From 26bbe66288c63fc55bc9185224c3078b7d6b946e Mon Sep 17 00:00:00 2001 From: Perttu Ahola Date: Thu, 19 May 2011 20:10:17 +0300 Subject: [PATCH] Moved the temporary mapgen test files and added a modified map.cpp too... These are probably useful in the next mapgen update and shouldn't be lost. --HG-- rename : src/noise.cpp.new => misc/noise.cpp rename : src/noise.h.new => misc/noise.h --- misc/map.cpp | 6393 +++++++++++++++++++++++++++ src/noise.cpp.new => misc/noise.cpp | 0 src/noise.h.new => misc/noise.h | 0 3 files changed, 6393 insertions(+) create mode 100644 misc/map.cpp rename src/noise.cpp.new => misc/noise.cpp (100%) rename src/noise.h.new => misc/noise.h (100%) diff --git a/misc/map.cpp b/misc/map.cpp new file mode 100644 index 000000000..78a849fd5 --- /dev/null +++ b/misc/map.cpp @@ -0,0 +1,6393 @@ +/* +Minetest-c55 +Copyright (C) 2010-2011 celeron55, Perttu Ahola + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "map.h" +#include "main.h" +#include "jmutexautolock.h" +#include "client.h" +#include "filesys.h" +#include "utility.h" +#include "voxel.h" +#include "porting.h" +#include "mineral.h" +#include "noise.h" +#include "serverobject.h" + +/* + Map +*/ + +Map::Map(std::ostream &dout): + m_dout(dout), + m_sector_cache(NULL) +{ + /*m_sector_mutex.Init(); + assert(m_sector_mutex.IsInitialized());*/ +} + +Map::~Map() +{ + /* + Free all MapSectors + */ + core::map::Iterator i = m_sectors.getIterator(); + for(; i.atEnd() == false; i++) + { + MapSector *sector = i.getNode()->getValue(); + delete sector; + } +} + +void Map::addEventReceiver(MapEventReceiver *event_receiver) +{ + m_event_receivers.insert(event_receiver, false); +} + +void Map::removeEventReceiver(MapEventReceiver *event_receiver) +{ + if(m_event_receivers.find(event_receiver) == NULL) + return; + m_event_receivers.remove(event_receiver); +} + +void Map::dispatchEvent(MapEditEvent *event) +{ + for(core::map::Iterator + i = m_event_receivers.getIterator(); + i.atEnd()==false; i++) + { + MapEventReceiver* event_receiver = i.getNode()->getKey(); + event_receiver->onMapEditEvent(event); + } +} + +MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p) +{ + if(m_sector_cache != NULL && p == m_sector_cache_p){ + MapSector * sector = m_sector_cache; + // Reset inactivity timer + sector->usage_timer = 0.0; + return sector; + } + + core::map::Node *n = m_sectors.find(p); + + if(n == NULL) + return NULL; + + MapSector *sector = n->getValue(); + + // Cache the last result + m_sector_cache_p = p; + m_sector_cache = sector; + + // Reset inactivity timer + sector->usage_timer = 0.0; + return sector; +} + +MapSector * Map::getSectorNoGenerateNoEx(v2s16 p) +{ + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out + + return getSectorNoGenerateNoExNoLock(p); +} + +MapSector * Map::getSectorNoGenerate(v2s16 p) +{ + MapSector *sector = getSectorNoGenerateNoEx(p); + if(sector == NULL) + throw InvalidPositionException(); + + return sector; +} + +MapBlock * Map::getBlockNoCreate(v3s16 p3d) +{ + v2s16 p2d(p3d.X, p3d.Z); + MapSector * sector = getSectorNoGenerate(p2d); + + MapBlock *block = sector->getBlockNoCreate(p3d.Y); + + return block; +} + +MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d) +{ + try + { + v2s16 p2d(p3d.X, p3d.Z); + MapSector * sector = getSectorNoGenerate(p2d); + MapBlock *block = sector->getBlockNoCreate(p3d.Y); + return block; + } + catch(InvalidPositionException &e) + { + return NULL; + } +} + +/*MapBlock * Map::getBlockCreate(v3s16 p3d) +{ + v2s16 p2d(p3d.X, p3d.Z); + MapSector * sector = getSectorCreate(p2d); + assert(sector); + MapBlock *block = sector->getBlockNoCreate(p3d.Y); + if(block) + return block; + block = sector->createBlankBlock(p3d.Y); + return block; +}*/ + +bool Map::isNodeUnderground(v3s16 p) +{ + v3s16 blockpos = getNodeBlockPos(p); + try{ + MapBlock * block = getBlockNoCreate(blockpos); + return block->getIsUnderground(); + } + catch(InvalidPositionException &e) + { + return false; + } +} + +/* + Goes recursively through the neighbours of the node. + + Alters only transparent nodes. + + If the lighting of the neighbour is lower than the lighting of + the node was (before changing it to 0 at the step before), the + lighting of the neighbour is set to 0 and then the same stuff + repeats for the neighbour. + + The ending nodes of the routine are stored in light_sources. + This is useful when a light is removed. In such case, this + routine can be called for the light node and then again for + light_sources to re-light the area without the removed light. + + values of from_nodes are lighting values. +*/ +void Map::unspreadLight(enum LightBank bank, + core::map & from_nodes, + core::map & light_sources, + core::map & modified_blocks) +{ + v3s16 dirs[6] = { + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + + if(from_nodes.size() == 0) + return; + + u32 blockchangecount = 0; + + core::map unlighted_nodes; + core::map::Iterator j; + j = from_nodes.getIterator(); + + /* + Initialize block cache + */ + v3s16 blockpos_last; + MapBlock *block = NULL; + // Cache this a bit, too + bool block_checked_in_modified = false; + + for(; j.atEnd() == false; j++) + { + v3s16 pos = j.getNode()->getKey(); + v3s16 blockpos = getNodeBlockPos(pos); + + // Only fetch a new block if the block position has changed + try{ + if(block == NULL || blockpos != blockpos_last){ + block = getBlockNoCreate(blockpos); + blockpos_last = blockpos; + + block_checked_in_modified = false; + blockchangecount++; + } + } + catch(InvalidPositionException &e) + { + continue; + } + + if(block->isDummy()) + continue; + + // Calculate relative position in block + v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE; + + // Get node straight from the block + MapNode n = block->getNode(relpos); + + u8 oldlight = j.getNode()->getValue(); + + // Loop through 6 neighbors + for(u16 i=0; i<6; i++) + { + // Get the position of the neighbor node + v3s16 n2pos = pos + dirs[i]; + + // Get the block where the node is located + v3s16 blockpos = getNodeBlockPos(n2pos); + + try + { + // Only fetch a new block if the block position has changed + try{ + if(block == NULL || blockpos != blockpos_last){ + block = getBlockNoCreate(blockpos); + blockpos_last = blockpos; + + block_checked_in_modified = false; + blockchangecount++; + } + } + catch(InvalidPositionException &e) + { + continue; + } + + // Calculate relative position in block + v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE; + // Get node straight from the block + MapNode n2 = block->getNode(relpos); + + bool changed = false; + + //TODO: Optimize output by optimizing light_sources? + + /* + If the neighbor is dimmer than what was specified + as oldlight (the light of the previous node) + */ + if(n2.getLight(bank) < oldlight) + { + /* + And the neighbor is transparent and it has some light + */ + if(n2.light_propagates() && n2.getLight(bank) != 0) + { + /* + Set light to 0 and add to queue + */ + + u8 current_light = n2.getLight(bank); + n2.setLight(bank, 0); + block->setNode(relpos, n2); + + unlighted_nodes.insert(n2pos, current_light); + changed = true; + + /* + Remove from light_sources if it is there + NOTE: This doesn't happen nearly at all + */ + /*if(light_sources.find(n2pos)) + { + std::cout<<"Removed from light_sources"< 0) + unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks); +} + +/* + A single-node wrapper of the above +*/ +void Map::unLightNeighbors(enum LightBank bank, + v3s16 pos, u8 lightwas, + core::map & light_sources, + core::map & modified_blocks) +{ + core::map from_nodes; + from_nodes.insert(pos, lightwas); + + unspreadLight(bank, from_nodes, light_sources, modified_blocks); +} + +/* + Lights neighbors of from_nodes, collects all them and then + goes on recursively. +*/ +void Map::spreadLight(enum LightBank bank, + core::map & from_nodes, + core::map & modified_blocks) +{ + const v3s16 dirs[6] = { + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + + if(from_nodes.size() == 0) + return; + + u32 blockchangecount = 0; + + core::map lighted_nodes; + core::map::Iterator j; + j = from_nodes.getIterator(); + + /* + Initialize block cache + */ + v3s16 blockpos_last; + MapBlock *block = NULL; + // Cache this a bit, too + bool block_checked_in_modified = false; + + for(; j.atEnd() == false; j++) + //for(; j != from_nodes.end(); j++) + { + v3s16 pos = j.getNode()->getKey(); + //v3s16 pos = *j; + //dstream<<"pos=("<isDummy()) + continue; + + // Calculate relative position in block + v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE; + + // Get node straight from the block + MapNode n = block->getNode(relpos); + + u8 oldlight = n.getLight(bank); + u8 newlight = diminish_light(oldlight); + + // Loop through 6 neighbors + for(u16 i=0; i<6; i++){ + // Get the position of the neighbor node + v3s16 n2pos = pos + dirs[i]; + + // Get the block where the node is located + v3s16 blockpos = getNodeBlockPos(n2pos); + + try + { + // Only fetch a new block if the block position has changed + try{ + if(block == NULL || blockpos != blockpos_last){ + block = getBlockNoCreate(blockpos); + blockpos_last = blockpos; + + block_checked_in_modified = false; + blockchangecount++; + } + } + catch(InvalidPositionException &e) + { + continue; + } + + // Calculate relative position in block + v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE; + // Get node straight from the block + MapNode n2 = block->getNode(relpos); + + bool changed = false; + /* + If the neighbor is brighter than the current node, + add to list (it will light up this node on its turn) + */ + if(n2.getLight(bank) > undiminish_light(oldlight)) + { + lighted_nodes.insert(n2pos, true); + //lighted_nodes.push_back(n2pos); + changed = true; + } + /* + If the neighbor is dimmer than how much light this node + would spread on it, add to list + */ + if(n2.getLight(bank) < newlight) + { + if(n2.light_propagates()) + { + n2.setLight(bank, newlight); + block->setNode(relpos, n2); + lighted_nodes.insert(n2pos, true); + //lighted_nodes.push_back(n2pos); + changed = true; + } + } + + // Add to modified_blocks + if(changed == true && block_checked_in_modified == false) + { + // If the block is not found in modified_blocks, add. + if(modified_blocks.find(blockpos) == NULL) + { + modified_blocks.insert(blockpos, block); + } + block_checked_in_modified = true; + } + } + catch(InvalidPositionException &e) + { + continue; + } + } + } + + /*dstream<<"spreadLight(): Changed block " + < 0) + spreadLight(bank, lighted_nodes, modified_blocks); +} + +/* + A single-node source variation of the above. +*/ +void Map::lightNeighbors(enum LightBank bank, + v3s16 pos, + core::map & modified_blocks) +{ + core::map from_nodes; + from_nodes.insert(pos, true); + spreadLight(bank, from_nodes, modified_blocks); +} + +v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p) +{ + v3s16 dirs[6] = { + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + + u8 brightest_light = 0; + v3s16 brightest_pos(0,0,0); + bool found_something = false; + + // Loop through 6 neighbors + for(u16 i=0; i<6; i++){ + // Get the position of the neighbor node + v3s16 n2pos = p + dirs[i]; + MapNode n2; + try{ + n2 = getNode(n2pos); + } + catch(InvalidPositionException &e) + { + continue; + } + if(n2.getLight(bank) > brightest_light || found_something == false){ + brightest_light = n2.getLight(bank); + brightest_pos = n2pos; + found_something = true; + } + } + + if(found_something == false) + throw InvalidPositionException(); + + return brightest_pos; +} + +/* + Propagates sunlight down from a node. + Starting point gets sunlight. + + Returns the lowest y value of where the sunlight went. + + Mud is turned into grass in where the sunlight stops. +*/ +s16 Map::propagateSunlight(v3s16 start, + core::map & modified_blocks) +{ + s16 y = start.Y; + for(; ; y--) + { + v3s16 pos(start.X, y, start.Z); + + v3s16 blockpos = getNodeBlockPos(pos); + MapBlock *block; + try{ + block = getBlockNoCreate(blockpos); + } + catch(InvalidPositionException &e) + { + break; + } + + v3s16 relpos = pos - blockpos*MAP_BLOCKSIZE; + MapNode n = block->getNode(relpos); + + if(n.sunlight_propagates()) + { + n.setLight(LIGHTBANK_DAY, LIGHT_SUN); + block->setNode(relpos, n); + + modified_blocks.insert(blockpos, block); + } + else + { + // Turn mud into grass + if(n.d == CONTENT_MUD) + { + n.d = CONTENT_GRASS; + block->setNode(relpos, n); + modified_blocks.insert(blockpos, block); + } + + // Sunlight goes no further + break; + } + } + return y + 1; +} + +void Map::updateLighting(enum LightBank bank, + core::map & a_blocks, + core::map & modified_blocks) +{ + /*m_dout< blocks_to_update; + + core::map light_sources; + + core::map unlight_from; + + core::map::Iterator i; + i = a_blocks.getIterator(); + for(; i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + + for(;;) + { + // Don't bother with dummy blocks. + if(block->isDummy()) + break; + + v3s16 pos = block->getPos(); + modified_blocks.insert(pos, block); + + blocks_to_update.insert(pos, block); + + /* + Clear all light from block + */ + for(s16 z=0; zgetNode(v3s16(x,y,z)); + u8 oldlight = n.getLight(bank); + n.setLight(bank, 0); + block->setNode(v3s16(x,y,z), n); + + // Collect borders for unlighting + if(x==0 || x == MAP_BLOCKSIZE-1 + || y==0 || y == MAP_BLOCKSIZE-1 + || z==0 || z == MAP_BLOCKSIZE-1) + { + v3s16 p_map = p + v3s16( + MAP_BLOCKSIZE*pos.X, + MAP_BLOCKSIZE*pos.Y, + MAP_BLOCKSIZE*pos.Z); + unlight_from.insert(p_map, oldlight); + } + } + catch(InvalidPositionException &e) + { + /* + This would happen when dealing with a + dummy block. + */ + //assert(0); + dstream<<"updateLighting(): InvalidPositionException" + <propagateSunlight(light_sources); + + // If bottom is valid, we're done. + if(bottom_valid) + break; + } + else if(bank == LIGHTBANK_NIGHT) + { + // For night lighting, sunlight is not propagated + break; + } + else + { + // Invalid lighting bank + assert(0); + } + + /*dstream<<"Bottom for sunlight-propagated block (" + <::Iterator i; + i = blocks_to_update.getIterator(); + for(; i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + v3s16 p = block->getPos(); + + // Add all surrounding blocks + vmanip.initialEmerge(p - v3s16(1,1,1), p + v3s16(1,1,1)); + + /* + Add all surrounding blocks that have up-to-date lighting + NOTE: This doesn't quite do the job (not everything + appropriate is lighted) + */ + /*for(s16 z=-1; z<=1; z++) + for(s16 y=-1; y<=1; y++) + for(s16 x=-1; x<=1; x++) + { + v3s16 p(x,y,z); + MapBlock *block = getBlockNoCreateNoEx(p); + if(block == NULL) + continue; + if(block->isDummy()) + continue; + if(block->getLightingExpired()) + continue; + vmanip.initialEmerge(p, p); + }*/ + + // Lighting of block will be updated completely + block->setLightingExpired(false); + } + + { + //TimeTaker timer("unSpreadLight"); + vmanip.unspreadLight(bank, unlight_from, light_sources); + } + { + //TimeTaker timer("spreadLight"); + vmanip.spreadLight(bank, light_sources); + } + { + //TimeTaker timer("blitBack"); + vmanip.blitBack(modified_blocks); + } + /*dstream<<"emerge_time="< & a_blocks, + core::map & modified_blocks) +{ + updateLighting(LIGHTBANK_DAY, a_blocks, modified_blocks); + updateLighting(LIGHTBANK_NIGHT, a_blocks, modified_blocks); + + /* + Update information about whether day and night light differ + */ + for(core::map::Iterator + i = modified_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + block->updateDayNightDiff(); + } +} + +/* + This is called after changing a node from transparent to opaque. + The lighting value of the node should be left as-is after changing + other values. This sets the lighting value to 0. +*/ +void Map::addNodeAndUpdate(v3s16 p, MapNode n, + core::map &modified_blocks) +{ + /*PrintInfo(m_dout); + m_dout< light_sources; + + /* + If there is a node at top and it doesn't have sunlight, + there has not been any sunlight going down. + + Otherwise there probably is. + */ + try{ + MapNode topnode = getNode(toppos); + + if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN) + node_under_sunlight = false; + } + catch(InvalidPositionException &e) + { + } + + /* + If the new node doesn't propagate sunlight and there is + grass below, change it to mud + */ + if(content_features(n.d).sunlight_propagates == false) + { + try{ + MapNode bottomnode = getNode(bottompos); + + if(bottomnode.d == CONTENT_GRASS + || bottomnode.d == CONTENT_GRASS_FOOTSTEPS) + { + bottomnode.d = CONTENT_MUD; + setNode(bottompos, bottomnode); + } + } + catch(InvalidPositionException &e) + { + } + } + + /* + If the new node is mud and it is under sunlight, change it + to grass + */ + if(n.d == CONTENT_MUD && node_under_sunlight) + { + n.d = CONTENT_GRASS; + } + + /* + Remove all light that has come out of this node + */ + + enum LightBank banks[] = + { + LIGHTBANK_DAY, + LIGHTBANK_NIGHT + }; + for(s32 i=0; i<2; i++) + { + enum LightBank bank = banks[i]; + + u8 lightwas = getNode(p).getLight(bank); + + // Add the block of the added node to modified_blocks + v3s16 blockpos = getNodeBlockPos(p); + MapBlock * block = getBlockNoCreate(blockpos); + assert(block != NULL); + modified_blocks.insert(blockpos, block); + + assert(isValidPosition(p)); + + // Unlight neighbours of node. + // This means setting light of all consequent dimmer nodes + // to 0. + // This also collects the nodes at the border which will spread + // light again into this. + unLightNeighbors(bank, p, lightwas, light_sources, modified_blocks); + + n.setLight(bank, 0); + } + + /* + If node lets sunlight through and is under sunlight, it has + sunlight too. + */ + if(node_under_sunlight && content_features(n.d).sunlight_propagates) + { + n.setLight(LIGHTBANK_DAY, LIGHT_SUN); + } + + /* + Set the node on the map + */ + + setNode(p, n); + + /* + Add intial metadata + */ + + NodeMetadata *meta_proto = content_features(n.d).initial_metadata; + if(meta_proto) + { + NodeMetadata *meta = meta_proto->clone(); + setNodeMetadata(p, meta); + } + + /* + If node is under sunlight and doesn't let sunlight through, + take all sunlighted nodes under it and clear light from them + and from where the light has been spread. + TODO: This could be optimized by mass-unlighting instead + of looping + */ + if(node_under_sunlight && !content_features(n.d).sunlight_propagates) + { + s16 y = p.Y - 1; + for(;; y--){ + //m_dout<::Iterator + i = modified_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + block->updateDayNightDiff(); + } + + /* + Add neighboring liquid nodes and the node itself if it is + liquid (=water node was added) to transform queue. + */ + v3s16 dirs[7] = { + v3s16(0,0,0), // self + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + for(u16 i=0; i<7; i++) + { + try + { + + v3s16 p2 = p + dirs[i]; + + MapNode n2 = getNode(p2); + if(content_liquid(n2.d)) + { + m_transforming_liquid.push_back(p2); + } + + }catch(InvalidPositionException &e) + { + } + } +} + +/* +*/ +void Map::removeNodeAndUpdate(v3s16 p, + core::map &modified_blocks) +{ + /*PrintInfo(m_dout); + m_dout< light_sources; + + enum LightBank banks[] = + { + LIGHTBANK_DAY, + LIGHTBANK_NIGHT + }; + for(s32 i=0; i<2; i++) + { + enum LightBank bank = banks[i]; + + /* + Unlight neighbors (in case the node is a light source) + */ + unLightNeighbors(bank, p, + getNode(p).getLight(bank), + light_sources, modified_blocks); + } + + /* + Remove node metadata + */ + + removeNodeMetadata(p); + + /* + Remove the node. + This also clears the lighting. + */ + + MapNode n; + n.d = replace_material; + setNode(p, n); + + for(s32 i=0; i<2; i++) + { + enum LightBank bank = banks[i]; + + /* + Recalculate lighting + */ + spreadLight(bank, light_sources, modified_blocks); + } + + // Add the block of the removed node to modified_blocks + v3s16 blockpos = getNodeBlockPos(p); + MapBlock * block = getBlockNoCreate(blockpos); + assert(block != NULL); + modified_blocks.insert(blockpos, block); + + /* + If the removed node was under sunlight, propagate the + sunlight down from it and then light all neighbors + of the propagated blocks. + */ + if(node_under_sunlight) + { + s16 ybottom = propagateSunlight(p, modified_blocks); + /*m_dout< ybottom="<= ybottom; y--) + { + v3s16 p2(p.X, y, p.Z); + /*m_dout<::Iterator + i = modified_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + block->updateDayNightDiff(); + } + + /* + Add neighboring liquid nodes to transform queue. + */ + v3s16 dirs[6] = { + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + for(u16 i=0; i<6; i++) + { + try + { + + v3s16 p2 = p + dirs[i]; + + MapNode n2 = getNode(p2); + if(content_liquid(n2.d)) + { + m_transforming_liquid.push_back(p2); + } + + }catch(InvalidPositionException &e) + { + } + } +} + +bool Map::addNodeWithEvent(v3s16 p, MapNode n) +{ + MapEditEvent event; + event.type = MEET_ADDNODE; + event.p = p; + event.n = n; + + bool succeeded = true; + try{ + core::map modified_blocks; + addNodeAndUpdate(p, n, modified_blocks); + + // Copy modified_blocks to event + for(core::map::Iterator + i = modified_blocks.getIterator(); + i.atEnd()==false; i++) + { + event.modified_blocks.insert(i.getNode()->getKey(), false); + } + } + catch(InvalidPositionException &e){ + succeeded = false; + } + + dispatchEvent(&event); + + return succeeded; +} + +bool Map::removeNodeWithEvent(v3s16 p) +{ + MapEditEvent event; + event.type = MEET_REMOVENODE; + event.p = p; + + bool succeeded = true; + try{ + core::map modified_blocks; + removeNodeAndUpdate(p, modified_blocks); + + // Copy modified_blocks to event + for(core::map::Iterator + i = modified_blocks.getIterator(); + i.atEnd()==false; i++) + { + event.modified_blocks.insert(i.getNode()->getKey(), false); + } + } + catch(InvalidPositionException &e){ + succeeded = false; + } + + dispatchEvent(&event); + + return succeeded; +} + +bool Map::dayNightDiffed(v3s16 blockpos) +{ + try{ + v3s16 p = blockpos + v3s16(0,0,0); + MapBlock *b = getBlockNoCreate(p); + if(b->dayNightDiffed()) + return true; + } + catch(InvalidPositionException &e){} + // Leading edges + try{ + v3s16 p = blockpos + v3s16(-1,0,0); + MapBlock *b = getBlockNoCreate(p); + if(b->dayNightDiffed()) + return true; + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,-1,0); + MapBlock *b = getBlockNoCreate(p); + if(b->dayNightDiffed()) + return true; + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,0,-1); + MapBlock *b = getBlockNoCreate(p); + if(b->dayNightDiffed()) + return true; + } + catch(InvalidPositionException &e){} + // Trailing edges + try{ + v3s16 p = blockpos + v3s16(1,0,0); + MapBlock *b = getBlockNoCreate(p); + if(b->dayNightDiffed()) + return true; + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,1,0); + MapBlock *b = getBlockNoCreate(p); + if(b->dayNightDiffed()) + return true; + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,0,1); + MapBlock *b = getBlockNoCreate(p); + if(b->dayNightDiffed()) + return true; + } + catch(InvalidPositionException &e){} + + return false; +} + +/* + Updates usage timers +*/ +void Map::timerUpdate(float dtime) +{ + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out + + core::map::Iterator si; + + si = m_sectors.getIterator(); + for(; si.atEnd() == false; si++) + { + MapSector *sector = si.getNode()->getValue(); + sector->usage_timer += dtime; + } +} + +void Map::deleteSectors(core::list &list, bool only_blocks) +{ + /* + Wait for caches to be removed before continuing. + + This disables the existence of caches while locked + */ + //SharedPtr cachelock(m_blockcachelock.waitCaches()); + + core::list::Iterator j; + for(j=list.begin(); j!=list.end(); j++) + { + MapSector *sector = m_sectors[*j]; + if(only_blocks) + { + sector->deleteBlocks(); + } + else + { + /* + If sector is in sector cache, remove it from there + */ + if(m_sector_cache == sector) + { + m_sector_cache = NULL; + } + /* + Remove from map and delete + */ + m_sectors.remove(*j); + delete sector; + } + } +} + +u32 Map::deleteUnusedSectors(float timeout, bool only_blocks, + core::list *deleted_blocks) +{ + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out + + core::list sector_deletion_queue; + core::map::Iterator i = m_sectors.getIterator(); + for(; i.atEnd() == false; i++) + { + MapSector *sector = i.getNode()->getValue(); + /* + Delete sector from memory if it hasn't been used in a long time + */ + if(sector->usage_timer > timeout) + { + sector_deletion_queue.push_back(i.getNode()->getKey()); + + if(deleted_blocks != NULL) + { + // Collect positions of blocks of sector + MapSector *sector = i.getNode()->getValue(); + core::list blocks; + sector->getBlocks(blocks); + for(core::list::Iterator i = blocks.begin(); + i != blocks.end(); i++) + { + deleted_blocks->push_back((*i)->getPos()); + } + } + } + } + deleteSectors(sector_deletion_queue, only_blocks); + return sector_deletion_queue.getSize(); +} + +void Map::PrintInfo(std::ostream &out) +{ + out<<"Map: "; +} + +#define WATER_DROP_BOOST 4 + +void Map::transformLiquids(core::map & modified_blocks) +{ + DSTACK(__FUNCTION_NAME); + //TimeTaker timer("transformLiquids()"); + + u32 loopcount = 0; + u32 initial_size = m_transforming_liquid.size(); + + /*if(initial_size != 0) + dstream<<"transformLiquids(): initial_size="<= 7 - WATER_DROP_BOOST) + new_liquid_level = 7; + else + new_liquid_level = n2_liquid_level + WATER_DROP_BOOST; + } + else if(n2_liquid_level > 0) + { + new_liquid_level = n2_liquid_level - 1; + } + + if(new_liquid_level > new_liquid_level_max) + new_liquid_level_max = new_liquid_level; + } + + }catch(InvalidPositionException &e) + { + } + } //for + + /* + If liquid level should be something else, update it and + add all the neighboring water nodes to the transform queue. + */ + if(new_liquid_level_max != liquid_level) + { + if(new_liquid_level_max == -1) + { + // Remove water alltoghether + n0.d = CONTENT_AIR; + n0.param2 = 0; + setNode(p0, n0); + } + else + { + n0.param2 = new_liquid_level_max; + setNode(p0, n0); + } + + // Block has been modified + { + v3s16 blockpos = getNodeBlockPos(p0); + MapBlock *block = getBlockNoCreateNoEx(blockpos); + if(block != NULL) + modified_blocks.insert(blockpos, block); + } + + /* + Add neighboring non-source liquid nodes to transform queue. + */ + v3s16 dirs[6] = { + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + for(u16 i=0; i<6; i++) + { + try + { + + v3s16 p2 = p0 + dirs[i]; + + MapNode n2 = getNode(p2); + if(content_flowing_liquid(n2.d)) + { + m_transforming_liquid.push_back(p2); + } + + }catch(InvalidPositionException &e) + { + } + } + } + } + + // Get a new one from queue if the node has turned into non-water + if(content_liquid(n0.d) == false) + continue; + + /* + Flow water from this node + */ + v3s16 dirs_to[5] = { + v3s16(0,-1,0), // bottom + v3s16(0,0,1), // back + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(-1,0,0), // left + }; + for(u16 i=0; i<5; i++) + { + try + { + + bool to_bottom = (i == 0); + + // If liquid is at lowest possible height, it's not going + // anywhere except down + if(liquid_level == 0 && to_bottom == false) + continue; + + u8 liquid_next_level = 0; + // If going to bottom + if(to_bottom) + { + //liquid_next_level = 7; + if(liquid_level >= 7 - WATER_DROP_BOOST) + liquid_next_level = 7; + else + liquid_next_level = liquid_level + WATER_DROP_BOOST; + } + else + liquid_next_level = liquid_level - 1; + + bool n2_changed = false; + bool flowed = false; + + v3s16 p2 = p0 + dirs_to[i]; + + MapNode n2 = getNode(p2); + //dstream<<"[1] n2.param="<<(int)n2.param< liquid_level) + { + n2.param2 = liquid_next_level; + setNode(p2, n2); + + n2_changed = true; + flowed = true; + } + } + } + else if(n2.d == CONTENT_AIR) + { + n2.d = nonsource_c; + n2.param2 = liquid_next_level; + setNode(p2, n2); + + n2_changed = true; + flowed = true; + } + + //dstream<<"[2] n2.param="<<(int)n2.param<= 100000) + if(loopcount >= initial_size * 1) + break; + } + //dstream<<"Map::transformLiquids(): loopcount="<m_node_metadata.get(p_rel); + return meta; +} + +void Map::setNodeMetadata(v3s16 p, NodeMetadata *meta) +{ + v3s16 blockpos = getNodeBlockPos(p); + v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE; + MapBlock *block = getBlockNoCreateNoEx(blockpos); + if(block == NULL) + { + dstream<<"WARNING: Map::setNodeMetadata(): Block not found" + <m_node_metadata.set(p_rel, meta); +} + +void Map::removeNodeMetadata(v3s16 p) +{ + v3s16 blockpos = getNodeBlockPos(p); + v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE; + MapBlock *block = getBlockNoCreateNoEx(blockpos); + if(block == NULL) + { + dstream<<"WARNING: Map::removeNodeMetadata(): Block not found" + <m_node_metadata.remove(p_rel); +} + +void Map::nodeMetadataStep(float dtime, + core::map &changed_blocks) +{ + /* + NOTE: + Currently there is no way to ensure that all the necessary + blocks are loaded when this is run. (They might get unloaded) + NOTE: ^- Actually, that might not be so. In a quick test it + reloaded a block with a furnace when I walked back to it from + a distance. + */ + core::map::Iterator si; + si = m_sectors.getIterator(); + for(; si.atEnd() == false; si++) + { + MapSector *sector = si.getNode()->getValue(); + core::list< MapBlock * > sectorblocks; + sector->getBlocks(sectorblocks); + core::list< MapBlock * >::Iterator i; + for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) + { + MapBlock *block = *i; + bool changed = block->m_node_metadata.step(dtime); + if(changed) + changed_blocks[block->getPos()] = block; + } + } +} + +/* + ServerMap +*/ + +ServerMap::ServerMap(std::string savedir): + Map(dout_server), + m_seed(0), + m_map_metadata_changed(true) +{ + dstream<<__FUNCTION_NAME<::Iterator i = m_chunks.getIterator(); + for(; i.atEnd() == false; i++) + { + MapChunk *chunk = i.getNode()->getValue(); + delete chunk; + } +} + +/* + Some helper functions for the map generator +*/ + +s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d) +{ + v3s16 em = vmanip.m_area.getExtent(); + s16 y_nodes_max = vmanip.m_area.MaxEdge.Y; + s16 y_nodes_min = vmanip.m_area.MinEdge.Y; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + s16 y; + for(y=y_nodes_max; y>=y_nodes_min; y--) + { + MapNode &n = vmanip.m_data[i]; + if(content_walkable(n.d)) + break; + + vmanip.m_area.add_y(em, i, -1); + } + if(y >= y_nodes_min) + return y; + else + return y_nodes_min; +} + +s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d) +{ + v3s16 em = vmanip.m_area.getExtent(); + s16 y_nodes_max = vmanip.m_area.MaxEdge.Y; + s16 y_nodes_min = vmanip.m_area.MinEdge.Y; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + s16 y; + for(y=y_nodes_max; y>=y_nodes_min; y--) + { + MapNode &n = vmanip.m_data[i]; + if(content_walkable(n.d) + && n.d != CONTENT_TREE + && n.d != CONTENT_LEAVES) + break; + + vmanip.m_area.add_y(em, i, -1); + } + if(y >= y_nodes_min) + return y; + else + return y_nodes_min; +} + +void make_tree(VoxelManipulator &vmanip, v3s16 p0) +{ + MapNode treenode(CONTENT_TREE); + MapNode leavesnode(CONTENT_LEAVES); + + s16 trunk_h = myrand_range(3, 6); + v3s16 p1 = p0; + for(s16 ii=0; ii leaves_d(new u8[leaves_a.getVolume()]); + Buffer leaves_d(leaves_a.getVolume()); + for(s32 i=0; i0, 0->1, 1->0 +double contour(double v) +{ + v = fabs(v); + if(v >= 1.0) + return 0.0; + return (1.0-v); +}*/ + +/* + Noise functions. Make sure seed is mangled differently in each one. +*/ + +// This affects the shape of the contour +#define CAVE_NOISE_SCALE 10.0 + +NoiseParams get_cave_noise1_params(u64 seed) +{ + return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 5, 0.7, + 200, CAVE_NOISE_SCALE); +} + +NoiseParams get_cave_noise2_params(u64 seed) +{ + return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 5, 0.7, + 200, CAVE_NOISE_SCALE); +} + +#define CAVE_NOISE_THRESHOLD (2.5/CAVE_NOISE_SCALE) + +bool is_cave(u64 seed, v3s16 p) +{ + double d1 = noise3d_param(get_cave_noise1_params(seed), p.X,p.Y,p.Z); + double d2 = noise3d_param(get_cave_noise2_params(seed), p.X,p.Y,p.Z); + return d1*d2 > CAVE_NOISE_THRESHOLD; +} + +// Amount of trees per area in nodes +double tree_amount_2d(u64 seed, v2s16 p) +{ + double noise = noise2d_perlin( + 0.5+(float)p.X/250, 0.5+(float)p.Y/250, + seed+2, 5, 0.66); + double zeroval = -0.3; + if(noise < zeroval) + return 0; + else + return 0.04 * (noise-zeroval) / (1.0-zeroval); +} + +#define AVERAGE_MUD_AMOUNT 4 + +double base_rock_level_2d(u64 seed, v2s16 p) +{ + // The base ground level + double base = (double)WATER_LEVEL - (double)AVERAGE_MUD_AMOUNT + + 20. * noise2d_perlin( + 0.5+(float)p.X/500., 0.5+(float)p.Y/500., + (seed>>32)+654879876, 6, 0.6); + + /*// A bit hillier one + double base2 = WATER_LEVEL - 4.0 + 40. * noise2d_perlin( + 0.5+(float)p.X/250., 0.5+(float)p.Y/250., + (seed>>27)+90340, 6, 0.69); + if(base2 > base) + base = base2;*/ +#if 1 + // Higher ground level + double higher = (double)WATER_LEVEL + 25. + 35. * noise2d_perlin( + 0.5+(float)p.X/250., 0.5+(float)p.Y/250., + seed+85039, 5, 0.69); + //higher = 30; // For debugging + + // Limit higher to at least base + if(higher < base) + higher = base; + + // Steepness factor of cliffs + double b = 1.0 + 1.0 * noise2d_perlin( + 0.5+(float)p.X/250., 0.5+(float)p.Y/250., + seed-932, 7, 0.7); + b = rangelim(b, 0.0, 1000.0); + b = pow(b, 5); + b *= 7; + b = rangelim(b, 3.0, 1000.0); + //dstream<<"b="<sectorpos_bigbase.X*MAP_BLOCKSIZE, + y_nodes_min, + data->sectorpos_bigbase.Y*MAP_BLOCKSIZE + ); + v3f maxpos_f = minpos_f + v3f( + data->sectorpos_bigbase_size*MAP_BLOCKSIZE, + y_nodes_max-y_nodes_min, + data->sectorpos_bigbase_size*MAP_BLOCKSIZE + ); + //v3f samplelength_f = v3f(4.0, 4.0, 4.0); + + TimeTaker timer("noisebuf.create"); + + noisebuf_cave.create(get_cave_noise1_params(data->seed), + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + 4, 4, 4); + + noisebuf_cave.multiply(get_cave_noise2_params(data->seed)); + + /*noisebuf1.create(data->seed+25104, 6, 0.60, 200.0, false, + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + samplelength_f.X, samplelength_f.Y, samplelength_f.Z);*/ + /*noisebuf1.create(data->seed+25104, 3, 0.60, 25.0, false, + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + samplelength_f.X, samplelength_f.Y, samplelength_f.Z); + noisebuf2.create(data->seed+25105, 4, 0.50, 200.0, false, + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + samplelength_f.X, samplelength_f.Y, samplelength_f.Z);*/ + } + +#if 0 + for(s16 x=0; xsectorpos_bigbase_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_bigbase_size*MAP_BLOCKSIZE; z++) + { + // Node position + v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + + // Ground height at this point + float surface_y_f = 0.0; + + // Use perlin noise for ground height + surface_y_f = base_rock_level_2d(data->seed, p2d); + //surface_y_f = base_rock_level_2d(data->seed, p2d); + + // Convert to integer + s16 surface_y = (s16)surface_y_f; + + // Log it + if(surface_y > stone_surface_max_y) + stone_surface_max_y = surface_y; + + /* + Fill ground with stone + */ + { + // Use fast index incrementing + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); + for(s16 y=y_nodes_min; y<=y_nodes_max; y++) + { + // Skip if already generated. + // This is done here because there might be a cave at + // any point in ground, which could look like it + // wasn't generated. + if(data->vmanip.m_data[i].d != CONTENT_AIR) + break; + + /*s16 noiseval = 50.0 * noise3d_perlin( + 0.5+(float)p2d.X/100.0, + 0.5+(float)y/100.0, + 0.5+(float)p2d.Y/100.0, + data->seed+123, 5, 0.5);*/ + double noiseval = 64.0 * noisebuf1.get(p2d.X, y, p2d.Y); + /*double noiseval = 30.0 * noisebuf1.get(p2d.X, y, p2d.Y); + noiseval *= MYMAX(0, -0.2 + noisebuf2.get(p2d.X, y, p2d.Y));*/ + + //if(y < surface_y + noiseval) + if(noiseval > 0) + //if(noiseval > y) + data->vmanip.m_data[i].d = CONTENT_STONE; + + data->vmanip.m_area.add_y(em, i, 1); + } + } + } +#endif + +#if 1 + for(s16 x=0; xsectorpos_bigbase_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_bigbase_size*MAP_BLOCKSIZE; z++) + { + // Node position + v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + + /* + Skip of already generated + */ + /*{ + v3s16 p(p2d.X, y_nodes_min, p2d.Y); + if(data->vmanip.m_data[data->vmanip.m_area.index(p)].d != CONTENT_AIR) + continue; + }*/ + +#define CAVE_TEST 0 + +#if CAVE_TEST + /* + Fill ground with stone + */ + { + // Use fast index incrementing + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); + for(s16 y=y_nodes_min; y<=y_nodes_max; y++) + { + // Skip if already generated. + // This is done here because there might be a cave at + // any point in ground, which could look like it + // wasn't generated. + if(data->vmanip.m_data[i].d != CONTENT_AIR) + break; + + //if(is_cave(data->seed, v3s16(p2d.X, y, p2d.Y))) + if(noisebuf_cave.get(p2d.X,y,p2d.Y) > CAVE_NOISE_THRESHOLD) + { + data->vmanip.m_data[i].d = CONTENT_STONE; + } + else + { + data->vmanip.m_data[i].d = CONTENT_AIR; + } + + data->vmanip.m_area.add_y(em, i, 1); + } + } +#else + // Ground height at this point + float surface_y_f = 0.0; + + // Use perlin noise for ground height + surface_y_f = base_rock_level_2d(data->seed, p2d); + + // Convert to integer + s16 surface_y = (s16)surface_y_f; + + // Log it + if(surface_y > stone_surface_max_y) + stone_surface_max_y = surface_y; + + /* + Fill ground with stone + */ + { + // Use fast index incrementing + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); + for(s16 y=y_nodes_min; yvmanip.m_data[i].d != CONTENT_AIR) + break; + + //if(is_cave(data->seed, v3s16(p2d.X, y, p2d.Y))) + if(noisebuf_cave.get(p2d.X,y,p2d.Y) > CAVE_NOISE_THRESHOLD) + { + // Set tunnel flag + data->vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON; + // Is now air + data->vmanip.m_data[i].d = CONTENT_AIR; + } + else + { + data->vmanip.m_data[i].d = CONTENT_STONE; + } + + data->vmanip.m_area.add_y(em, i, 1); + } + } +#endif // !CAVE_TEST + } +#endif + + }//timer1 + + /* + Randomize some parameters + */ + + //s32 stone_obstacle_count = 0; + /*s32 stone_obstacle_count = + rangelim((1.0+noise2d(data->seed+897, + data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ + + //s16 stone_obstacle_max_height = 0; + /*s16 stone_obstacle_max_height = + rangelim((1.0+noise2d(data->seed+5902, + data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ + + // Set to 0 to disable everything but lighting +#if 1 + + /* + Loop this part, it will make stuff look older and newer nicely + */ + const u32 age_loops = 2; + for(u32 i_age=0; i_age caves_count); + + if(bruise_surface) + { + min_tunnel_diameter = 5; + max_tunnel_diameter = myrand_range(10, 20); + /*min_tunnel_diameter = MYMAX(0, stone_surface_max_y/6); + max_tunnel_diameter = myrand_range(MYMAX(0, stone_surface_max_y/6), MYMAX(0, stone_surface_max_y/2));*/ + + /*s16 tunnel_rou = rangelim(25*(0.5+1.0*noise2d(data->seed+42, + data->sectorpos_base.X, data->sectorpos_base.Y)), 0, 15);*/ + + tunnel_routepoints = 5; + } + else + { + } + + // Allowed route area size in nodes + v3s16 ar( + data->sectorpos_base_size*MAP_BLOCKSIZE, + h_blocks*MAP_BLOCKSIZE, + data->sectorpos_base_size*MAP_BLOCKSIZE + ); + + // Area starting point in nodes + v3s16 of( + data->sectorpos_base.X*MAP_BLOCKSIZE, + data->y_blocks_min*MAP_BLOCKSIZE, + data->sectorpos_base.Y*MAP_BLOCKSIZE + ); + + // Allow a bit more + //(this should be more than the maximum radius of the tunnel) + //s16 insure = 5; // Didn't work with max_d = 20 + s16 insure = 10; + s16 more = data->max_spread_amount - max_tunnel_diameter/2 - insure; + ar += v3s16(1,0,1) * more * 2; + of -= v3s16(1,0,1) * more; + + s16 route_y_min = 0; + // Allow half a diameter + 7 over stone surface + s16 route_y_max = -of.Y + stone_surface_max_y + max_tunnel_diameter/2 + 7; + + /*// If caves, don't go through surface too often + if(bruise_surface == false) + route_y_max -= myrand_range(0, max_tunnel_diameter*2);*/ + + // Limit maximum to area + route_y_max = rangelim(route_y_max, 0, ar.Y-1); + + if(bruise_surface) + { + /*// Minimum is at y=0 + route_y_min = -of.Y - 0;*/ + // Minimum is at y=max_tunnel_diameter/4 + //route_y_min = -of.Y + max_tunnel_diameter/4; + //s16 min = -of.Y + max_tunnel_diameter/4; + s16 min = -of.Y + 0; + route_y_min = myrand_range(min, min + max_tunnel_diameter); + route_y_min = rangelim(route_y_min, 0, route_y_max); + } + + /*dstream<<"route_y_min = "<vmanip.m_area.index(p); + data->vmanip.m_data[i] = airnode; + + if(bruise_surface == false) + { + // Set tunnel flag + data->vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON; + } + } + } + } + } + + orp = rp; + } + + } + + }//timer1 +#endif + +#if 1 + { + // 46ms @cs=8 + //TimeTaker timer1("ore veins"); + + /* + Make ore veins + */ + for(u32 jj=0; jjsectorpos_base_size*MAP_BLOCKSIZE, + h_blocks*MAP_BLOCKSIZE, + data->sectorpos_base_size*MAP_BLOCKSIZE + ); + + // Area starting point in nodes + v3s16 of( + data->sectorpos_base.X*MAP_BLOCKSIZE, + data->y_blocks_min*MAP_BLOCKSIZE, + data->sectorpos_base.Y*MAP_BLOCKSIZE + ); + + // Allow a bit more + //(this should be more than the maximum radius of the tunnel) + s16 insure = 3; + s16 more = data->max_spread_amount - max_vein_diameter/2 - insure; + ar += v3s16(1,0,1) * more * 2; + of -= v3s16(1,0,1) * more; + + // Randomize starting position + v3f orp( + (float)(myrand()%ar.X)+0.5, + (float)(myrand()%ar.Y)+0.5, + (float)(myrand()%ar.Z)+0.5 + ); + + // Randomize mineral + u8 mineral; + if(myrand()%3 != 0) + mineral = MINERAL_COAL; + else + mineral = MINERAL_IRON; + + /* + Generate some vein starting from orp + */ + + for(u16 j=0; j<2; j++) + { + /*v3f rp( + (float)(myrand()%ar.X)+0.5, + (float)(myrand()%ar.Y)+0.5, + (float)(myrand()%ar.Z)+0.5 + ); + v3f vec = rp - orp;*/ + + v3s16 maxlen(5, 5, 5); + v3f vec( + (float)(myrand()%(maxlen.X*2))-(float)maxlen.X, + (float)(myrand()%(maxlen.Y*2))-(float)maxlen.Y, + (float)(myrand()%(maxlen.Z*2))-(float)maxlen.Z + ); + v3f rp = orp + vec; + if(rp.X < 0) + rp.X = 0; + else if(rp.X >= ar.X) + rp.X = ar.X; + if(rp.Y < 0) + rp.Y = 0; + else if(rp.Y >= ar.Y) + rp.Y = ar.Y; + if(rp.Z < 0) + rp.Z = 0; + else if(rp.Z >= ar.Z) + rp.Z = ar.Z; + vec = rp - orp; + + // Randomize size + s16 min_d = 0; + s16 max_d = max_vein_diameter; + s16 rs = myrand_range(min_d, max_d); + + for(float f=0; f<1.0; f+=1.0/vec.getLength()) + { + v3f fp = orp + vec * f; + v3s16 cp(fp.X, fp.Y, fp.Z); + s16 d0 = -rs/2; + s16 d1 = d0 + rs - 1; + for(s16 z0=d0; z0<=d1; z0++) + { + s16 si = rs - abs(z0); + for(s16 x0=-si; x0<=si-1; x0++) + { + s16 si2 = rs - abs(x0); + for(s16 y0=-si2+1; y0<=si2-1; y0++) + { + // Don't put mineral to every place + if(myrand()%5 != 0) + continue; + + s16 z = cp.Z + z0; + s16 y = cp.Y + y0; + s16 x = cp.X + x0; + v3s16 p(x,y,z); + /*if(isInArea(p, ar) == false) + continue;*/ + // Check only height + if(y < 0 || y >= ar.Y) + continue; + p += of; + + assert(data->vmanip.m_area.contains(p)); + + // Just set it to air, it will be changed to + // water afterwards + u32 i = data->vmanip.m_area.index(p); + MapNode *n = &data->vmanip.m_data[i]; + if(n->d == CONTENT_STONE) + n->param = mineral; + } + } + } + } + + orp = rp; + } + + } + + }//timer1 +#endif + +#if 1 + { + // 15ms @cs=8 + TimeTaker timer1("add mud"); + + /* + Add mud to the central chunk + */ + + for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++) + { + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + // Randomize mud amount + s16 mud_add_amount = get_mud_add_amount(data->seed, p2d) / 2.0; + + // Find ground level + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); + + /* + If topmost node is grass, change it to mud. + It might be if it was flown to there from a neighboring + chunk and then converted. + */ + { + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y)); + MapNode *n = &data->vmanip.m_data[i]; + if(n->d == CONTENT_GRASS) + *n = MapNode(CONTENT_MUD); + //n->d = CONTENT_MUD; + } + + /* + Add mud on ground + */ + { + s16 mudcount = 0; + v3s16 em = data->vmanip.m_area.getExtent(); + s16 y_start = surface_y+1; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y<=y_nodes_max; y++) + { + if(mudcount >= mud_add_amount) + break; + + MapNode &n = data->vmanip.m_data[i]; + n = MapNode(CONTENT_MUD); + //n.d = CONTENT_MUD; + mudcount++; + + data->vmanip.m_area.add_y(em, i, 1); + } + } + + } + + }//timer1 +#endif + +#if 1 + { + // 340ms @cs=8 + TimeTaker timer1("flow mud"); + + /* + Flow mud away from steep edges + */ + + // Limit area by 1 because mud is flown into neighbors. + s16 mudflow_minpos = 0-data->max_spread_amount+1; + s16 mudflow_maxpos = data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-2; + + // Iterate a few times + for(s16 k=0; k<3; k++) + { + + for(s16 x=mudflow_minpos; + x<=mudflow_maxpos; + x++) + for(s16 z=mudflow_minpos; + z<=mudflow_maxpos; + z++) + { + // Invert coordinates every 2nd iteration + if(k%2 == 0) + { + x = mudflow_maxpos - (x-mudflow_minpos); + z = mudflow_maxpos - (z-mudflow_minpos); + } + + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + s16 y=y_nodes_max; + + for(;; y--) + { + MapNode *n = NULL; + // Find mud + for(; y>=y_nodes_min; y--) + { + n = &data->vmanip.m_data[i]; + //if(content_walkable(n->d)) + // break; + if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) + break; + + data->vmanip.m_area.add_y(em, i, -1); + } + + // Stop if out of area + //if(data->vmanip.m_area.contains(i) == false) + if(y < y_nodes_min) + break; + + /*// If not mud, do nothing to it + MapNode *n = &data->vmanip.m_data[i]; + if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) + continue;*/ + + /* + Don't flow it if the stuff under it is not mud + */ + { + u32 i2 = i; + data->vmanip.m_area.add_y(em, i2, -1); + // Cancel if out of area + if(data->vmanip.m_area.contains(i2) == false) + continue; + MapNode *n2 = &data->vmanip.m_data[i2]; + if(n2->d != CONTENT_MUD && n2->d != CONTENT_GRASS) + continue; + } + + // Make it exactly mud + n->d = CONTENT_MUD; + + /*s16 recurse_count = 0; + mudflow_recurse:*/ + + v3s16 dirs4[4] = { + v3s16(0,0,1), // back + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(-1,0,0), // left + }; + + // Theck that upper is air or doesn't exist. + // Cancel dropping if upper keeps it in place + u32 i3 = i; + data->vmanip.m_area.add_y(em, i3, 1); + if(data->vmanip.m_area.contains(i3) == true + && content_walkable(data->vmanip.m_data[i3].d) == true) + { + continue; + } + + // Drop mud on side + + for(u32 di=0; di<4; di++) + { + v3s16 dirp = dirs4[di]; + u32 i2 = i; + // Move to side + data->vmanip.m_area.add_p(em, i2, dirp); + // Fail if out of area + if(data->vmanip.m_area.contains(i2) == false) + continue; + // Check that side is air + MapNode *n2 = &data->vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue; + // Check that under side is air + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) + continue; + n2 = &data->vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue; + /*// Check that under that is air (need a drop of 2) + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) + continue; + n2 = &data->vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue;*/ + // Loop further down until not air + do{ + data->vmanip.m_area.add_y(em, i2, -1); + // Fail if out of area + if(data->vmanip.m_area.contains(i2) == false) + continue; + n2 = &data->vmanip.m_data[i2]; + }while(content_walkable(n2->d) == false); + // Loop one up so that we're in air + data->vmanip.m_area.add_y(em, i2, 1); + n2 = &data->vmanip.m_data[i2]; + + // Move mud to new place + *n2 = *n; + // Set old place to be air + *n = MapNode(CONTENT_AIR); + + // Done + break; + } + } + } + + } + + }//timer1 +#endif + +#if 1 + { + // 50ms @cs=8 + TimeTaker timer1("add water"); + + /* + Add water to the central chunk (and a bit more) + */ + + for(s16 x=0-data->max_spread_amount; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; + x++) + for(s16 z=0-data->max_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; + z++) + { + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + // Find ground level + //s16 surface_y = find_ground_level(data->vmanip, p2d); + + /* + If ground level is over water level, skip. + NOTE: This leaves caves near water without water, + which looks especially crappy when the nearby water + won't start flowing either for some reason + */ + /*if(surface_y > WATER_LEVEL) + continue;*/ + + /* + Add water on ground + */ + { + v3s16 em = data->vmanip.m_area.getExtent(); + u8 light = LIGHT_MAX; + // Start at global water surface level + s16 y_start = WATER_LEVEL; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + MapNode *n = &data->vmanip.m_data[i]; + + for(s16 y=y_start; y>=y_nodes_min; y--) + { + n = &data->vmanip.m_data[i]; + + // Stop when there is no water and no air + if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE + && n->d != CONTENT_WATER) + { + + break; + } + + // Make water only not in caves + if(!(data->vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) + { + n->d = CONTENT_WATERSOURCE; + //n->setLight(LIGHTBANK_DAY, light); + + // Add to transforming liquid queue (in case it'd + // start flowing) + v3s16 p = v3s16(p2d.X, y, p2d.Y); + data->transforming_liquid.push_back(p); + } + + // Next one + data->vmanip.m_area.add_y(em, i, -1); + if(light > 0) + light--; + } + } + + } + + }//timer1 +#endif + + } // Aging loop + /*********************** + END OF AGING LOOP + ************************/ + +#if 1 + { + //TimeTaker timer1("convert mud to sand"); + + /* + Convert mud to sand + */ + + //s16 mud_add_amount = myrand_range(2, 4); + //s16 mud_add_amount = 0; + + /*for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++)*/ + for(s16 x=0-data->max_spread_amount+1; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; + x++) + for(s16 z=0-data->max_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; + z++) + { + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + // Determine whether to have sand here + double sandnoise = noise2d_perlin( + 0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500, + data->seed+59420, 3, 0.50); + + bool have_sand = (sandnoise > -0.15); + + if(have_sand == false) + continue; + + // Find ground level + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); + + if(surface_y > WATER_LEVEL + 2) + continue; + + { + v3s16 em = data->vmanip.m_area.getExtent(); + s16 y_start = surface_y; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 not_sand_counter = 0; + for(s16 y=y_start; y>=y_nodes_min; y--) + { + MapNode *n = &data->vmanip.m_data[i]; + if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) + { + n->d = CONTENT_SAND; + } + else + { + not_sand_counter++; + if(not_sand_counter > 3) + break; + } + + data->vmanip.m_area.add_y(em, i, -1); + } + } + + } + + }//timer1 +#endif + +#if 1 + { + // 1ms @cs=8 + //TimeTaker timer1("generate trees"); + + /* + Generate some trees + */ + { + // Divide area into parts + s16 div = 8; + s16 sidelen = data->sectorpos_base_size*MAP_BLOCKSIZE / div; + double area = sidelen * sidelen; + for(s16 x0=0; x0sectorpos_base.X*MAP_BLOCKSIZE + sidelen/2 + sidelen*x0, + data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen/2 + sidelen*z0 + ); + // Minimum edge of part of division + v2s16 p2d_min( + data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen*x0, + data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen*z0 + ); + // Maximum edge of part of division + v2s16 p2d_max( + data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen + sidelen*x0 - 1, + data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen + sidelen*z0 - 1 + ); + // Amount of trees + u32 tree_count = area * tree_amount_2d(data->seed, p2d_center); + // Put trees in random places on part of division + for(u32 i=0; ivmanip, v2s16(x,z)); + // Don't make a tree under water level + if(y < WATER_LEVEL) + continue; + // Don't make a tree so high that it doesn't fit + if(y > y_nodes_max - 6) + continue; + v3s16 p(x,y,z); + /* + Trees grow only on mud and grass + */ + { + u32 i = data->vmanip.m_area.index(v3s16(p)); + MapNode *n = &data->vmanip.m_data[i]; + if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) + continue; + } + p.Y++; + // Make a tree + make_tree(data->vmanip, p); + } + } + /*u32 tree_max = relative_area / 60; + //u32 count = myrand_range(0, tree_max); + for(u32 i=0; isectorpos_base_size*MAP_BLOCKSIZE-1); + s16 z = myrand_range(0, data->sectorpos_base_size*MAP_BLOCKSIZE-1); + x += data->sectorpos_base.X*MAP_BLOCKSIZE; + z += data->sectorpos_base.Y*MAP_BLOCKSIZE; + s16 y = find_ground_level(data->vmanip, v2s16(x,z)); + // Don't make a tree under water level + if(y < WATER_LEVEL) + continue; + v3s16 p(x,y+1,z); + // Make a tree + make_tree(data->vmanip, p); + }*/ + } + + }//timer1 +#endif + +#if 1 + { + // 19ms @cs=8 + //TimeTaker timer1("grow grass"); + + /* + Grow grass + */ + + /*for(s16 x=0-4; xsectorpos_base_size*MAP_BLOCKSIZE+4; x++) + for(s16 z=0-4; zsectorpos_base_size*MAP_BLOCKSIZE+4; z++)*/ + for(s16 x=0-data->max_spread_amount; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; + x++) + for(s16 z=0-data->max_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; + z++) + { + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + /* + Find the lowest surface to which enough light ends up + to make grass grow. + + Basically just wait until not air and not leaves. + */ + s16 surface_y = 0; + { + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + s16 y; + // Go to ground level + for(y=y_nodes_max; y>=y_nodes_min; y--) + { + MapNode &n = data->vmanip.m_data[i]; + if(n.d != CONTENT_AIR + && n.d != CONTENT_LEAVES) + break; + data->vmanip.m_area.add_y(em, i, -1); + } + if(y >= y_nodes_min) + surface_y = y; + else + surface_y = y_nodes_min; + } + + u32 i = data->vmanip.m_area.index(p2d.X, surface_y, p2d.Y); + MapNode *n = &data->vmanip.m_data[i]; + if(n->d == CONTENT_MUD) + n->d = CONTENT_GRASS; + } + + }//timer1 +#endif + +#endif // Disable all but lighting + + /* + Initial lighting (sunlight) + */ + + core::map light_sources; + + { + // 750ms @cs=8, can't optimize more + TimeTaker timer1("initial lighting"); + + // NOTE: This is no used... umm... for some reason! +#if 0 + /* + Go through the edges and add all nodes that have light to light_sources + */ + + // Four edges + for(s16 i=0; i<4; i++) + // Edge length + for(s16 j=lighting_min_d; + j<=lighting_max_d; + j++) + { + s16 x; + s16 z; + // +-X + if(i == 0 || i == 1) + { + x = (i==0) ? lighting_min_d : lighting_max_d; + if(i == 0) + z = lighting_min_d; + else + z = lighting_max_d; + } + // +-Z + else + { + z = (i==0) ? lighting_min_d : lighting_max_d; + if(i == 0) + x = lighting_min_d; + else + x = lighting_max_d; + } + + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + { + v3s16 em = data->vmanip.m_area.getExtent(); + s16 y_start = y_nodes_max; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y>=y_nodes_min; y--) + { + MapNode *n = &data->vmanip.m_data[i]; + if(n->getLight(LIGHTBANK_DAY) != 0) + { + light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); + } + //NOTE: This is broken, at least the index has to + // be incremented + } + } + } +#endif + +#if 1 + /* + Go through the edges and apply sunlight to them, not caring + about neighbors + */ + + // Four edges + for(s16 i=0; i<4; i++) + // Edge length + for(s16 j=lighting_min_d; + j<=lighting_max_d; + j++) + { + s16 x; + s16 z; + // +-X + if(i == 0 || i == 1) + { + x = (i==0) ? lighting_min_d : lighting_max_d; + if(i == 0) + z = lighting_min_d; + else + z = lighting_max_d; + } + // +-Z + else + { + z = (i==0) ? lighting_min_d : lighting_max_d; + if(i == 0) + x = lighting_min_d; + else + x = lighting_max_d; + } + + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + // Loop from top to down + { + u8 light = LIGHT_SUN; + v3s16 em = data->vmanip.m_area.getExtent(); + s16 y_start = y_nodes_max; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y>=y_nodes_min; y--) + { + MapNode *n = &data->vmanip.m_data[i]; + if(light_propagates_content(n->d) == false) + { + light = 0; + } + else if(light != LIGHT_SUN + || sunlight_propagates_content(n->d) == false) + { + if(light > 0) + light--; + } + + n->setLight(LIGHTBANK_DAY, light); + n->setLight(LIGHTBANK_NIGHT, 0); + + if(light != 0) + { + // Insert light source + light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); + } + + // Increment index by y + data->vmanip.m_area.add_y(em, i, -1); + } + } + } +#endif + + /*for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++)*/ + /*for(s16 x=0-data->max_spread_amount+1; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; + x++) + for(s16 z=0-data->max_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; + z++)*/ +#if 1 + /* + This has to be 1 smaller than the actual area, because + neighboring nodes are checked. + */ + for(s16 x=lighting_min_d+1; + x<=lighting_max_d-1; + x++) + for(s16 z=lighting_min_d+1; + z<=lighting_max_d-1; + z++) + { + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + /* + Apply initial sunlight + */ + { + u8 light = LIGHT_SUN; + bool add_to_sources = false; + v3s16 em = data->vmanip.m_area.getExtent(); + s16 y_start = y_nodes_max; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y>=y_nodes_min; y--) + { + MapNode *n = &data->vmanip.m_data[i]; + + if(light_propagates_content(n->d) == false) + { + light = 0; + } + else if(light != LIGHT_SUN + || sunlight_propagates_content(n->d) == false) + { + if(light > 0) + light--; + } + + // This doesn't take much time + if(add_to_sources == false) + { + /* + Check sides. If side is not air or water, start + adding to light_sources. + */ + v3s16 dirs4[4] = { + v3s16(0,0,1), // back + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(-1,0,0), // left + }; + for(u32 di=0; di<4; di++) + { + v3s16 dirp = dirs4[di]; + u32 i2 = i; + data->vmanip.m_area.add_p(em, i2, dirp); + MapNode *n2 = &data->vmanip.m_data[i2]; + if( + n2->d != CONTENT_AIR + && n2->d != CONTENT_WATERSOURCE + && n2->d != CONTENT_WATER + ){ + add_to_sources = true; + break; + } + } + } + + n->setLight(LIGHTBANK_DAY, light); + n->setLight(LIGHTBANK_NIGHT, 0); + + // This doesn't take much time + if(light != 0 && add_to_sources) + { + // Insert light source + light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); + } + + // Increment index by y + data->vmanip.m_area.add_y(em, i, -1); + } + } + } +#endif + + }//timer1 + + // Spread light around + { + TimeTaker timer("makeChunk() spreadLight"); + data->vmanip.spreadLight(LIGHTBANK_DAY, light_sources); + } + + /* + Generation ended + */ + + timer_generate.stop(); +} + +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### + +void ServerMap::initChunkMake(ChunkMakeData &data, v2s16 chunkpos) +{ + if(m_chunksize == 0) + { + data.no_op = true; + return; + } + + data.no_op = false; + + // The distance how far into the neighbors the generator is allowed to go. + s16 max_spread_amount_sectors = 2; + assert(max_spread_amount_sectors <= m_chunksize); + s16 max_spread_amount = max_spread_amount_sectors * MAP_BLOCKSIZE; + + s16 y_blocks_min = -4; + s16 y_blocks_max = 3; + + v2s16 sectorpos_base = chunk_to_sector(chunkpos); + s16 sectorpos_base_size = m_chunksize; + + v2s16 sectorpos_bigbase = + sectorpos_base - v2s16(1,1) * max_spread_amount_sectors; + s16 sectorpos_bigbase_size = + sectorpos_base_size + 2 * max_spread_amount_sectors; + + data.seed = m_seed; + data.chunkpos = chunkpos; + data.y_blocks_min = y_blocks_min; + data.y_blocks_max = y_blocks_max; + data.sectorpos_base = sectorpos_base; + data.sectorpos_base_size = sectorpos_base_size; + data.sectorpos_bigbase = sectorpos_bigbase; + data.sectorpos_bigbase_size = sectorpos_bigbase_size; + data.max_spread_amount = max_spread_amount; + + /* + Create the whole area of this and the neighboring chunks + */ + { + TimeTaker timer("initChunkMake() create area"); + + for(s16 x=0; xsetLightingExpired(true); + // Lighting will be calculated + block->setLightingExpired(false); + + /* + Block gets sunlight if this is true. + + This should be set to true when the top side of a block + is completely exposed to the sky. + + Actually this doesn't matter now because the + initial lighting is done here. + */ + block->setIsUnderground(y != y_blocks_max); + } + } + } + + /* + Now we have a big empty area. + + Make a ManualMapVoxelManipulator that contains this and the + neighboring chunks + */ + + v3s16 bigarea_blocks_min( + sectorpos_bigbase.X, + y_blocks_min, + sectorpos_bigbase.Y + ); + v3s16 bigarea_blocks_max( + sectorpos_bigbase.X + sectorpos_bigbase_size - 1, + y_blocks_max, + sectorpos_bigbase.Y + sectorpos_bigbase_size - 1 + ); + + data.vmanip.setMap(this); + // Add the area + { + TimeTaker timer("initChunkMake() initialEmerge"); + data.vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max); + } + +} + +MapChunk* ServerMap::finishChunkMake(ChunkMakeData &data, + core::map &changed_blocks) +{ + if(data.no_op) + return NULL; + + /* + Blit generated stuff to map + */ + { + // 70ms @cs=8 + //TimeTaker timer("generateChunkRaw() blitBackAll"); + data.vmanip.blitBackAll(&changed_blocks); + } + + /* + Update day/night difference cache of the MapBlocks + */ + { + for(core::map::Iterator i = changed_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + block->updateDayNightDiff(); + } + } + + /* + Copy transforming liquid information + */ + while(data.transforming_liquid.size() > 0) + { + v3s16 p = data.transforming_liquid.pop_front(); + m_transforming_liquid.push_back(p); + } + + /* + Add random objects to blocks + */ + { + for(s16 x=0; xsetIsVolatile(true); + if(chunk->getGenLevel() > GENERATED_PARTLY) + chunk->setGenLevel(GENERATED_PARTLY); + } + + /* + Set central chunk non-volatile + */ + MapChunk *chunk = getChunk(data.chunkpos); + assert(chunk); + // Set non-volatile + //chunk->setIsVolatile(false); + chunk->setGenLevel(GENERATED_FULLY); + + /* + Save changed parts of map + */ + save(true); + + return chunk; +} + +#if 0 +// NOTE: Deprecated +MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, + core::map &changed_blocks, + bool force) +{ + DSTACK(__FUNCTION_NAME); + + /* + Don't generate if already fully generated + */ + if(force == false) + { + MapChunk *chunk = getChunk(chunkpos); + if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY) + { + dstream<<"generateChunkRaw(): Chunk " + <<"("< &changed_blocks) +{ + dstream<<"generateChunk(): Generating chunk " + <<"("<getGenLevel() == GENERATED_FULLY) + continue; + generateChunkRaw(chunkpos0, changed_blocks); + } + + assert(chunkNonVolatile(chunkpos1)); + + MapChunk *chunk = getChunk(chunkpos1); + return chunk; +} +#endif + +ServerMapSector * ServerMap::createSector(v2s16 p2d) +{ + DSTACK("%s: p2d=(%d,%d)", + __FUNCTION_NAME, + p2d.X, p2d.Y); + + /* + Check if it exists already in memory + */ + ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); + if(sector != NULL) + return sector; + + /* + Try to load it from disk (with blocks) + */ + if(loadSectorFull(p2d) == true) + { + ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); + if(sector == NULL) + { + dstream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"< MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) + throw InvalidPositionException("createSector(): pos. over limit"); + + /* + Generate blank sector + */ + + sector = new ServerMapSector(this, p2d); + + // Sector position on map in nodes + v2s16 nodepos2d = p2d * MAP_BLOCKSIZE; + + /* + Insert to container + */ + m_sectors.insert(p2d, sector); + + return sector; +} + +#if 0 +MapSector * ServerMap::emergeSector(v2s16 p2d, + core::map &changed_blocks) +{ + DSTACK("%s: p2d=(%d,%d)", + __FUNCTION_NAME, + p2d.X, p2d.Y); + + /* + Check chunk status + */ + v2s16 chunkpos = sector_to_chunk(p2d); + /*bool chunk_nonvolatile = false; + MapChunk *chunk = getChunk(chunkpos); + if(chunk && chunk->getIsVolatile() == false) + chunk_nonvolatile = true;*/ + bool chunk_nonvolatile = chunkNonVolatile(chunkpos); + + /* + If chunk is not fully generated, generate chunk + */ + if(chunk_nonvolatile == false) + { + // Generate chunk and neighbors + generateChunk(chunkpos, changed_blocks); + } + + /* + Return sector if it exists now + */ + MapSector *sector = getSectorNoGenerateNoEx(p2d); + if(sector != NULL) + return sector; + + /* + Try to load it from disk + */ + if(loadSectorFull(p2d) == true) + { + MapSector *sector = getSectorNoGenerateNoEx(p2d); + if(sector == NULL) + { + dstream<<"ServerMap::emergeSector(): loadSectorFull didn't make a sector"< &changed_blocks, + core::map &lighting_invalidated_blocks +) +{ + DSTACK("%s: p=(%d,%d,%d)", + __FUNCTION_NAME, + p.X, p.Y, p.Z); + + // If chunks are disabled + /*if(m_chunksize == 0) + { + dstream<<"ServerMap::generateBlock(): Chunks disabled -> " + <<"not generating."<createBlankBlockNoInsert(block_y); + } + else + { + // Remove the block so that nobody can get a half-generated one. + sector->removeBlock(block); + // Allocate the block to contain the generated data + block->unDummify(); + } + +#if 0 + /* + Generate a completely empty block + */ + for(s16 z0=0; z0setNode(v3s16(x0,y0,z0), n); + } + } +#else + /* + Generate a proper block + */ + + u8 water_material = CONTENT_WATERSOURCE; + + s32 lowest_ground_y = 32767; + s32 highest_ground_y = -32768; + + for(s16 z0=0; z0getPos()] = block; + }*/ + + // DEBUG: Always update lighting + //lighting_invalidated_blocks[block->getPos()] = block; + + /* + Add some minerals + */ + + if(some_part_underground) + { + s16 underground_level = (lowest_ground_y/MAP_BLOCKSIZE - block_y)+1; + + /* + Add meseblocks + */ + for(s16 i=0; igetNode(cp+g_27dirs[i]).d == CONTENT_STONE) + if(myrand()%8 == 0) + block->setNode(cp+g_27dirs[i], n); + } + } + } + + /* + Add coal + */ + u16 coal_amount = 30; + u16 coal_rareness = 60 / coal_amount; + if(coal_rareness == 0) + coal_rareness = 1; + if(myrand()%coal_rareness == 0) + { + u16 a = myrand() % 16; + u16 amount = coal_amount * a*a*a / 1000; + for(s16 i=0; igetNode(cp+g_27dirs[i]).d == CONTENT_STONE) + if(myrand()%8 == 0) + block->setNode(cp+g_27dirs[i], n); + } + } + } + + /* + Add iron + */ + //TODO: change to iron_amount or whatever + u16 iron_amount = 15; + u16 iron_rareness = 60 / iron_amount; + if(iron_rareness == 0) + iron_rareness = 1; + if(myrand()%iron_rareness == 0) + { + u16 a = myrand() % 16; + u16 amount = iron_amount * a*a*a / 1000; + for(s16 i=0; igetNode(cp+g_27dirs[i]).d == CONTENT_STONE) + if(myrand()%8 == 0) + block->setNode(cp+g_27dirs[i], n); + } + } + } + } + + /* + Create a few rats in empty blocks underground + */ + if(completely_underground) + { + //for(u16 i=0; i<2; i++) + { + v3s16 cp( + (myrand()%(MAP_BLOCKSIZE-2))+1, + (myrand()%(MAP_BLOCKSIZE-2))+1, + (myrand()%(MAP_BLOCKSIZE-2))+1 + ); + + // Check that the place is empty + //if(!is_ground_content(block->getNode(cp).d)) + if(1) + { + RatObject *obj = new RatObject(NULL, -1, intToFloat(cp, BS)); + block->addObject(obj); + } + } + } + +#endif // end of proper block generation + + /* + Add block to sector. + */ + sector->insertBlock(block); + + // Lighting is invalid after generation. + block->setLightingExpired(true); + +#if 0 + /* + Debug information + */ + dstream + <<"lighting_invalidated_blocks.size()" + <<", has_caves" + <<", completely_ug" + <<", some_part_ug" + <<" "< MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) + throw InvalidPositionException("createBlock(): pos. over limit"); + + v2s16 p2d(p.X, p.Z); + s16 block_y = p.Y; + /* + This will create or load a sector if not found in memory. + If block exists on disk, it will be loaded. + + NOTE: On old save formats, this will be slow, as it generates + lighting on blocks for them. + */ + ServerMapSector *sector; + try{ + sector = (ServerMapSector*)createSector(p2d); + assert(sector->getId() == MAPSECTOR_SERVER); + } + catch(InvalidPositionException &e) + { + dstream<<"createBlock: createSector() failed"<getBlockNoCreateNoEx(block_y); + if(block) + return block; + // Create blank + block = sector->createBlankBlock(block_y); + return block; +} + +MapBlock * ServerMap::emergeBlock( + v3s16 p, + bool only_from_disk, + core::map &changed_blocks, + core::map &lighting_invalidated_blocks +) +{ + DSTACK("%s: p=(%d,%d,%d), only_from_disk=%d", + __FUNCTION_NAME, + p.X, p.Y, p.Z, only_from_disk); + + /* + Do not generate over-limit + */ + if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) + throw InvalidPositionException("emergeBlock(): pos. over limit"); + + v2s16 p2d(p.X, p.Z); + s16 block_y = p.Y; + /* + This will create or load a sector if not found in memory. + If block exists on disk, it will be loaded. + */ + ServerMapSector *sector; + try{ + sector = (ServerMapSector*)emergeSector(p2d, changed_blocks); + assert(sector->getId() == MAPSECTOR_SERVER); + } + catch(InvalidPositionException &e) + { + dstream<<"emergeBlock: emergeSector() failed: " + <getBlockNoCreateNoEx(block_y); + + if(block == NULL) + { + does_not_exist = true; + } + else if(block->isDummy() == true) + { + does_not_exist = true; + } + else if(block->getLightingExpired()) + { + lighting_expired = true; + } + else + { + // Valid block + //dstream<<"emergeBlock(): Returning already valid block"<insertBlock(block); + } + // Done. + return block; + } + + //dstream<<"Not found on disk, generating."< making one"< light_sources; + bool black_air_left = false; + bool bottom_invalid = + block->propagateSunlight(light_sources, true, + &black_air_left, true); + + // If sunlight didn't reach everywhere and part of block is + // above ground, lighting has to be properly updated + //if(black_air_left && some_part_underground) + if(black_air_left) + { + lighting_invalidated_blocks[block->getPos()] = block; + } + + if(bottom_invalid) + { + lighting_invalidated_blocks[block->getPos()] = block; + } + } + + return block; +} + +s16 ServerMap::findGroundLevel(v2s16 p2d) +{ + /* + Uh, just do something random... + */ + // Find existing map from top to down + s16 max=63; + s16 min=-64; + v3s16 p(p2d.X, max, p2d.Y); + for(; p.Y>min; p.Y--) + { + MapNode n = getNodeNoEx(p); + if(n.d != CONTENT_IGNORE) + break; + } + if(p.Y == min) + goto plan_b; + // If this node is not air, go to plan b + if(getNodeNoEx(p).d != CONTENT_AIR) + goto plan_b; + // Search existing walkable and return it + for(; p.Y>min; p.Y--) + { + MapNode n = getNodeNoEx(p); + if(content_walkable(n.d) && n.d != CONTENT_IGNORE) + return p.Y; + } + // Move to plan b +plan_b: + /* + Plan B: Get from map generator perlin noise function + */ + // This won't work if proper generation is disabled + if(m_chunksize == 0) + return WATER_LEVEL+2; + double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT; + return (s16)level; +} + +void ServerMap::createDir(std::string path) +{ + if(fs::CreateDir(path) == false) + { + m_dout<::Iterator i = m_sectors.getIterator(); + for(; i.atEnd() == false; i++) + { + ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue(); + assert(sector->getId() == MAPSECTOR_SERVER); + + if(sector->differs_from_disk || only_changed == false) + { + saveSectorMeta(sector); + sector_meta_count++; + } + core::list blocks; + sector->getBlocks(blocks); + core::list::Iterator j; + for(j=blocks.begin(); j!=blocks.end(); j++) + { + MapBlock *block = *j; + if(block->getChangedFlag() || only_changed == false) + { + saveBlock(block); + block_count++; + + /*dstream<<"ServerMap: Written block (" + <getPos().X<<"," + <getPos().Y<<"," + <getPos().Z<<")" + < list = fs::GetDirListing(m_savedir+"/sectors/"); + + dstream<::iterator i; + for(i=list.begin(); i!=list.end(); i++) + { + if(counter > printed_counter + 10) + { + dstream<dir == false) + continue; + try{ + sector = loadSectorMeta(i->name); + } + catch(InvalidFilenameException &e) + { + // This catches unknown crap in directory + } + + std::vector list2 = fs::GetDirListing + (m_savedir+"/sectors/"+i->name); + std::vector::iterator i2; + for(i2=list2.begin(); i2!=list2.end(); i2++) + { + // We want files + if(i2->dir) + continue; + try{ + loadBlock(i->name, i2->name, sector); + } + catch(InvalidFilenameException &e) + { + // This catches unknown crap in directory + } + } + } + dstream<::Iterator + i = m_chunks.getIterator(); + i.atEnd()==false; i++) + { + v2s16 p = i.getNode()->getKey(); + MapChunk *chunk = i.getNode()->getValue(); + // Write position + writeV2S16(buf, p); + os.write((char*)buf, 4); + // Write chunk data + chunk->serialize(os, version); + } + + setChunksNonModified(); +} + +void ServerMap::loadChunkMeta() +{ + DSTACK(__FUNCTION_NAME); + + dstream<<"INFO: ServerMap::loadChunkMeta(): Loading chunk metadata" + <deSerialize(is, version); + m_chunks.insert(p, chunk); + } +} + +void ServerMap::saveSectorMeta(ServerMapSector *sector) +{ + DSTACK(__FUNCTION_NAME); + // Format used for writing + u8 version = SER_FMT_VER_HIGHEST; + // Get destination + v2s16 pos = sector->getPos(); + createDir(m_savedir); + createDir(m_savedir+"/sectors"); + std::string dir = getSectorDir(pos); + createDir(dir); + + std::string fullpath = dir + "/meta"; + std::ofstream o(fullpath.c_str(), std::ios_base::binary); + if(o.good() == false) + throw FileNotGoodException("Cannot open sector metafile"); + + sector->serialize(o, version); + + sector->differs_from_disk = false; +} + +MapSector* ServerMap::loadSectorMeta(std::string dirname) +{ + DSTACK(__FUNCTION_NAME); + // Get destination + v2s16 p2d = getSectorPos(dirname); + std::string dir = m_savedir + "/sectors/" + dirname; + + ServerMapSector *sector = NULL; + + std::string fullpath = dir + "/meta"; + std::ifstream is(fullpath.c_str(), std::ios_base::binary); + if(is.good() == false) + { + // If the directory exists anyway, it probably is in some old + // format. Just go ahead and create the sector. + if(fs::PathExists(dir)) + { + dstream<<"ServerMap::loadSectorMeta(): Sector metafile " + <differs_from_disk = false; + + return sector; +} + +bool ServerMap::loadSectorFull(v2s16 p2d) +{ + DSTACK(__FUNCTION_NAME); + std::string sectorsubdir = getSectorSubDir(p2d); + + MapSector *sector = NULL; + + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out + + try{ + sector = loadSectorMeta(sectorsubdir); + } + catch(InvalidFilenameException &e) + { + return false; + } + catch(FileNotGoodException &e) + { + return false; + } + catch(std::exception &e) + { + return false; + } + + /* + Load blocks + */ + std::vector list2 = fs::GetDirListing + (m_savedir+"/sectors/"+sectorsubdir); + std::vector::iterator i2; + for(i2=list2.begin(); i2!=list2.end(); i2++) + { + // We want files + if(i2->dir) + continue; + try{ + loadBlock(sectorsubdir, i2->name, sector); + } + catch(InvalidFilenameException &e) + { + // This catches unknown crap in directory + } + } + return true; +} + +void ServerMap::saveBlock(MapBlock *block) +{ + DSTACK(__FUNCTION_NAME); + /* + Dummy blocks are not written + */ + if(block->isDummy()) + { + /*v3s16 p = block->getPos(); + dstream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block " + <<"("<getPos(); + v2s16 p2d(p3d.X, p3d.Z); + createDir(m_savedir); + createDir(m_savedir+"/sectors"); + std::string dir = getSectorDir(p2d); + createDir(dir); + + // Block file is map/sectors/xxxxxxxx/xxxx + char cc[5]; + snprintf(cc, 5, "%.4x", (unsigned int)p3d.Y&0xffff); + std::string fullpath = dir + "/" + cc; + std::ofstream o(fullpath.c_str(), std::ios_base::binary); + if(o.good() == false) + throw FileNotGoodException("Cannot open block data"); + + /* + [0] u8 serialization version + [1] data + */ + o.write((char*)&version, 1); + + block->serialize(o, version); + + /* + Versions up from 9 have block objects. + */ + if(version >= 9) + { + block->serializeObjects(o, version); + } + + /* + Versions up from 15 have static objects. + */ + if(version >= 15) + { + block->m_static_objects.serialize(o); + } + + // We just wrote it to the disk + block->resetChangedFlag(); +} + +void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector) +{ + DSTACK(__FUNCTION_NAME); + + // Block file is map/sectors/xxxxxxxx/xxxx + std::string fullpath = m_savedir+"/sectors/"+sectordir+"/"+blockfile; + try{ + + std::ifstream is(fullpath.c_str(), std::ios_base::binary); + if(is.good() == false) + throw FileNotGoodException("Cannot open block file"); + + v3s16 p3d = getBlockPos(sectordir, blockfile); + v2s16 p2d(p3d.X, p3d.Z); + + assert(sector->getPos() == p2d); + + u8 version = SER_FMT_VER_INVALID; + is.read((char*)&version, 1); + + if(is.fail()) + throw SerializationError("ServerMap::loadBlock(): Failed" + " to read MapBlock version"); + + /*u32 block_size = MapBlock::serializedLength(version); + SharedBuffer data(block_size); + is.read((char*)*data, block_size);*/ + + // This will always return a sector because we're the server + //MapSector *sector = emergeSector(p2d); + + MapBlock *block = NULL; + bool created_new = false; + try{ + block = sector->getBlockNoCreate(p3d.Y); + } + catch(InvalidPositionException &e) + { + block = sector->createBlankBlockNoInsert(p3d.Y); + created_new = true; + } + + // deserialize block data + block->deSerialize(is, version); + + /* + Versions up from 9 have block objects. + */ + if(version >= 9) + { + block->updateObjects(is, version, NULL, 0); + } + + /* + Versions up from 15 have static objects. + */ + if(version >= 15) + { + block->m_static_objects.deSerialize(is); + } + + if(created_new) + sector->insertBlock(block); + + /* + Convert old formats to new and save + */ + + // Save old format blocks in new format + if(version < SER_FMT_VER_HIGHEST) + { + saveBlock(block); + } + + // We just loaded it from the disk, so it's up-to-date. + block->resetChangedFlag(); + + } + catch(SerializationError &e) + { + dstream<<"WARNING: Invalid block data on disk " + "(SerializationError). Ignoring. " + "A new one will be generated." + <(-BS*1000000,-BS*1000000,-BS*1000000, + BS*1000000,BS*1000000,BS*1000000); +} + +ClientMap::~ClientMap() +{ + /*JMutexAutoLock lock(mesh_mutex); + + if(mesh != NULL) + { + mesh->drop(); + mesh = NULL; + }*/ +} + +MapSector * ClientMap::emergeSector(v2s16 p2d) +{ + DSTACK(__FUNCTION_NAME); + // Check that it doesn't exist already + try{ + return getSectorNoGenerate(p2d); + } + catch(InvalidPositionException &e) + { + } + + // Create a sector + ClientMapSector *sector = new ClientMapSector(this, p2d); + + { + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out + m_sectors.insert(p2d, sector); + } + + return sector; +} + +void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is) +{ + DSTACK(__FUNCTION_NAME); + ClientMapSector *sector = NULL; + + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out + + core::map::Node *n = m_sectors.find(p2d); + + if(n != NULL) + { + sector = (ClientMapSector*)n->getValue(); + assert(sector->getId() == MAPSECTOR_CLIENT); + } + else + { + sector = new ClientMapSector(this, p2d); + { + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out + m_sectors.insert(p2d, sector); + } + } + + sector->deSerialize(is); +} + +void ClientMap::OnRegisterSceneNode() +{ + if(IsVisible) + { + SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID); + SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT); + } + + ISceneNode::OnRegisterSceneNode(); +} + +void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass) +{ + //m_dout<getDayNightRatio(); + + m_camera_mutex.Lock(); + v3f camera_position = m_camera_position; + v3f camera_direction = m_camera_direction; + m_camera_mutex.Unlock(); + + /* + Get all blocks and draw all visible ones + */ + + v3s16 cam_pos_nodes( + camera_position.X / BS, + camera_position.Y / BS, + camera_position.Z / BS); + + v3s16 box_nodes_d = m_control.wanted_range * v3s16(1,1,1); + + v3s16 p_nodes_min = cam_pos_nodes - box_nodes_d; + v3s16 p_nodes_max = cam_pos_nodes + box_nodes_d; + + // Take a fair amount as we will be dropping more out later + v3s16 p_blocks_min = getNodeBlockPos(p_nodes_min) - v3s16(1,1,1); + v3s16 p_blocks_max = getNodeBlockPos(p_nodes_max) + v3s16(1,1,1); + + u32 vertex_count = 0; + + // For limiting number of mesh updates per frame + u32 mesh_update_count = 0; + + u32 blocks_would_have_drawn = 0; + u32 blocks_drawn = 0; + + //NOTE: The sectors map should be locked but we're not doing it + // because it'd cause too much delays + + int timecheck_counter = 0; + core::map::Iterator si; + si = m_sectors.getIterator(); + for(; si.atEnd() == false; si++) + { + { + timecheck_counter++; + if(timecheck_counter > 50) + { + timecheck_counter = 0; + int time2 = time(0); + if(time2 > time1 + 4) + { + dstream<<"ClientMap::renderMap(): " + "Rendering takes ages, returning." + <getValue(); + v2s16 sp = sector->getPos(); + + if(m_control.range_all == false) + { + if(sp.X < p_blocks_min.X + || sp.X > p_blocks_max.X + || sp.Y < p_blocks_min.Z + || sp.Y > p_blocks_max.Z) + continue; + } + + core::list< MapBlock * > sectorblocks; + sector->getBlocks(sectorblocks); + + /* + Draw blocks + */ + + core::list< MapBlock * >::Iterator i; + for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) + { + MapBlock *block = *i; + + /* + Compare block position to camera position, skip + if not seen on display + */ + + float range = 100000 * BS; + if(m_control.range_all == false) + range = m_control.wanted_range * BS; + + float d = 0.0; + if(isBlockInSight(block->getPos(), camera_position, + camera_direction, range, &d) == false) + { + continue; + } + + // This is ugly (spherical distance limit?) + /*if(m_control.range_all == false && + d - 0.5*BS*MAP_BLOCKSIZE > range) + continue;*/ + +#if 1 + /* + Update expired mesh (used for day/night change) + + It doesn't work exactly like it should now with the + tasked mesh update but whatever. + */ + + bool mesh_expired = false; + + { + JMutexAutoLock lock(block->mesh_mutex); + + mesh_expired = block->getMeshExpired(); + + // Mesh has not been expired and there is no mesh: + // block has no content + if(block->mesh == NULL && mesh_expired == false) + continue; + } + + f32 faraway = BS*50; + //f32 faraway = m_control.wanted_range * BS; + + /* + This has to be done with the mesh_mutex unlocked + */ + // Pretty random but this should work somewhat nicely + if(mesh_expired && ( + (mesh_update_count < 3 + && (d < faraway || mesh_update_count < 2) + ) + || + (m_control.range_all && mesh_update_count < 20) + ) + ) + /*if(mesh_expired && mesh_update_count < 6 + && (d < faraway || mesh_update_count < 3))*/ + { + mesh_update_count++; + + // Mesh has been expired: generate new mesh + //block->updateMesh(daynight_ratio); + m_client->addUpdateMeshTask(block->getPos()); + + mesh_expired = false; + } + +#endif + /* + Draw the faces of the block + */ + { + JMutexAutoLock lock(block->mesh_mutex); + + scene::SMesh *mesh = block->mesh; + + if(mesh == NULL) + continue; + + blocks_would_have_drawn++; + if(blocks_drawn >= m_control.wanted_max_blocks + && m_control.range_all == false + && d > m_control.wanted_min_range * BS) + continue; + blocks_drawn++; + + u32 c = mesh->getMeshBufferCount(); + + for(u32 i=0; igetMeshBuffer(i); + const video::SMaterial& material = buf->getMaterial(); + video::IMaterialRenderer* rnd = + driver->getMaterialRenderer(material.MaterialType); + bool transparent = (rnd && rnd->isTransparent()); + // Render transparent on transparent pass and likewise. + if(transparent == is_transparent_pass) + { + /* + This *shouldn't* hurt too much because Irrlicht + doesn't change opengl textures if the old + material is set again. + */ + driver->setMaterial(buf->getMaterial()); + driver->drawMeshBuffer(buf); + vertex_count += buf->getVertexCount(); + } + } + } + } // foreach sectorblocks + } + + m_control.blocks_drawn = blocks_drawn; + m_control.blocks_would_have_drawn = blocks_would_have_drawn; + + /*dstream<<"renderMap(): is_transparent_pass="< *affected_blocks) +{ + bool changed = false; + /* + Add it to all blocks touching it + */ + v3s16 dirs[7] = { + v3s16(0,0,0), // this + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + for(u16 i=0; i<7; i++) + { + v3s16 p2 = p + dirs[i]; + // Block position of neighbor (or requested) node + v3s16 blockpos = getNodeBlockPos(p2); + MapBlock * blockref = getBlockNoCreateNoEx(blockpos); + if(blockref == NULL) + continue; + // Relative position of requested node + v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; + if(blockref->setTempMod(relpos, mod)) + { + changed = true; + } + } + if(changed && affected_blocks!=NULL) + { + for(u16 i=0; i<7; i++) + { + v3s16 p2 = p + dirs[i]; + // Block position of neighbor (or requested) node + v3s16 blockpos = getNodeBlockPos(p2); + MapBlock * blockref = getBlockNoCreateNoEx(blockpos); + if(blockref == NULL) + continue; + affected_blocks->insert(blockpos, blockref); + } + } + return changed; +} + +bool ClientMap::clearTempMod(v3s16 p, + core::map *affected_blocks) +{ + bool changed = false; + v3s16 dirs[7] = { + v3s16(0,0,0), // this + v3s16(0,0,1), // back + v3s16(0,1,0), // top + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left + }; + for(u16 i=0; i<7; i++) + { + v3s16 p2 = p + dirs[i]; + // Block position of neighbor (or requested) node + v3s16 blockpos = getNodeBlockPos(p2); + MapBlock * blockref = getBlockNoCreateNoEx(blockpos); + if(blockref == NULL) + continue; + // Relative position of requested node + v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; + if(blockref->clearTempMod(relpos)) + { + changed = true; + } + } + if(changed && affected_blocks!=NULL) + { + for(u16 i=0; i<7; i++) + { + v3s16 p2 = p + dirs[i]; + // Block position of neighbor (or requested) node + v3s16 blockpos = getNodeBlockPos(p2); + MapBlock * blockref = getBlockNoCreateNoEx(blockpos); + if(blockref == NULL) + continue; + affected_blocks->insert(blockpos, blockref); + } + } + return changed; +} + +void ClientMap::expireMeshes(bool only_daynight_diffed) +{ + TimeTaker timer("expireMeshes()"); + + core::map::Iterator si; + si = m_sectors.getIterator(); + for(; si.atEnd() == false; si++) + { + MapSector *sector = si.getNode()->getValue(); + + core::list< MapBlock * > sectorblocks; + sector->getBlocks(sectorblocks); + + core::list< MapBlock * >::Iterator i; + for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) + { + MapBlock *block = *i; + + if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false) + { + continue; + } + + { + JMutexAutoLock lock(block->mesh_mutex); + if(block->mesh != NULL) + { + /*block->mesh->drop(); + block->mesh = NULL;*/ + block->setMeshExpired(true); + } + } + } + } +} + +void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio) +{ + assert(mapType() == MAPTYPE_CLIENT); + + try{ + v3s16 p = blockpos + v3s16(0,0,0); + MapBlock *b = getBlockNoCreate(p); + b->updateMesh(daynight_ratio); + //b->setMeshExpired(true); + } + catch(InvalidPositionException &e){} + // Leading edge + try{ + v3s16 p = blockpos + v3s16(-1,0,0); + MapBlock *b = getBlockNoCreate(p); + b->updateMesh(daynight_ratio); + //b->setMeshExpired(true); + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,-1,0); + MapBlock *b = getBlockNoCreate(p); + b->updateMesh(daynight_ratio); + //b->setMeshExpired(true); + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,0,-1); + MapBlock *b = getBlockNoCreate(p); + b->updateMesh(daynight_ratio); + //b->setMeshExpired(true); + } + catch(InvalidPositionException &e){} +} + +#if 0 +/* + Update mesh of block in which the node is, and if the node is at the + leading edge, update the appropriate leading blocks too. +*/ +void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio) +{ + v3s16 dirs[4] = { + v3s16(0,0,0), + v3s16(-1,0,0), + v3s16(0,-1,0), + v3s16(0,0,-1), + }; + v3s16 blockposes[4]; + for(u32 i=0; i<4; i++) + { + v3s16 np = nodepos + dirs[i]; + blockposes[i] = getNodeBlockPos(np); + // Don't update mesh of block if it has been done already + bool already_updated = false; + for(u32 j=0; jupdateMesh(daynight_ratio); + } +} +#endif + +void ClientMap::PrintInfo(std::ostream &out) +{ + out<<"ClientMap: "; +} + +#endif // !SERVER + +/* + MapVoxelManipulator +*/ + +MapVoxelManipulator::MapVoxelManipulator(Map *map) +{ + m_map = map; +} + +MapVoxelManipulator::~MapVoxelManipulator() +{ + /*dstream<<"MapVoxelManipulator: blocks: "<::Node *n; + n = m_loaded_blocks.find(p); + if(n != NULL) + continue; + + bool block_data_inexistent = false; + try + { + TimeTaker timer1("emerge load", &emerge_load_time); + + /*dstream<<"Loading block (caller_id="<getBlockNoCreate(p); + if(block->isDummy()) + block_data_inexistent = true; + else + block->copyTo(*this); + } + catch(InvalidPositionException &e) + { + block_data_inexistent = true; + } + + if(block_data_inexistent) + { + VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1)); + // Fill with VOXELFLAG_INEXISTENT + for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++) + for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++) + { + s32 i = m_area.index(a.MinEdge.X,y,z); + memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE); + } + } + + m_loaded_blocks.insert(p, !block_data_inexistent); + } + + //dstream<<"emerge done"< & modified_blocks) +{ + if(m_area.getExtent() == v3s16(0,0,0)) + return; + + //TimeTaker timer1("blitBack"); + + /*dstream<<"blitBack(): m_loaded_blocks.size()=" + <getBlockNoCreate(blockpos); + blockpos_last = blockpos; + block_checked_in_modified = false; + } + + // Calculate relative position in block + v3s16 relpos = p - blockpos * MAP_BLOCKSIZE; + + // Don't continue if nothing has changed here + if(block->getNode(relpos) == n) + continue; + + //m_map->setNode(m_area.MinEdge + p, n); + block->setNode(relpos, n); + + /* + Make sure block is in modified_blocks + */ + if(block_checked_in_modified == false) + { + modified_blocks[blockpos] = block; + block_checked_in_modified = true; + } + } + catch(InvalidPositionException &e) + { + } + } +} + +ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map): + MapVoxelManipulator(map), + m_create_area(false) +{ +} + +ManualMapVoxelManipulator::~ManualMapVoxelManipulator() +{ +} + +void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id) +{ + // Just create the area so that it can be pointed to + VoxelManipulator::emerge(a, caller_id); +} + +void ManualMapVoxelManipulator::initialEmerge( + v3s16 blockpos_min, v3s16 blockpos_max) +{ + TimeTaker timer1("initialEmerge", &emerge_time); + + // Units of these are MapBlocks + v3s16 p_min = blockpos_min; + v3s16 p_max = blockpos_max; + + VoxelArea block_area_nodes + (p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1)); + + u32 size_MB = block_area_nodes.getVolume()*4/1000000; + if(size_MB >= 1) + { + dstream<<"initialEmerge: area: "; + block_area_nodes.print(dstream); + dstream<<" ("<::Node *n; + n = m_loaded_blocks.find(p); + if(n != NULL) + continue; + + bool block_data_inexistent = false; + try + { + TimeTaker timer1("emerge load", &emerge_load_time); + + MapBlock *block = m_map->getBlockNoCreate(p); + if(block->isDummy()) + block_data_inexistent = true; + else + block->copyTo(*this); + } + catch(InvalidPositionException &e) + { + block_data_inexistent = true; + } + + if(block_data_inexistent) + { + /* + Mark area inexistent + */ + VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1)); + // Fill with VOXELFLAG_INEXISTENT + for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++) + for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++) + { + s32 i = m_area.index(a.MinEdge.X,y,z); + memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE); + } + } + + m_loaded_blocks.insert(p, !block_data_inexistent); + } +} + +void ManualMapVoxelManipulator::blitBackAll( + core::map * modified_blocks) +{ + if(m_area.getExtent() == v3s16(0,0,0)) + return; + + /* + Copy data of all blocks + */ + for(core::map::Iterator + i = m_loaded_blocks.getIterator(); + i.atEnd() == false; i++) + { + bool existed = i.getNode()->getValue(); + if(existed == false) + continue; + v3s16 p = i.getNode()->getKey(); + MapBlock *block = m_map->getBlockNoCreateNoEx(p); + if(block == NULL) + { + dstream<<"WARNING: "<<__FUNCTION_NAME + <<": got NULL block " + <<"("<copyFrom(*this); + + if(modified_blocks) + modified_blocks->insert(p, block); + } +} + +//END diff --git a/src/noise.cpp.new b/misc/noise.cpp similarity index 100% rename from src/noise.cpp.new rename to misc/noise.cpp diff --git a/src/noise.h.new b/misc/noise.h similarity index 100% rename from src/noise.h.new rename to misc/noise.h