X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=d644215be78911de0d56af9825eb684e98d94d3d;hb=7df125c249dc9b99b66f047a395106c2038eb00e;hp=35bf8bb4035a34aece61c2282c645b7e56246e50;hpb=24c4b7c68d283a4d1de72a3eb68f1268f1fe34e3;p=dragonfireclient.git diff --git a/src/map.cpp b/src/map.cpp index 35bf8bb40..d644215be 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -1,51 +1,49 @@ /* -(c) 2010 Perttu Ahola +Minetest-c55 +Copyright (C) 2010 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 "player.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" -#ifdef _WIN32 - #include - #define sleep_ms(x) Sleep(x) -#else - #include - #define sleep_ms(x) usleep(x*1000) -#endif +/* + Map +*/ Map::Map(std::ostream &dout): m_dout(dout), - m_camera_position(0,0,0), - m_camera_direction(0,0,1), - m_sector_cache(NULL), - m_hwrapper(this), - drawoffset(0,0,0) + m_sector_cache(NULL) { m_sector_mutex.Init(); - m_camera_mutex.Init(); assert(m_sector_mutex.IsInitialized()); - assert(m_camera_mutex.IsInitialized()); - - // Get this so that the player can stay on it at first - //getSector(v2s16(0,0)); } Map::~Map() { /* - Stop updater thread - */ - /*updater.setRun(false); - while(updater.IsRunning()) - sleep_s(1);*/ - - /* - Free all MapSectors. + Free all MapSectors */ core::map::Iterator i = m_sectors.getIterator(); for(; i.atEnd() == false; i++) @@ -55,17 +53,31 @@ Map::~Map() } } -/*bool Map::sectorExists(v2s16 p) +void Map::addEventReceiver(MapEventReceiver *event_receiver) { - JMutexAutoLock lock(m_sector_mutex); - core::map::Node *n = m_sectors.find(p); - return (n != NULL); -}*/ + m_event_receivers.insert(event_receiver, false); +} -MapSector * Map::getSectorNoGenerate(v2s16 p) +void Map::removeEventReceiver(MapEventReceiver *event_receiver) { - JMutexAutoLock lock(m_sector_mutex); + 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 @@ -74,11 +86,9 @@ MapSector * Map::getSectorNoGenerate(v2s16 p) } core::map::Node *n = m_sectors.find(p); - // If sector doesn't exist, throw an exception + if(n == NULL) - { - throw InvalidPositionException(); - } + return NULL; MapSector *sector = n->getValue(); @@ -86,13 +96,27 @@ MapSector * Map::getSectorNoGenerate(v2s16 p) m_sector_cache_p = p; m_sector_cache = sector; - //MapSector * ref(sector); - // Reset inactivity timer sector->usage_timer = 0.0; return sector; } +MapSector * Map::getSectorNoGenerateNoEx(v2s16 p) +{ + JMutexAutoLock lock(m_sector_mutex); + + 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); @@ -103,47 +127,32 @@ MapBlock * Map::getBlockNoCreate(v3s16 p3d) return block; } -/*MapBlock * Map::getBlock(v3s16 p3d, bool generate) -{ - dstream<<"Map::getBlock() with generate=true called" - <getBlockNoCreate(p3d.Y); -}*/ - -f32 Map::getGroundHeight(v2s16 p, bool generate) +MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d) { - try{ - v2s16 sectorpos = getNodeSectorPos(p); - MapSector * sref = getSectorNoGenerate(sectorpos); - v2s16 relpos = p - sectorpos * MAP_BLOCKSIZE; - f32 y = sref->getGroundHeight(relpos); - return y; + try + { + v2s16 p2d(p3d.X, p3d.Z); + MapSector * sector = getSectorNoGenerate(p2d); + MapBlock *block = sector->getBlockNoCreate(p3d.Y); + return block; } catch(InvalidPositionException &e) { - return GROUNDHEIGHT_NOTFOUND_SETVALUE; + return NULL; } } -void Map::setGroundHeight(v2s16 p, f32 y, bool generate) +/*MapBlock * Map::getBlockCreate(v3s16 p3d) { - /*m_dout<mutex.Lock(); - sref->setGroundHeight(relpos, y); - //sref->mutex.Unlock(); -} + 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) { @@ -158,120 +167,6 @@ bool Map::isNodeUnderground(v3s16 p) } } -#ifdef LKJnb -//TODO: Remove: Not used. -/* - 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. - - Some things are made strangely to make it as fast as possible. - - Usage: (for clearing all possible spreaded light of a lamp) - NOTE: This is outdated - core::list light_sources; - core::map modified_blocks; - u8 oldlight = node_at_pos.light; - node_at_pos.setLight(0); - unLightNeighbors(pos, oldlight, light_sources, modified_blocks); -*/ -void Map::unLightNeighbors(v3s16 pos, u8 oldlight, - 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 - }; - - /* - Initialize block cache - */ - v3s16 blockpos_last; - MapBlock *block = NULL; - // Cache this a bit, too - bool block_checked_in_modified = false; - - // 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); - - // 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 = n2pos - blockpos * MAP_BLOCKSIZE; - // Get node straight from the block - MapNode n2 = block->getNode(relpos); - - /* - If the neighbor is dimmer than what was specified - as oldlight (the light of the previous node) - */ - if(n2.getLight() < oldlight) - { - /* - And the neighbor is transparent and it has some light - */ - if(n2.light_propagates() && n2.getLight() != 0) - { - /* - Set light to 0 and recurse. - */ - u8 current_light = n2.getLight(); - n2.setLight(0); - block->setNode(relpos, n2); - unLightNeighbors(n2pos, current_light, - light_sources, modified_blocks); - - if(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; - } - } - } - else{ - //light_sources.push_back(n2pos); - light_sources.insert(n2pos, true); - } - } -} -#endif - /* Goes recursively through the neighbours of the node. @@ -289,7 +184,8 @@ void Map::unLightNeighbors(v3s16 pos, u8 oldlight, values of from_nodes are lighting values. */ -void Map::unspreadLight(core::map & from_nodes, +void Map::unspreadLight(enum LightBank bank, + core::map & from_nodes, core::map & light_sources, core::map & modified_blocks) { @@ -389,19 +285,19 @@ void Map::unspreadLight(core::map & from_nodes, If the neighbor is dimmer than what was specified as oldlight (the light of the previous node) */ - if(n2.getLight() < oldlight) + if(n2.getLight(bank) < oldlight) { /* And the neighbor is transparent and it has some light */ - if(n2.light_propagates() && n2.getLight() != 0) + if(n2.light_propagates() && n2.getLight(bank) != 0) { /* Set light to 0 and add to queue */ - u8 current_light = n2.getLight(); - n2.setLight(0); + u8 current_light = n2.getLight(bank); + n2.setLight(bank, 0); block->setNode(relpos, n2); unlighted_nodes.insert(n2pos, current_light); @@ -417,6 +313,10 @@ void Map::unspreadLight(core::map & from_nodes, light_sources.remove(n2pos); }*/ } + + /*// DEBUG + if(light_sources.find(n2pos) != NULL) + light_sources.remove(n2pos);*/ } else{ light_sources.insert(n2pos, true); @@ -446,27 +346,29 @@ void Map::unspreadLight(core::map & from_nodes, < 0) - unspreadLight(unlighted_nodes, light_sources, modified_blocks); + unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks); } /* A single-node wrapper of the above */ -void Map::unLightNeighbors(v3s16 pos, u8 lightwas, +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(from_nodes, light_sources, modified_blocks); + unspreadLight(bank, from_nodes, light_sources, modified_blocks); } /* Lights neighbors of from_nodes, collects all them and then goes on recursively. */ -void Map::spreadLight(core::map & from_nodes, +void Map::spreadLight(enum LightBank bank, + core::map & from_nodes, core::map & modified_blocks) { const v3s16 dirs[6] = { @@ -527,7 +429,7 @@ void Map::spreadLight(core::map & from_nodes, // Get node straight from the block MapNode n = block->getNode(relpos); - u8 oldlight = n.getLight(); + u8 oldlight = n.getLight(bank); u8 newlight = diminish_light(oldlight); // Loop through 6 neighbors @@ -565,7 +467,7 @@ void Map::spreadLight(core::map & from_nodes, If the neighbor is brighter than the current node, add to list (it will light up this node on its turn) */ - if(n2.getLight() > undiminish_light(oldlight)) + if(n2.getLight(bank) > undiminish_light(oldlight)) { lighted_nodes.insert(n2pos, true); //lighted_nodes.push_back(n2pos); @@ -575,11 +477,11 @@ void Map::spreadLight(core::map & from_nodes, If the neighbor is dimmer than how much light this node would spread on it, add to list */ - if(n2.getLight() < newlight) + if(n2.getLight(bank) < newlight) { if(n2.light_propagates()) { - n2.setLight(newlight); + n2.setLight(bank, newlight); block->setNode(relpos, n2); lighted_nodes.insert(n2pos, true); //lighted_nodes.push_back(n2pos); @@ -611,21 +513,22 @@ void Map::spreadLight(core::map & from_nodes, < 0) - spreadLight(lighted_nodes, modified_blocks); + spreadLight(bank, lighted_nodes, modified_blocks); } /* A single-node source variation of the above. */ -void Map::lightNeighbors(v3s16 pos, +void Map::lightNeighbors(enum LightBank bank, + v3s16 pos, core::map & modified_blocks) { core::map from_nodes; from_nodes.insert(pos, true); - spreadLight(from_nodes, modified_blocks); + spreadLight(bank, from_nodes, modified_blocks); } -v3s16 Map::getBrightestNeighbour(v3s16 p) +v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p) { v3s16 dirs[6] = { v3s16(0,0,1), // back @@ -652,8 +555,8 @@ v3s16 Map::getBrightestNeighbour(v3s16 p) { continue; } - if(n2.getLight() > brightest_light || found_something == false){ - brightest_light = n2.getLight(); + if(n2.getLight(bank) > brightest_light || found_something == false){ + brightest_light = n2.getLight(bank); brightest_pos = n2pos; found_something = true; } @@ -670,6 +573,8 @@ v3s16 Map::getBrightestNeighbour(v3s16 p) 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) @@ -694,32 +599,42 @@ s16 Map::propagateSunlight(v3s16 start, if(n.sunlight_propagates()) { - n.setLight(LIGHT_SUN); + n.setLight(LIGHTBANK_DAY, LIGHT_SUN); block->setNode(relpos, n); modified_blocks.insert(blockpos, block); } - else{ + 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(core::map & a_blocks, +void Map::updateLighting(enum LightBank bank, + core::map & a_blocks, core::map & modified_blocks) { /*m_dout<::Iterator i = a_blocks.begin(); - for(; i != a_blocks.end(); i++) - { - MapBlock *block = *i;*/ + //bool debug=true; + //u32 count_was = modified_blocks.size(); + + core::map blocks_to_update; core::map light_sources; @@ -740,6 +655,8 @@ void Map::updateLighting(core::map & a_blocks, v3s16 pos = block->getPos(); modified_blocks.insert(pos, block); + blocks_to_update.insert(pos, block); + /* Clear all light from block */ @@ -751,14 +668,14 @@ void Map::updateLighting(core::map & a_blocks, try{ v3s16 p(x,y,z); MapNode n = block->getNode(v3s16(x,y,z)); - u8 oldlight = n.getLight(); - n.setLight(0); + 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) + || y==0 || y == MAP_BLOCKSIZE-1 + || z==0 || z == MAP_BLOCKSIZE-1) { v3s16 p_map = p + v3s16( MAP_BLOCKSIZE*pos.X, @@ -779,17 +696,30 @@ void Map::updateLighting(core::map & a_blocks, } } - bool bottom_valid = block->propagateSunlight(light_sources); + if(bank == LIGHTBANK_DAY) + { + bool bottom_valid = block->propagateSunlight(light_sources); - // If bottom is valid, we're done. - if(bottom_valid) + // 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 (" < & a_blocks, } } - + +#if 0 { - //TimeTaker timer("unspreadLight", g_device); - unspreadLight(unlight_from, light_sources, modified_blocks); + TimeTaker timer("unspreadLight"); + unspreadLight(bank, unlight_from, light_sources, modified_blocks); } if(debug) @@ -815,14 +746,9 @@ void Map::updateLighting(core::map & a_blocks, dstream<<"unspreadLight modified "< & a_blocks, count_was = modified_blocks.size(); dstream<<"spreadLight modified "<::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::nodeAddedUpdate(v3s16 p, u8 lightwas, - core::map &modified_blocks)*/ void Map::addNodeAndUpdate(v3s16 p, MapNode n, core::map &modified_blocks) { /*PrintInfo(m_dout); - m_dout< light_sources; - core::map light_sources; - //MapNode n = getNode(p); - + /* From this node to nodes underneath: If lighting is sunlight (1.0), unlight neighbours and @@ -862,9 +855,11 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, Else discontinue. */ - bool node_under_sunlight = true; - v3s16 toppos = p + v3s16(0,1,0); + v3s16 bottompos = p + v3s16(0,-1,0); + + bool node_under_sunlight = true; + core::map light_sources; /* If there is a node at top and it doesn't have sunlight, @@ -875,73 +870,192 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, try{ MapNode topnode = getNode(toppos); - if(topnode.getLight() != LIGHT_SUN) + if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN) node_under_sunlight = false; } catch(InvalidPositionException &e) { } - - // 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); - - if(isValidPosition(p) == false) - throw; - - // 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(p, lightwas, light_sources, modified_blocks); - - n.setLight(0); - setNode(p, n); /* - If node is under sunlight, take all sunlighted nodes under - it and clear light from them and from where the light has - been spread. + If the new node doesn't propagate sunlight and there is + grass below, change it to mud */ - if(node_under_sunlight) + if(content_features(n.d).sunlight_propagates == false) { - s16 y = p.Y - 1; - for(;; y--){ - //m_dout<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) @@ -953,6 +1067,9 @@ void Map::removeNodeAndUpdate(v3s16 p, bool node_under_sunlight = true; v3s16 toppos = p + v3s16(0,1,0); + + // Node will be replaced with this + u8 replace_material = CONTENT_AIR; /* If there is a node at top and it doesn't have sunlight, @@ -961,33 +1078,56 @@ void Map::removeNodeAndUpdate(v3s16 p, try{ MapNode topnode = getNode(toppos); - if(topnode.getLight() != LIGHT_SUN) + if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN) node_under_sunlight = false; } catch(InvalidPositionException &e) { } + core::map 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); + } + /* - Unlight neighbors (in case the node is a light source) + Remove node metadata */ - //core::list light_sources; - core::map light_sources; - unLightNeighbors(p, getNode(p).getLight(), - light_sources, modified_blocks); + + removeNodeMetadata(p); /* - Remove the node + Remove the node. + This also clears the lighting. */ + MapNode n; - n.d = MATERIAL_AIR; - n.setLight(0); + n.d = replace_material; setNode(p, n); - /* - Recalculate lighting - */ - spreadLight(light_sources, modified_blocks); + 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); @@ -1013,62 +1153,192 @@ void Map::removeNodeAndUpdate(v3s16 p, /*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) + { + } } } -void Map::updateMeshes(v3s16 blockpos) +bool Map::addNodeWithEvent(v3s16 p, MapNode n) { - assert(mapType() == MAPTYPE_CLIENT); + 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); - b->updateMesh(); + if(b->dayNightDiffed()) + return true; } catch(InvalidPositionException &e){} + // Leading edges try{ v3s16 p = blockpos + v3s16(-1,0,0); MapBlock *b = getBlockNoCreate(p); - b->updateMesh(); + if(b->dayNightDiffed()) + return true; } catch(InvalidPositionException &e){} try{ v3s16 p = blockpos + v3s16(0,-1,0); MapBlock *b = getBlockNoCreate(p); - b->updateMesh(); + if(b->dayNightDiffed()) + return true; } catch(InvalidPositionException &e){} try{ v3s16 p = blockpos + v3s16(0,0,-1); MapBlock *b = getBlockNoCreate(p); - b->updateMesh(); + 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; } /* @@ -1090,6 +1360,13 @@ void Map::timerUpdate(float 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++) { @@ -1156,369 +1433,2425 @@ void Map::PrintInfo(std::ostream &out) out<<"Map: "; } -/* - ServerMap -*/ +#define WATER_DROP_BOOST 4 -ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp): - Map(dout_server), - m_heightmap(NULL) +void Map::transformLiquids(core::map & modified_blocks) { - m_savedir = savedir; - m_map_saving_enabled = false; + DSTACK(__FUNCTION_NAME); + //TimeTaker timer("transformLiquids()"); + + u32 loopcount = 0; + u32 initial_size = m_transforming_liquid.size(); - try + /*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); +} + +/* + ServerMap +*/ + +ServerMap::ServerMap(std::string savedir): + Map(dout_server), + m_seed(0) +{ + + //m_chunksize = 64; + //m_chunksize = 16; // Too slow + m_chunksize = 8; // Takes a few seconds + //m_chunksize = 4; + //m_chunksize = 2; + + // TODO: Save to and load from a file + m_seed = (((u64)(myrand()%0xffff)<<0) + + ((u64)(myrand()%0xffff)<<16) + + ((u64)(myrand()%0xffff)<<32) + + ((u64)(myrand()%0xffff)<<48)); + + /* + Experimental and debug stuff + */ + + { + } + + /* + Try to load map; if not found, create a new one. + */ + + m_savedir = savedir; + m_map_saving_enabled = false; + + try + { + // If directory exists, check contents and load if possible + if(fs::PathExists(m_savedir)) + { + // If directory is empty, it is safe to save into it. + if(fs::GetDirListing(m_savedir).size() == 0) + { + dstream<::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; i>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. + 45. * 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="<setLightingExpired(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 + */ + + ManualMapVoxelManipulator vmanip(this); + // Add the area we just generated + { + TimeTaker timer("generateChunkRaw() initialEmerge"); + vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max); + } + + // Clear all flags + vmanip.clearFlag(0xff); + + TimeTaker timer_generate("generateChunkRaw() generate"); + + // Maximum height of the stone surface and obstacles. + // This is used to disable dungeon generation from going too high. + s16 stone_surface_max_y = 0; + + /* + Generate general ground level to full area + */ + + { + // 22ms @cs=8 + //TimeTaker timer1("ground level"); + + for(s16 x=0; x surface_y_f) + surface_y_f = a; + }*/ + + // 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 = vmanip.m_area.getExtent(); + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); + for(s16 y=y_nodes_min; y=y_nodes_min; y--) + { + MapNode *n = &vmanip.m_data[i]; + /*if(content_walkable(n.d) + && n.d != CONTENT_MUD + && n.d != CONTENT_GRASS) + break;*/ + if(n->d == CONTENT_STONE) + break; + + if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) + { + mud_amount++; + /* + Change to mud because otherwise we might + be throwing mud on grass at the next + step + */ + n->d = CONTENT_MUD; + } + + vmanip.m_area.add_y(em, i, -1); + } + if(y >= y_nodes_min) + surface_y = y; + else + surface_y = y_nodes_min; + } + + + /* + Add stone on ground + */ + { + v3s16 em = vmanip.m_area.getExtent(); + s16 y_start = surface_y+1; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + s16 y; + // Add stone + s16 count = 0; + for(y=y_start; y<=y_nodes_max - min_head_space; y++) + { + MapNode &n = vmanip.m_data[i]; + n.d = CONTENT_STONE; + + if(y > stone_surface_max_y) + stone_surface_max_y = y; + + count++; + if(count >= ob_size.Y) + break; + + vmanip.m_area.add_y(em, i, 1); + } + // Add mud + count = 0; + for(; y<=y_nodes_max - min_head_space; y++) + { + MapNode &n = vmanip.m_data[i]; + n.d = CONTENT_MUD; + count++; + if(count >= mud_amount) + break; + + vmanip.m_area.add_y(em, i, 1); + } + } + + } + } + + }//timer1 + { + // 24ms @cs=8 + //TimeTaker timer1("dungeons"); + + /* + Make dungeons + */ + u32 dungeons_count = relative_volume / 600000; + u32 bruises_count = relative_volume * stone_surface_max_y / 40000000; + if(stone_surface_max_y < WATER_LEVEL) + bruises_count = 0; + /*u32 dungeons_count = 0; + u32 bruises_count = 0;*/ + for(u32 jj=0; jj= 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(vmanip.m_area.contains(p)); + + // Just set it to air, it will be changed to + // water afterwards + u32 i = vmanip.m_area.index(p); + MapNode *n = &vmanip.m_data[i]; + if(n->d == CONTENT_STONE) + n->param = mineral; + } + } + } + } + + orp = rp; + } + + } + + }//timer1 + { + // 15ms @cs=8 + //TimeTaker timer1("add mud"); + + /* + Add mud to the central chunk + */ + + for(s16 x=0; xd == CONTENT_GRASS) + n->d = CONTENT_MUD; + } + + /* + Add mud on ground + */ + { + s16 mudcount = 0; + v3s16 em = vmanip.m_area.getExtent(); + s16 y_start = surface_y+1; + u32 i = 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 = vmanip.m_data[i]; + n.d = CONTENT_MUD; + mudcount++; + + vmanip.m_area.add_y(em, i, 1); + } + } + + } + + }//timer1 + { + // 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-max_spread_amount+1; + s16 mudflow_maxpos = sectorpos_base_size*MAP_BLOCKSIZE+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 = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + v3s16 em = vmanip.m_area.getExtent(); + u32 i = 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 = &vmanip.m_data[i]; + //if(content_walkable(n->d)) + // break; + if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) + break; + + vmanip.m_area.add_y(em, i, -1); + } + + // Stop if out of area + //if(vmanip.m_area.contains(i) == false) + if(y < y_nodes_min) + break; + + /*// If not mud, do nothing to it + MapNode *n = &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; + vmanip.m_area.add_y(em, i2, -1); + // Cancel if out of area + if(vmanip.m_area.contains(i2) == false) + continue; + MapNode *n2 = &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; + vmanip.m_area.add_y(em, i3, 1); + if(vmanip.m_area.contains(i3) == true + && content_walkable(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 + vmanip.m_area.add_p(em, i2, dirp); + // Fail if out of area + if(vmanip.m_area.contains(i2) == false) + continue; + // Check that side is air + MapNode *n2 = &vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue; + // Check that under side is air + vmanip.m_area.add_y(em, i2, -1); + if(vmanip.m_area.contains(i2) == false) + continue; + n2 = &vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue; + /*// Check that under that is air (need a drop of 2) + vmanip.m_area.add_y(em, i2, -1); + if(vmanip.m_area.contains(i2) == false) + continue; + n2 = &vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue;*/ + // Loop further down until not air + do{ + vmanip.m_area.add_y(em, i2, -1); + // Fail if out of area + if(vmanip.m_area.contains(i2) == false) + continue; + n2 = &vmanip.m_data[i2]; + }while(content_walkable(n2->d) == false); + // Loop one up so that we're in air + vmanip.m_area.add_y(em, i2, 1); + n2 = &vmanip.m_data[i2]; + + // Move mud to new place + *n2 = *n; + // Set old place to be air + *n = MapNode(CONTENT_AIR); + + // Done + break; + } + } + } + + } + + }//timer1 + { + // 50ms @cs=8 + //TimeTaker timer1("add water"); + + /* + Add water to the central chunk (and a bit more) + */ + + for(s16 x=0-max_spread_amount; + x WATER_LEVEL) + continue;*/ + + /* + Add water on ground + */ + { + v3s16 em = vmanip.m_area.getExtent(); + u8 light = LIGHT_MAX; + // Start at global water surface level + s16 y_start = WATER_LEVEL; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + MapNode *n = &vmanip.m_data[i]; + + /*// Add first one to transforming liquid queue, if water + if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) + { + v3s16 p = v3s16(p2d.X, y_start, p2d.Y); + m_transforming_liquid.push_back(p); + }*/ + + for(s16 y=y_start; y>=y_nodes_min; y--) + { + n = &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) + { + /*// Add bottom one to transforming liquid queue + vmanip.m_area.add_y(em, i, 1); + n = &vmanip.m_data[i]; + if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) + { + v3s16 p = v3s16(p2d.X, y, p2d.Y); + m_transforming_liquid.push_back(p); + }*/ + + break; + } + + // Make water only not in dungeons + if(!(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); + m_transforming_liquid.push_back(p); + } + + // Next one + vmanip.m_area.add_y(em, i, -1); + if(light > 0) + light--; + } + } + + } + + }//timer1 + + } // Aging loop + + { + //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; x -0.15); + + if(have_sand == false) + continue; + + // Find ground level + s16 surface_y = find_ground_level_clever(vmanip, p2d); + + if(surface_y > WATER_LEVEL + 2) + continue; + + { + v3s16 em = vmanip.m_area.getExtent(); + s16 y_start = surface_y; + u32 i = 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 = &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; + } + + vmanip.m_area.add_y(em, i, -1); + } + } + + } + + }//timer1 + { + // 1ms @cs=8 + //TimeTaker timer1("generate trees"); + + /* + Generate some trees + */ + { + // Divide area into parts + s16 div = 8; + s16 sidelen = sectorpos_base_size*MAP_BLOCKSIZE / div; + double area = sidelen * sidelen; + for(s16 x0=0; x0 y_nodes_max - 6) + continue; + v3s16 p(x,y,z); + /* + Trees grow only on mud and grass + */ + { + u32 i = vmanip.m_area.index(v3s16(p)); + MapNode *n = &vmanip.m_data[i]; + if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) + continue; + } + p.Y++; + // Make a tree + make_tree(vmanip, p); + } + } + /*u32 tree_max = relative_area / 60; + //u32 count = myrand_range(0, tree_max); + for(u32 i=0; i=y_nodes_min; y--) + { + MapNode &n = vmanip.m_data[i]; + if(n.d != CONTENT_AIR + && n.d != CONTENT_LEAVES) + break; + vmanip.m_area.add_y(em, i, -1); + } + if(y >= y_nodes_min) + surface_y = y; + else + surface_y = y_nodes_min; + } + + u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y); + MapNode *n = &vmanip.m_data[i]; + if(n->d == CONTENT_MUD) + n->d = CONTENT_GRASS; + } + + }//timer1 + + /* + Initial lighting (sunlight) + */ + + core::map light_sources; + + { + // 750ms @cs=8, can't optimize more + TimeTaker timer1("initial lighting"); + +#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 = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + { + v3s16 em = vmanip.m_area.getExtent(); + s16 y_start = y_nodes_max; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y>=y_nodes_min; y--) + { + MapNode *n = &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++) { - if(m_map_saving_enabled) + s16 x; + s16 z; + // +-X + if(i == 0 || i == 1) { - //save(false); - // Save only changed parts - save(true); - dstream<=y_nodes_min; y--) + { + MapNode *n = &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 + vmanip.m_area.add_y(em, i, -1); + } } } - catch(std::exception &e) +#endif + + /*for(s16 x=0; x=y_nodes_min; y--) + { + MapNode *n = &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; + vmanip.m_area.add_p(em, i2, dirp); + MapNode *n2 = &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 + vmanip.m_area.add_y(em, i, -1); + } + } } - - if(m_heightmap != NULL) - delete m_heightmap; -} +#endif -MapSector * ServerMap::emergeSector(v2s16 p2d) -{ - DSTACK("%s: p2d=(%d,%d)", - __FUNCTION_NAME, - p2d.X, p2d.Y); - // Check that it doesn't exist already - try{ - return getSectorNoGenerate(p2d); +#if 0 + 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 = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + /* + Apply initial sunlight + */ + { + u8 light = LIGHT_SUN; + v3s16 em = vmanip.m_area.getExtent(); + s16 y_start = y_nodes_max; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y>=y_nodes_min; y--) + { + MapNode *n = &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); + + // This doesn't take much time + if(light != 0) + { + // Insert light source + light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); + } + + // Increment index by y + vmanip.m_area.add_y(em, i, -1); + } + } } - catch(InvalidPositionException &e) +#endif + + }//timer1 + + // Spread light around { + TimeTaker timer("generateChunkRaw() spreadLight"); + vmanip.spreadLight(LIGHTBANK_DAY, light_sources); } /* - Try to load the sector from disk. + Generation ended + */ + + timer_generate.stop(); + + /* + Blit generated stuff to map */ - if(loadSectorFull(p2d) == true) { - return getSectorNoGenerate(p2d); + // 70ms @cs=8 + //TimeTaker timer("generateChunkRaw() blitBackAll"); + vmanip.blitBackAll(&changed_blocks); } /* - If there is no master heightmap, throw. + Update day/night difference cache of the MapBlocks */ - if(m_heightmap == NULL) { - throw InvalidPositionException("emergeSector(): no heightmap"); + for(core::map::Iterator i = changed_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + block->updateDayNightDiff(); + } } + /* - Do not generate over-limit + Create chunk metadata */ - if(p2d.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p2d.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) - throw InvalidPositionException("emergeSector(): pos. over limit"); + + for(s16 x=-1; x<=1; x++) + for(s16 y=-1; y<=1; y++) + { + v2s16 chunkpos0 = chunkpos + v2s16(x,y); + // Add chunk meta information + MapChunk *chunk = getChunk(chunkpos0); + if(chunk == NULL) + { + chunk = new MapChunk(); + m_chunks.insert(chunkpos0, chunk); + } + //chunk->setIsVolatile(true); + if(chunk->getGenLevel() > GENERATED_PARTLY) + chunk->setGenLevel(GENERATED_PARTLY); + } /* - Generate sector and heightmaps + Set central chunk non-volatile */ + MapChunk *chunk = getChunk(chunkpos); + assert(chunk); + // Set non-volatile + //chunk->setIsVolatile(false); + chunk->setGenLevel(GENERATED_FULLY); - // Number of heightmaps in sector in each direction - u16 hm_split = SECTOR_HEIGHTMAP_SPLIT; - - // Heightmap side width - s16 hm_d = MAP_BLOCKSIZE / hm_split; + /* + Save changed parts of map + */ + save(true); - ServerMapSector *sector = new ServerMapSector(this, p2d, hm_split); + /* + Return central chunk (which was requested) + */ + return chunk; +} - /*dstream<<"Generating sector ("< &changed_blocks) +{ + dstream<<"generateChunk(): Generating chunk " + <<"("<getGroundHeight(mhm_p+v2s16(0,0)), - m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)), - m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)), - m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)), - }; - - /*dstream<<"p_in_sector=("<setHeightmap(p_in_sector, hm); - - //TODO: Make these values configurable - hm->generateContinued(1.0, 0.2, corners); - //hm->generateContinued(2.0, 0.2, corners); - - //hm->print(); - + v2s16 chunkpos0 = chunkpos1 + v2s16(x,y); + MapChunk *chunk = getChunk(chunkpos0); + // Skip if already generated + if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY) + continue; + generateChunkRaw(chunkpos0, changed_blocks); } + + assert(chunkNonVolatile(chunkpos1)); + + MapChunk *chunk = getChunk(chunkpos1); + return chunk; +} +ServerMapSector * ServerMap::createSector(v2s16 p2d) +{ + DSTACK("%s: p2d=(%d,%d)", + __FUNCTION_NAME, + p2d.X, p2d.Y); + /* - Generate objects + Check if it exists already in memory */ + ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); + if(sector != NULL) + return sector; - core::map *objects = new core::map; - sector->setObjects(objects); - - v2s16 mhm_p = p2d * hm_split; - f32 corners[4] = { - m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)*hm_split), - m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)*hm_split), - m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)*hm_split), - m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)*hm_split), - }; - - float avgheight = (corners[0]+corners[1]+corners[2]+corners[3])/4.0; - float avgslope = 0.0; - avgslope += fabs(avgheight - corners[0]); - avgslope += fabs(avgheight - corners[1]); - avgslope += fabs(avgheight - corners[2]); - avgslope += fabs(avgheight - corners[3]); - avgslope /= 4.0; - avgslope /= MAP_BLOCKSIZE; - //dstream<<"avgslope="<getSlope(p2d+v2s16(0,0)); - pitness += -a.X; - pitness += -a.Y; - a = m_heightmap->getSlope(p2d+v2s16(0,1)); - pitness += -a.X; - pitness += a.Y; - a = m_heightmap->getSlope(p2d+v2s16(1,1)); - pitness += a.X; - pitness += a.Y; - a = m_heightmap->getSlope(p2d+v2s16(1,0)); - pitness += a.X; - pitness += -a.Y; - pitness /= 4.0; - pitness /= MAP_BLOCKSIZE; - //dstream<<"pitness="< 0.03) - tree_max = a / (t/0.03); - else - tree_max = a; - u32 count = (rand()%(tree_max+1)); - //u32 count = tree_max; - for(u32 i=0; igetGroundHeight(v2s16(x,z))+1; - if(y < WATER_LEVEL) - continue; - objects->insert(v3s16(x, y, z), - SECTOR_OBJECT_TREE_1); - } - } + /* + Try to load it from disk (with blocks) + */ + if(loadSectorFull(p2d) == true) { - // Pitness usually goes at around -0.5...0.5 - u32 bush_max = 0; - u32 a = MAP_BLOCKSIZE * 3.0 * m_params.plants_amount; - if(pitness > 0) - bush_max = (pitness*a*4); - if(bush_max > a) - bush_max = a; - u32 count = (rand()%(bush_max+1)); - for(u32 i=0; igetGroundHeight(v2s16(x,z))+1; - if(y < WATER_LEVEL) - continue; - objects->insert(v3s16(x, y, z), - SECTOR_OBJECT_BUSH_1); + 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 */ - JMutexAutoLock lock(m_sector_mutex); m_sectors.insert(p2d, sector); return sector; } -MapBlock * ServerMap::emergeBlock( - v3s16 p, - bool only_from_disk, - core::map &changed_blocks, - core::map &lighting_invalidated_blocks -) +MapSector * ServerMap::emergeSector(v2s16 p2d, + core::map &changed_blocks) { - DSTACK("%s: p=(%d,%d,%d), only_from_disk=%d", + DSTACK("%s: p2d=(%d,%d)", __FUNCTION_NAME, - p.X, p.Y, p.Z, only_from_disk); - - /*dstream<<"ServerMap::emergeBlock(): " - <<"("< &changed_blocks, + core::map &lighting_invalidated_blocks +) +{ + DSTACK("%s: p=(%d,%d,%d)", + __FUNCTION_NAME, + p.X, p.Y, p.Z); + + /*dstream<<"generateBlock(): " + <<"("<removeBlock(block); - // Allocate the block to be a proper one. + // Allocate the block to contain the generated data block->unDummify(); } - - // Randomize a bit. This makes dungeons. - bool low_block_is_empty = false; - if(rand() % 4 == 0) - low_block_is_empty = true; - // This is the basic material of what the visible flat ground - // will consist of - u8 material = MATERIAL_GRASS; + u8 water_material = CONTENT_WATERSOURCE; s32 lowest_ground_y = 32767; + s32 highest_ground_y = -32768; - // DEBUG - //sector->printHeightmaps(); - for(s16 z0=0; z0getInterpolatedFloat(nodepos2d); + } +#endif + + //dstream<<"generateBlock(): Done"<getPosRelative(); + if(getNode(ap).d == CONTENT_AIR) + { + orp = v3f(x+1,y+1,0); + found_existing = true; + goto continue_generating; + } + } + } + catch(InvalidPositionException &e){} + + // Check z+ + try + { + s16 z = ued; + for(s16 y=0; ygetPosRelative(); + if(getNode(ap).d == CONTENT_AIR) + { + orp = v3f(x+1,y+1,ued-1); + found_existing = true; + goto continue_generating; + } + } + } + catch(InvalidPositionException &e){} + + // Check x- + try + { + s16 x = -1; + for(s16 y=0; ygetPosRelative(); + if(getNode(ap).d == CONTENT_AIR) + { + orp = v3f(0,y+1,z+1); + found_existing = true; + goto continue_generating; + } + } + } + catch(InvalidPositionException &e){} + + // Check x+ + try + { + s16 x = ued; + for(s16 y=0; ygetPosRelative(); + if(getNode(ap).d == CONTENT_AIR) + { + orp = v3f(ued-1,y+1,z+1); + found_existing = true; + goto continue_generating; + } + } + } + catch(InvalidPositionException &e){} + + // Check y- + try + { + s16 y = -1; + for(s16 x=0; xgetPosRelative(); + if(getNode(ap).d == CONTENT_AIR) + { + orp = v3f(x+1,0,z+1); + found_existing = true; + goto continue_generating; + } + } + } + catch(InvalidPositionException &e){} + + // Check y+ + try + { + s16 y = ued; + for(s16 x=0; xgetPosRelative(); + if(getNode(ap).d == CONTENT_AIR) + { + orp = v3f(x+1,ued-1,z+1); + found_existing = true; + goto continue_generating; + } + } + } + catch(InvalidPositionException &e){} + +continue_generating: + + /* + Choose whether to actually generate dungeon + */ + bool do_generate_dungeons = true; + // Don't generate if no part is underground + if(!some_part_underground) + { + do_generate_dungeons = false; + } + // Don't generate if mostly underwater surface + /*else if(mostly_underwater_surface) + { + do_generate_dungeons = false; + }*/ + // Partly underground = cave + else if(!completely_underground) + { + do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100)); + } + // Found existing dungeon underground + else if(found_existing && completely_underground) + { + do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100)); + } + // Underground and no dungeons found + else + { + do_generate_dungeons = (rand() % 300 <= (s32)(caves_amount*100)); + } + + if(do_generate_dungeons) + { + /* + Generate some tunnel starting from orp and ors + */ + for(u16 i=0; i<3; i++) + { + v3f rp( + (float)(myrand()%ued)+0.5, + (float)(myrand()%ued)+0.5, + (float)(myrand()%ued)+0.5 + ); + s16 min_d = 0; + s16 max_d = 4; + s16 rs = (myrand()%(max_d-min_d+1))+min_d; + + v3f vec = rp - orp; + + for(float f=0; f<1.0; f+=0.04) + { + 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++) + { + s16 z = cp.Z + z0; + s16 y = cp.Y + y0; + s16 x = cp.X + x0; + v3s16 p(x,y,z); + if(isInArea(p, ued) == false) + continue; + underground_emptiness[ued*ued*z + ued*y + x] = 1; + } + } + } + } + + orp = rp; + } + } + } +#endif + + // Set to true if has caves. + // Set when some non-air is changed to air when making caves. + bool has_dungeons = false; + + /* + Apply temporary cave data to block + */ + + for(s16 z0=0; z0getNode(v3s16(x0,y0,z0)); + + // Create dungeons + if(underground_emptiness[ + ued*ued*(z0*ued/MAP_BLOCKSIZE) + +ued*(y0*ued/MAP_BLOCKSIZE) + +(x0*ued/MAP_BLOCKSIZE)]) + { + if(content_features(n.d).walkable/*is_ground_content(n.d)*/) + { + // Has now caves + has_dungeons = true; + // Set air to node + n.d = CONTENT_AIR; + } } + block->setNode(v3s16(x0,y0,z0), n); } } + + /* + This is used for guessing whether or not the block should + receive sunlight from the top if the block above doesn't exist + */ + block->setIsUnderground(completely_underground); + + /* + Force lighting update if some part of block is partly + underground and has caves. + */ + /*if(some_part_underground && !completely_underground && has_dungeons) + { + //dstream<<"Half-ground caves"<getPos()] = 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); + } + } + } + + /* + Add block to sector. + */ + sector->insertBlock(block); + + // Lighting is invalid after generation. + block->setLightingExpired(true); + +#if 0 /* - Calculate is_underground + Debug information */ - // Probably underground if the highest part of block is under lowest - // ground height - bool is_underground = (block_y+1) * MAP_BLOCKSIZE < lowest_ground_y; - block->setIsUnderground(is_underground); + dstream + <<"lighting_invalidated_blocks.size()" + <<", has_dungeons" + <<", completely_ug" + <<", some_part_ug" + <<" "<setNode(cp, n); - - for(u16 i=0; i<26; i++) - { - if(rand()%8 == 0) - block->setNode(cp+g_26dirs[i], n); - } - } - } - } + 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("createBlock(): pos. over limit"); + v2s16 p2d(p.X, p.Z); + s16 block_y = p.Y; /* - Create a few rats in empty blocks underground + 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. */ - if(is_underground && low_block_is_empty == true) + ServerMapSector *sector; + try{ + sector = (ServerMapSector*)createSector(p2d); + assert(sector->getId() == MAPSECTOR_SERVER); + } + catch(InvalidPositionException &e) { - //for(u16 i=0; i<2; i++) - { - v3s16 pos(8, 1, 8); - RatObject *obj = new RatObject(NULL, -1, intToFloat(pos)); - block->addObject(obj); - } + dstream<<"createBlock: createSector() failed"<addObject(obj); + 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) { - v3s16 pos(8, 11, 8); - SignObject *obj = new SignObject(NULL, -1, intToFloat(pos)); - obj->setText("Moicka"); - obj->setYaw(45); - block->addObject(obj); + dstream<<"emergeBlock: emergeSector() failed: " + <addObject(obj); + dstream<<"emergeBlock: emergeSector() failed: " + <insertBlock(block); - - // An y-wise container if changed blocks - core::map changed_blocks_sector; + bool does_not_exist = false; + bool lighting_expired = false; + MapBlock *block = sector->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"< *objects = sector->getObjects(); - core::list objects_to_remove; - for(core::map::Iterator i = objects->getIterator(); - i.atEnd() == false; i++) + if(only_from_disk && (does_not_exist || lighting_expired)) { - v3s16 p = i.getNode()->getKey(); - u8 d = i.getNode()->getValue(); + //dstream<<"emergeBlock(): Was not on disk but not generating"<isValidArea(p + v3s16(0,0,0), - p + v3s16(0,0,0), &changed_blocks_sector)) - { - MapNode n; - n.d = MATERIAL_LIGHT; - sector->setNode(p, n); - objects_to_remove.push_back(p); - } + // Add block to sector + sector->insertBlock(block); } - else if(d == SECTOR_OBJECT_TREE_1) - { - v3s16 p_min = p + v3s16(-1,0,-1); - v3s16 p_max = p + v3s16(1,4,1); - if(sector->isValidArea(p_min, p_max, - &changed_blocks_sector)) - { - MapNode n; - n.d = MATERIAL_TREE; - sector->setNode(p+v3s16(0,0,0), n); - sector->setNode(p+v3s16(0,1,0), n); - sector->setNode(p+v3s16(0,2,0), n); - sector->setNode(p+v3s16(0,3,0), n); + // Done. + return block; + } - n.d = MATERIAL_LEAVES; + //dstream<<"Not found on disk, generating."<setNode(p+v3s16(0,4,0), n); - - sector->setNode(p+v3s16(-1,4,0), n); - sector->setNode(p+v3s16(1,4,0), n); - sector->setNode(p+v3s16(0,4,-1), n); - sector->setNode(p+v3s16(0,4,1), n); - sector->setNode(p+v3s16(1,4,1), n); - sector->setNode(p+v3s16(-1,4,1), n); - sector->setNode(p+v3s16(-1,4,-1), n); - sector->setNode(p+v3s16(1,4,-1), n); - - sector->setNode(p+v3s16(-1,3,0), n); - sector->setNode(p+v3s16(1,3,0), n); - sector->setNode(p+v3s16(0,3,-1), n); - sector->setNode(p+v3s16(0,3,1), n); - sector->setNode(p+v3s16(1,3,1), n); - sector->setNode(p+v3s16(-1,3,1), n); - sector->setNode(p+v3s16(-1,3,-1), n); - sector->setNode(p+v3s16(1,3,-1), n); - - objects_to_remove.push_back(p); - - // Lighting has to be recalculated for this one. - sector->getBlocksInArea(p_min, p_max, - lighting_invalidated_blocks); - } - } - else if(d == SECTOR_OBJECT_BUSH_1) - { - if(sector->isValidArea(p + v3s16(0,0,0), - p + v3s16(0,0,0), &changed_blocks_sector)) - { - MapNode n; - n.d = MATERIAL_LEAVES; - sector->setNode(p+v3s16(0,0,0), n); - - objects_to_remove.push_back(p); - } - } - else + //dstream<<"emergeBlock(): Didn't find valid block -> 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) { - dstream<<"ServerMap::emergeBlock(): " - "Invalid heightmap object" - <getPos()] = block; } - }//try - catch(InvalidPositionException &e) + if(bottom_invalid) { - dstream<<"WARNING: "<<__FUNCTION_NAME - <<": while inserting object "<<(int)d - <<" to ("<getValue(); assert(sector->getId() == MAPSECTOR_SERVER); - - if(ENABLE_SECTOR_SAVING) + + if(sector->differs_from_disk || only_changed == false) { - if(sector->differs_from_disk || only_changed == false) - { - saveSectorMeta(sector); - sector_meta_count++; - } + saveSectorMeta(sector); + sector_meta_count++; } - if(ENABLE_BLOCK_SAVING) + core::list blocks; + sector->getBlocks(blocks); + core::list::Iterator j; + for(j=blocks.begin(); j!=blocks.end(); j++) { - 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) { - MapBlock *block = *j; - if(block->getChangedFlag() || only_changed == false) - { - saveBlock(block); - block_count++; - } + saveBlock(block); + block_count++; + + /*dstream<<"ServerMap: Written block (" + <getPos().X<<"," + <getPos().Y<<"," + <getPos().Z<<")" + < list = fs::GetDirListing(m_savedir+"/sectors/"); @@ -2002,72 +4840,211 @@ void ServerMap::loadAll() // This catches unknown crap in directory } - if(ENABLE_BLOCK_LOADING) + std::vector list2 = fs::GetDirListing + (m_savedir+"/sectors/"+i->name); + std::vector::iterator i2; + for(i2=list2.begin(); i2!=list2.end(); i2++) { - 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) { - // We want files - if(i2->dir) - continue; - try{ - loadBlock(i->name, i2->name, sector); - } - catch(InvalidFilenameException &e) - { - // This catches unknown crap in directory - } + // This catches unknown crap in directory } } } dstream< hmdata = m_heightmap->serialize(version); - /* - [0] u8 serialization version - [1] X master heightmap - */ - u32 fullsize = 1 + hmdata.getSize(); - SharedBuffer data(fullsize); + //u8 version = SER_FMT_VER_HIGHEST; +} - data[0] = version; - memcpy(&data[1], *hmdata, hmdata.getSize()); +void ServerMap::loadMasterHeightmap() +{ + DSTACK(__FUNCTION_NAME); + + dstream<<"DEPRECATED: "<<__FUNCTION_NAME<serialize(o, version); } -void ServerMap::loadMasterHeightmap() +void ServerMap::loadMapMeta() +{ + DSTACK(__FUNCTION_NAME); + + dstream<<"INFO: ServerMap::loadMapMeta(): Loading chunk metadata" + <::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); + } +} + +void ServerMap::loadChunkMeta() { DSTACK(__FUNCTION_NAME); - std::string fullpath = m_savedir + "/master_heightmap"; + + dstream<<"INFO: ServerMap::loadChunkMeta(): Loading chunk metadata" + <deSerialize(is, version); + m_chunks.insert(p, chunk); + } } void ServerMap::saveSectorMeta(ServerMapSector *sector) @@ -2082,10 +5059,10 @@ void ServerMap::saveSectorMeta(ServerMapSector *sector) std::string dir = getSectorDir(pos); createDir(dir); - std::string fullpath = dir + "/heightmap"; + std::string fullpath = dir + "/meta"; std::ofstream o(fullpath.c_str(), std::ios_base::binary); if(o.good() == false) - throw FileNotGoodException("Cannot open master heightmap"); + throw FileNotGoodException("Cannot open sector metafile"); sector->serialize(o, version); @@ -2099,13 +5076,13 @@ MapSector* ServerMap::loadSectorMeta(std::string dirname) v2s16 p2d = getSectorPos(dirname); std::string dir = m_savedir + "/sectors/" + dirname; - std::string fullpath = dir + "/heightmap"; + std::string fullpath = dir + "/meta"; std::ifstream is(fullpath.c_str(), std::ios_base::binary); if(is.good() == false) - throw FileNotGoodException("Cannot open sector heightmap"); + throw FileNotGoodException("Cannot open sector metafile"); ServerMapSector *sector = ServerMapSector::deSerialize - (is, this, p2d, &m_hwrapper, m_sectors); + (is, this, p2d, m_sectors); sector->differs_from_disk = false; @@ -2136,51 +5113,28 @@ bool ServerMap::loadSectorFull(v2s16 p2d) { return false; } - - if(ENABLE_BLOCK_LOADING) + + /* + Load blocks + */ + std::vector list2 = fs::GetDirListing + (m_savedir+"/sectors/"+sectorsubdir); + std::vector::iterator i2; + for(i2=list2.begin(); i2!=list2.end(); i2++) { - 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 - } + // We want files + if(i2->dir) + continue; + try{ + loadBlock(sectorsubdir, i2->name, sector); } - } - return true; -} - -#if 0 -bool ServerMap::deFlushSector(v2s16 p2d) -{ - DSTACK(__FUNCTION_NAME); - // See if it already exists in memory - try{ - MapSector *sector = getSectorNoGenerate(p2d); - return true; - } - catch(InvalidPositionException &e) - { - /* - Try to load the sector from disk. - */ - if(loadSectorFull(p2d) == true) + catch(InvalidFilenameException &e) { - return true; + // This catches unknown crap in directory } } - return false; + return true; } -#endif void ServerMap::saveBlock(MapBlock *block) { @@ -2237,622 +5191,877 @@ void ServerMap::saveBlock(MapBlock *block) 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; - 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); + try{ + + // Block file is map/sectors/xxxxxxxx/xxxx + std::string fullpath = m_savedir+"/sectors/"+sectordir+"/"+blockfile; + 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); + } + + 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); + 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); + + 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); + 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( + p_nodes_min.X / MAP_BLOCKSIZE - 1, + p_nodes_min.Y / MAP_BLOCKSIZE - 1, + p_nodes_min.Z / MAP_BLOCKSIZE - 1); + v3s16 p_blocks_max( + p_nodes_max.X / MAP_BLOCKSIZE + 1, + p_nodes_max.Y / MAP_BLOCKSIZE + 1, + p_nodes_max.Z / MAP_BLOCKSIZE + 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; - /*u32 block_size = MapBlock::serializedLength(version); - SharedBuffer data(block_size); - is.read((char*)*data, block_size);*/ + /* + 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;*/ - // This will always return a sector because we're the server - //MapSector *sector = emergeSector(p2d); +#if 1 + /* + Update expired mesh (used for day/night change) - MapBlock *block = NULL; - bool created_new = false; - try{ - block = sector->getBlockNoCreate(p3d.Y); - } - catch(InvalidPositionException &e) - { - block = sector->createBlankBlockNoInsert(p3d.Y); - created_new = true; - } + It doesn't work exactly like it should now with the + tasked mesh update but whatever. + */ - block->deSerialize(is, version); - - /* - Versions up from 9 have block objects. - */ - if(version >= 9) - { - block->updateObjects(is, version, NULL); - } + bool mesh_expired = false; + + { + JMutexAutoLock lock(block->mesh_mutex); - if(created_new) - sector->insertBlock(block); - - /* - Convert old formats to new and save - */ + mesh_expired = block->getMeshExpired(); - if(version == 0 || version == 1) - { - dstream<<"Block ("<mesh == NULL && mesh_expired == false) + continue; + } - // Old version has zero lighting, update it - core::map blocks_changed; - blocks_changed.insert(block->getPos(), block); - core::map modified_blocks; - updateLighting(blocks_changed, modified_blocks); - - // Close input file - is.close(); - - // Save modified blocks - core::map::Iterator i = modified_blocks.getIterator(); - for(; i.atEnd() == false; i++) - { - MapBlock *b2 = i.getNode()->getValue(); - saveBlock(b2); - } - } - // Save blocks in new format - else if(version < SER_FMT_VER_HIGHEST) - { - saveBlock(block); - } - - // We just loaded it from the disk, so it's up-to-date. - block->resetChangedFlag(); -} + 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++; -// Gets from master heightmap -void ServerMap::getSectorCorners(v2s16 p2d, s16 *corners) -{ - assert(m_heightmap != NULL); - /* - Corner definition: - v2s16(0,0), - v2s16(1,0), - v2s16(1,1), - v2s16(0,1), - */ - corners[0] = m_heightmap->getGroundHeight - ((p2d+v2s16(0,0))*SECTOR_HEIGHTMAP_SPLIT); - corners[1] = m_heightmap->getGroundHeight - ((p2d+v2s16(1,0))*SECTOR_HEIGHTMAP_SPLIT); - corners[2] = m_heightmap->getGroundHeight - ((p2d+v2s16(1,1))*SECTOR_HEIGHTMAP_SPLIT); - corners[3] = m_heightmap->getGroundHeight - ((p2d+v2s16(0,1))*SECTOR_HEIGHTMAP_SPLIT); -} + // Mesh has been expired: generate new mesh + //block->updateMesh(daynight_ratio); + m_client->addUpdateMeshTask(block->getPos()); -void ServerMap::PrintInfo(std::ostream &out) -{ - out<<"ServerMap: "; -} + mesh_expired = false; + } + +#endif + /* + Draw the faces of the block + */ + { + JMutexAutoLock lock(block->mesh_mutex); -/* - ClientMap -*/ + scene::SMesh *mesh = block->mesh; -ClientMap::ClientMap( - Client *client, - video::SMaterial *materials, - scene::ISceneNode* parent, - scene::ISceneManager* mgr, - s32 id -): - Map(dout_client), - scene::ISceneNode(parent, mgr, id), - m_client(client), - m_materials(materials), - mesh(NULL) -{ - /*m_box = core::aabbox3d(0,0,0, - map->getW()*BS, map->getH()*BS, map->getD()*BS);*/ - /*m_box = core::aabbox3d(0,0,0, - map->getSizeNodes().X * BS, - map->getSizeNodes().Y * BS, - map->getSizeNodes().Z * BS);*/ - m_box = core::aabbox3d(-BS*1000000,-BS*1000000,-BS*1000000, - BS*1000000,BS*1000000,BS*1000000); + 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++; - mesh_mutex.Init(); -} + u32 c = mesh->getMeshBufferCount(); -ClientMap::~ClientMap() -{ - JMutexAutoLock lock(mesh_mutex); - - if(mesh != NULL) - { - mesh->drop(); - mesh = NULL; + 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) { - DSTACK(__FUNCTION_NAME); - // Check that it doesn't exist already - try{ - return getSectorNoGenerate(p2d); - } - catch(InvalidPositionException &e) + 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; + } } - - // Create a sector with no heightmaps - ClientMapSector *sector = new ClientMapSector(this, p2d); - + if(changed && affected_blocks!=NULL) { - JMutexAutoLock lock(m_sector_mutex); - m_sectors.insert(p2d, sector); + 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 sector; + return changed; } -void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is) +bool ClientMap::clearTempMod(v3s16 p, + core::map *affected_blocks) { - DSTACK(__FUNCTION_NAME); - ClientMapSector *sector = NULL; - - JMutexAutoLock lock(m_sector_mutex); - - core::map::Node *n = m_sectors.find(p2d); - - if(n != NULL) + 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++) { - sector = (ClientMapSector*)n->getValue(); - assert(sector->getId() == MAPSECTOR_CLIENT); + 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; + } } - else + if(changed && affected_blocks!=NULL) { - sector = new ClientMapSector(this, p2d); + for(u16 i=0; i<7; i++) { - JMutexAutoLock lock(m_sector_mutex); - m_sectors.insert(p2d, sector); + 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); } } - - sector->deSerialize(is); + return changed; } -void ClientMap::renderMap(video::IVideoDriver* driver, - video::SMaterial *materials, s32 pass) +void ClientMap::expireMeshes(bool only_daynight_diffed) { - //m_dout<::Iterator si; + si = m_sectors.getIterator(); + for(; si.atEnd() == false; si++) { - JMutexAutoLock lock(mesh_mutex); - if(mesh != NULL) + 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++) { - u32 c = mesh->getMeshBufferCount(); + MapBlock *block = *i; - for(u32 i=0; igetPos()) == false) + { + continue; + } + { - scene::IMeshBuffer *buf = mesh->getMeshBuffer(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) + JMutexAutoLock lock(block->mesh_mutex); + if(block->mesh != NULL) { - driver->setMaterial(buf->getMaterial()); - driver->drawMeshBuffer(buf); + /*block->mesh->drop(); + block->mesh = NULL;*/ + block->setMeshExpired(true); } } } } -#endif +} - /* - Get time for measuring timeout. - - Measuring time is very useful for long delays when the - machine is swapping a lot. - */ - int time1 = time(0); +void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio) +{ + assert(mapType() == MAPTYPE_CLIENT); - /* - Collect all blocks that are in the view range + 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){} +} - Should not optimize more here as we want to auto-update - all changed nodes in viewing range at the next step. - */ +#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: "; +} - s16 viewing_range_nodes; - bool viewing_range_all; - { - JMutexAutoLock lock(g_range_mutex); - viewing_range_nodes = g_viewing_range_nodes; - viewing_range_all = g_viewing_range_all; - } +#endif // !SERVER - m_camera_mutex.Lock(); - v3f camera_position = m_camera_position; - v3f camera_direction = m_camera_direction; - m_camera_mutex.Unlock(); +/* + MapVoxelManipulator +*/ - /* - Get all blocks and draw all visible ones - */ +MapVoxelManipulator::MapVoxelManipulator(Map *map) +{ + m_map = map; +} - v3s16 cam_pos_nodes( - camera_position.X / BS, - camera_position.Y / BS, - camera_position.Z / BS); +MapVoxelManipulator::~MapVoxelManipulator() +{ + /*dstream<<"MapVoxelManipulator: blocks: "<::Iterator si; + VoxelArea block_area_nodes + (p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1)); - //NOTE: The sectors map should be locked but we're not doing it - // because it'd cause too much delays + addArea(block_area_nodes); - si = m_sectors.getIterator(); - for(; si.atEnd() == false; si++) + for(s32 z=p_min.Z; z<=p_max.Z; z++) + for(s32 y=p_min.Y; y<=p_max.Y; y++) + for(s32 x=p_min.X; x<=p_max.X; x++) { + v3s16 p(x,y,z); + core::map::Node *n; + n = m_loaded_blocks.find(p); + if(n != NULL) + continue; + + bool block_data_inexistent = false; + try { - static int timecheck_counter = 0; - timecheck_counter++; - if(timecheck_counter > 50) - { - int time2 = time(0); - if(time2 > time1 + 4) - { - dstream<<"ClientMap::renderMap(): " - "Rendering takes ages, returning." - <getBlockNoCreate(p); + if(block->isDummy()) + block_data_inexistent = true; + else + block->copyTo(*this); + } + catch(InvalidPositionException &e) + { + block_data_inexistent = true; } - MapSector *sector = si.getNode()->getValue(); - v2s16 sp = sector->getPos(); - - if(viewing_range_all == false) + if(block_data_inexistent) { - 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; + 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); + } } - core::list< MapBlock * > sectorblocks; - sector->getBlocks(sectorblocks); - - /* - Draw blocks - */ + m_loaded_blocks.insert(p, !block_data_inexistent); + } - core::list< MapBlock * >::Iterator i; - for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) - { - MapBlock *block = *i; + //dstream<<"emerge done"<getPosRelative(); - - // Block center position - v3f blockpos( - ((float)blockpos_nodes.X + MAP_BLOCKSIZE/2) * BS, - ((float)blockpos_nodes.Y + MAP_BLOCKSIZE/2) * BS, - ((float)blockpos_nodes.Z + MAP_BLOCKSIZE/2) * BS - ); +/* + SUGG: Add an option to only update eg. water and air nodes. + This will make it interfere less with important stuff if + run on background. +*/ +void MapVoxelManipulator::blitBack + (core::map & modified_blocks) +{ + if(m_area.getExtent() == v3s16(0,0,0)) + return; + + //TimeTaker timer1("blitBack"); + + /*dstream<<"blitBack(): m_loaded_blocks.size()=" + < viewing_range_nodes * BS) - continue; + v3s16 blockpos = getNodeBlockPos(p); + + try + { + // Get block + if(block == NULL || blockpos != blockpos_last){ + block = m_map->getBlockNoCreate(blockpos); + blockpos_last = blockpos; + block_checked_in_modified = false; } - // Maximum radius of a block - f32 block_max_radius = 0.5*1.44*1.44*MAP_BLOCKSIZE*BS; - - // If block is (nearly) touching the camera, don't - // bother validating further (that is, render it anyway) - if(d > block_max_radius * 1.5) - { - // Cosine of the angle between the camera direction - // and the block direction (camera_direction is an unit vector) - f32 cosangle = dforward / d; - - // Compensate for the size of the block - // (as the block has to be shown even if it's a bit off FOV) - // This is an estimate. - cosangle += block_max_radius / dforward; - - // If block is not in the field of view, skip it - //if(cosangle < cos(FOV_ANGLE/2)) - if(cosangle < cos(FOV_ANGLE/2. * 4./3.)) - continue; - } + // 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); /* - Draw the faces of the block + Make sure block is in modified_blocks */ - + if(block_checked_in_modified == false) { - JMutexAutoLock lock(block->mesh_mutex); - - // Cancel if block has no mesh - if(block->mesh == NULL) - continue; - - u32 c = block->mesh->getMeshBufferCount(); - - for(u32 i=0; imesh->getMeshBuffer(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) - { - driver->setMaterial(buf->getMaterial()); - driver->drawMeshBuffer(buf); - vertex_count += buf->getVertexCount(); - } - } + modified_blocks[blockpos] = block; + block_checked_in_modified = true; } - } // foreach sectorblocks + } + catch(InvalidPositionException &e) + { + } } - - /*dstream<<"renderMap(): is_transparent_pass="<::Iterator - si = m_sectors.getIterator(); - si.atEnd() == false; si++) + u32 size_MB = block_area_nodes.getVolume()*4/1000000; + if(size_MB >= 1) { - MapSector *sector = si.getNode()->getValue(); - - if(sector->getId() != MAPSECTOR_CLIENT) - { - dstream<<"WARNING: Client has a non-client sector" - <getPos(); + addArea(block_area_nodes); - 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) + for(s32 z=p_min.Z; z<=p_max.Z; z++) + for(s32 y=p_min.Y; y<=p_max.Y; y++) + for(s32 x=p_min.X; x<=p_max.X; x++) + { + v3s16 p(x,y,z); + core::map::Node *n; + n = m_loaded_blocks.find(p); + if(n != NULL) continue; - /* - Get some ground level info - */ - - s16 a = -5; - - s16 cn[4] = + bool block_data_inexistent = false; + try { - cs->getCorner(0)+a, - cs->getCorner(1)+a, - cs->getCorner(2)+a, - cs->getCorner(3)+a, - }; - s16 cn_avg = (cn[0]+cn[1]+cn[2]+cn[3])/4; - s16 cn_min = 32767; - s16 cn_max = -32768; - for(s16 i=0; i<4; i++) + 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) { - if(cn[i] < cn_min) - cn_min = cn[i]; - if(cn[i] > cn_max) - cn_max = cn[i]; + block_data_inexistent = true; } - s16 cn_slope = cn_max - cn_min; - - /* - Generate this part of the heightmap mesh - */ - - u8 material; - if(cn_avg + MAP_BLOCKSIZE/4 <= WATER_LEVEL) - material = 0; - else if(cn_slope <= MAP_BLOCKSIZE) - material = 1; - else - material = 2; - if(material != material_in_use || buf == NULL) + if(block_data_inexistent) { - // Try to get a meshbuffer associated with the material - buf = (scene::SMeshBuffer*)mesh_new->getMeshBuffer - (g_mesh_materials[material]); - // If not found, create one - if(buf == NULL) + /* + 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++) { - // This is a "Standard MeshBuffer", - // it's a typedeffed CMeshBuffer - buf = new scene::SMeshBuffer(); - - // Set material - buf->Material = g_mesh_materials[material]; - // Use VBO - //buf->setHardwareMappingHint(scene::EHM_STATIC); - // Add to mesh - mesh_new->addMeshBuffer(buf); - // Mesh grabbed it - buf->drop(); + s32 i = m_area.index(a.MinEdge.X,y,z); + memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE); } - material_in_use = material; } - // Sector side width in floating-point units - f32 sd = BS * MAP_BLOCKSIZE; - // Sector position in global floating-point units - v3f spf = v3f((f32)sp.X, 0, (f32)sp.Y) * sd; - - //video::SColor c(255,255,255,255); - u8 cc = 180; - video::SColor c(255,cc,cc,cc); - - video::S3DVertex vertices[4] = - { - video::S3DVertex(spf.X, (f32)BS*cn[0],spf.Z, 0,0,0, c, 0,1), - video::S3DVertex(spf.X+sd,(f32)BS*cn[1],spf.Z, 0,0,0, c, 1,1), - video::S3DVertex(spf.X+sd,(f32)BS*cn[2],spf.Z+sd,0,0,0, c, 1,0), - video::S3DVertex(spf.X, (f32)BS*cn[3],spf.Z+sd,0,0,0, c, 0,0), - }; - u16 indices[] = {0,1,2,2,3,0}; - - buf->append(vertices, 4, indices, 6); + m_loaded_blocks.insert(p, !block_data_inexistent); } - - // Set VBO on - //mesh_new->setHardwareMappingHint(scene::EHM_STATIC); +} +void ManualMapVoxelManipulator::blitBackAll( + core::map * modified_blocks) +{ + if(m_area.getExtent() == v3s16(0,0,0)) + return; + /* - Replace the mesh + Copy data of all blocks */ - - mesh_mutex.Lock(); - - scene::SMesh *mesh_old = mesh; - - //DEBUG - /*mesh = NULL; - mesh_new->drop();*/ - mesh = mesh_new; - - mesh_mutex.Unlock(); - - if(mesh_old != NULL) + for(core::map::Iterator + i = m_loaded_blocks.getIterator(); + i.atEnd() == false; i++) { - /*dstream<<"mesh_old refcount="<getReferenceCount() - <getMeshBuffer - (g_materials[MATERIAL_GRASS]); - if(buf != NULL) - dstream<<"grass buf refcount="<getReferenceCount() - <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 " + <<"("<drop(); - } - else - { - dstream<<"WARNING: There was no old master heightmap mesh"<copyFrom(*this); -void ClientMap::PrintInfo(std::ostream &out) -{ - out<<"ClientMap: "; + if(modified_blocks) + modified_blocks->insert(p, block); + } } - +//END