X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapnode.cpp;h=dcf1f6d6ec2c2e46c8231a1812cdd6c7f31b718c;hb=9bb381ebd387cd783da8d582949bf284a29d9b3a;hp=c9f85c303ddd35698f795c7e365972b3dd60a85d;hpb=501034a792d08263bcab22fe0b50271192b2fe0f;p=dragonfireclient.git diff --git a/src/mapnode.cpp b/src/mapnode.cpp index c9f85c303..dcf1f6d6e 100644 --- a/src/mapnode.cpp +++ b/src/mapnode.cpp @@ -1,316 +1,829 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 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 +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 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. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser 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 "common_irrlicht.h" +#include "irrlichttypes_extrabloated.h" #include "mapnode.h" -#include "tile.h" #include "porting.h" +#include "nodedef.h" +#include "map.h" +#include "content_mapnode.h" // For mapnode_translate_*_internal +#include "serialization.h" // For ser_ver_supported +#include "util/serialize.h" +#include "log.h" +#include "util/directiontables.h" +#include "util/numeric.h" #include -#include "mineral.h" -// For g_settings -#include "main.h" -#include "content_mapnode.h" -#include "nodemetadata.h" +#include -ContentFeatures::~ContentFeatures() +static const Rotation wallmounted_to_rot[] = { + ROTATE_0, ROTATE_180, ROTATE_90, ROTATE_270 +}; + +static const u8 rot_to_wallmounted[] = { + 2, 4, 3, 5 +}; + + +/* + MapNode +*/ + +void MapNode::getColor(const ContentFeatures &f, video::SColor *color) const { - if(initial_metadata) - delete initial_metadata; + if (f.palette) { + *color = (*f.palette)[param2]; + return; + } + *color = f.color; } -void ContentFeatures::setTexture(u16 i, std::string name, u8 alpha) +void MapNode::setLight(LightBank bank, u8 a_light, const ContentFeatures &f) noexcept { - if(g_texturesource) + // If node doesn't contain light data, ignore this + if(f.param_type != CPT_LIGHT) + return; + if(bank == LIGHTBANK_DAY) { - tiles[i].texture = g_texturesource->getTexture(name); + param1 &= 0xf0; + param1 |= a_light & 0x0f; } - - if(alpha != 255) + else if(bank == LIGHTBANK_NIGHT) { - tiles[i].alpha = alpha; - tiles[i].material_type = MATERIAL_ALPHA_VERTEX; + param1 &= 0x0f; + param1 |= (a_light & 0x0f)<<4; } - - if(inventory_texture == NULL) - setInventoryTexture(name); + else + assert("Invalid light bank" == NULL); } -void ContentFeatures::setInventoryTexture(std::string imgname) +void MapNode::setLight(LightBank bank, u8 a_light, const NodeDefManager *nodemgr) { - if(g_texturesource == NULL) - return; - - imgname += "^[forcesingle"; - - inventory_texture = g_texturesource->getTextureRaw(imgname); + setLight(bank, a_light, nodemgr->get(*this)); } -void ContentFeatures::setInventoryTextureCube(std::string top, - std::string left, std::string right) +bool MapNode::isLightDayNightEq(const NodeDefManager *nodemgr) const { - if(g_texturesource == NULL) - return; - - str_replace_char(top, '^', '&'); - str_replace_char(left, '^', '&'); - str_replace_char(right, '^', '&'); - - std::string imgname_full; - imgname_full += "[inventorycube{"; - imgname_full += top; - imgname_full += "{"; - imgname_full += left; - imgname_full += "{"; - imgname_full += right; - inventory_texture = g_texturesource->getTextureRaw(imgname_full); + const ContentFeatures &f = nodemgr->get(*this); + bool isEqual; + + if (f.param_type == CPT_LIGHT) { + u8 day = MYMAX(f.light_source, param1 & 0x0f); + u8 night = MYMAX(f.light_source, (param1 >> 4) & 0x0f); + isEqual = day == night; + } else { + isEqual = true; + } + + return isEqual; } -struct ContentFeatures g_content_features[MAX_CONTENT+1]; +u8 MapNode::getLight(LightBank bank, const NodeDefManager *nodemgr) const +{ + // Select the brightest of [light source, propagated light] + const ContentFeatures &f = nodemgr->get(*this); + + u8 light; + if(f.param_type == CPT_LIGHT) + light = bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f; + else + light = 0; + + return MYMAX(f.light_source, light); +} -ContentFeatures & content_features(content_t i) +u8 MapNode::getLightRaw(LightBank bank, const ContentFeatures &f) const noexcept { - return g_content_features[i]; + if(f.param_type == CPT_LIGHT) + return bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f; + return 0; } -ContentFeatures & content_features(MapNode &n) + +u8 MapNode::getLightNoChecks(LightBank bank, const ContentFeatures *f) const noexcept { - return content_features(n.getContent()); + return MYMAX(f->light_source, + bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f); } -/* - See mapnode.h for description. -*/ -void init_mapnode() +bool MapNode::getLightBanks(u8 &lightday, u8 &lightnight, + const NodeDefManager *nodemgr) const { - if(g_texturesource == NULL) + // Select the brightest of [light source, propagated light] + const ContentFeatures &f = nodemgr->get(*this); + if(f.param_type == CPT_LIGHT) { - dstream<<"INFO: Initial run of init_mapnode with " - "g_texturesource=NULL. If this segfaults, " - "there is a bug with something not checking for " - "the NULL value."<>4)&0x0f; } else { - dstream<<"INFO: Full run of init_mapnode with " - "g_texturesource!=NULL"< lightday) + lightday = f.light_source; + if(f.light_source > lightnight) + lightnight = f.light_source; + return f.param_type == CPT_LIGHT || f.light_source != 0; +} + +u8 MapNode::getFaceDir(const NodeDefManager *nodemgr, + bool allow_wallmounted) const +{ + const ContentFeatures &f = nodemgr->get(*this); + if (f.param_type_2 == CPT2_FACEDIR || + f.param_type_2 == CPT2_COLORED_FACEDIR) + return (getParam2() & 0x1F) % 24; + if (allow_wallmounted && (f.param_type_2 == CPT2_WALLMOUNTED || + f.param_type_2 == CPT2_COLORED_WALLMOUNTED)) + return wallmounted_to_facedir[getParam2() & 0x07]; + return 0; +} - /*// Read some settings - bool new_style_water = g_settings.getBool("new_style_water"); - bool new_style_leaves = g_settings.getBool("new_style_leaves");*/ +u8 MapNode::getWallMounted(const NodeDefManager *nodemgr) const +{ + const ContentFeatures &f = nodemgr->get(*this); + if (f.param_type_2 == CPT2_WALLMOUNTED || + f.param_type_2 == CPT2_COLORED_WALLMOUNTED) + return getParam2() & 0x07; + return 0; +} - /* - Initialize content feature table - */ - - /* - Set initial material type to same in all tiles, so that the - same material can be used in more stuff. - This is set according to the leaves because they are the only - differing material to which all materials can be changed to - get this optimization. - */ - u8 initial_material_type = MATERIAL_ALPHA_SIMPLE; - /*if(new_style_leaves) - initial_material_type = MATERIAL_ALPHA_SIMPLE; - else - initial_material_type = MATERIAL_ALPHA_NONE;*/ - for(u16 i=0; ireset(); + case 0: default: return v3s16(0,1,0); + case 1: return v3s16(0,-1,0); + case 2: return v3s16(1,0,0); + case 3: return v3s16(-1,0,0); + case 4: return v3s16(0,0,1); + case 5: return v3s16(0,0,-1); + } +} - for(u16 j=0; j<6; j++) - f->tiles[j].material_type = initial_material_type; +void MapNode::rotateAlongYAxis(const NodeDefManager *nodemgr, Rotation rot) +{ + ContentParamType2 cpt2 = nodemgr->get(*this).param_type_2; + + if (cpt2 == CPT2_FACEDIR || cpt2 == CPT2_COLORED_FACEDIR) { + static const u8 rotate_facedir[24 * 4] = { + // Table value = rotated facedir + // Columns: 0, 90, 180, 270 degrees rotation around vertical axis + // Rotation is anticlockwise as seen from above (+Y) + + 0, 1, 2, 3, // Initial facedir 0 to 3 + 1, 2, 3, 0, + 2, 3, 0, 1, + 3, 0, 1, 2, + + 4, 13, 10, 19, // 4 to 7 + 5, 14, 11, 16, + 6, 15, 8, 17, + 7, 12, 9, 18, + + 8, 17, 6, 15, // 8 to 11 + 9, 18, 7, 12, + 10, 19, 4, 13, + 11, 16, 5, 14, + + 12, 9, 18, 7, // 12 to 15 + 13, 10, 19, 4, + 14, 11, 16, 5, + 15, 8, 17, 6, + + 16, 5, 14, 11, // 16 to 19 + 17, 6, 15, 8, + 18, 7, 12, 9, + 19, 4, 13, 10, + + 20, 23, 22, 21, // 20 to 23 + 21, 20, 23, 22, + 22, 21, 20, 23, + 23, 22, 21, 20 + }; + u8 facedir = (param2 & 31) % 24; + u8 index = facedir * 4 + rot; + param2 &= ~31; + param2 |= rotate_facedir[index]; + } else if (cpt2 == CPT2_WALLMOUNTED || + cpt2 == CPT2_COLORED_WALLMOUNTED) { + u8 wmountface = (param2 & 7); + if (wmountface <= 1) + return; + + Rotation oldrot = wallmounted_to_rot[wmountface - 2]; + param2 &= ~7; + param2 |= rot_to_wallmounted[(oldrot - rot) & 3]; } +} - /* - Initially set every block to be shown as an unknown block. - Don't touch CONTENT_IGNORE or CONTENT_AIR. - */ - for(u16 i=0; i *p_boxes, + u8 neighbors = 0) +{ + std::vector &boxes = *p_boxes; + + if (nodebox.type == NODEBOX_FIXED || nodebox.type == NODEBOX_LEVELED) { + const std::vector &fixed = nodebox.fixed; + int facedir = n.getFaceDir(nodemgr, true); + u8 axisdir = facedir>>2; + facedir&=0x03; + for (aabb3f box : fixed) { + if (nodebox.type == NODEBOX_LEVELED) + box.MaxEdge.Y = (-0.5f + n.getLevel(nodemgr) / 64.0f) * BS; + + switch (axisdir) { + case 0: + if(facedir == 1) + { + box.MinEdge.rotateXZBy(-90); + box.MaxEdge.rotateXZBy(-90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXZBy(180); + box.MaxEdge.rotateXZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXZBy(90); + box.MaxEdge.rotateXZBy(90); + } + break; + case 1: // z+ + box.MinEdge.rotateYZBy(90); + box.MaxEdge.rotateYZBy(90); + if(facedir == 1) + { + box.MinEdge.rotateXYBy(90); + box.MaxEdge.rotateXYBy(90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXYBy(180); + box.MaxEdge.rotateXYBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXYBy(-90); + box.MaxEdge.rotateXYBy(-90); + } + break; + case 2: //z- + box.MinEdge.rotateYZBy(-90); + box.MaxEdge.rotateYZBy(-90); + if(facedir == 1) + { + box.MinEdge.rotateXYBy(-90); + box.MaxEdge.rotateXYBy(-90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXYBy(180); + box.MaxEdge.rotateXYBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXYBy(90); + box.MaxEdge.rotateXYBy(90); + } + break; + case 3: //x+ + box.MinEdge.rotateXYBy(-90); + box.MaxEdge.rotateXYBy(-90); + if(facedir == 1) + { + box.MinEdge.rotateYZBy(90); + box.MaxEdge.rotateYZBy(90); + } + else if(facedir == 2) + { + box.MinEdge.rotateYZBy(180); + box.MaxEdge.rotateYZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateYZBy(-90); + box.MaxEdge.rotateYZBy(-90); + } + break; + case 4: //x- + box.MinEdge.rotateXYBy(90); + box.MaxEdge.rotateXYBy(90); + if(facedir == 1) + { + box.MinEdge.rotateYZBy(-90); + box.MaxEdge.rotateYZBy(-90); + } + else if(facedir == 2) + { + box.MinEdge.rotateYZBy(180); + box.MaxEdge.rotateYZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateYZBy(90); + box.MaxEdge.rotateYZBy(90); + } + break; + case 5: + box.MinEdge.rotateXYBy(-180); + box.MaxEdge.rotateXYBy(-180); + if(facedir == 1) + { + box.MinEdge.rotateXZBy(90); + box.MaxEdge.rotateXZBy(90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXZBy(180); + box.MaxEdge.rotateXZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXZBy(-90); + box.MaxEdge.rotateXZBy(-90); + } + break; + default: + break; + } + box.repair(); + boxes.push_back(box); + } + } + else if(nodebox.type == NODEBOX_WALLMOUNTED) { - if(i == CONTENT_IGNORE || i == CONTENT_AIR) - continue; - ContentFeatures *f = &g_content_features[i]; - f->setAllTextures("unknown_block.png"); - f->dug_item = std::string("MaterialItem ")+itos(i)+" 1"; + v3s16 dir = n.getWallMountedDir(nodemgr); + + // top + if(dir == v3s16(0,1,0)) + { + boxes.push_back(nodebox.wall_top); + } + // bottom + else if(dir == v3s16(0,-1,0)) + { + boxes.push_back(nodebox.wall_bottom); + } + // side + else + { + v3f vertices[2] = + { + nodebox.wall_side.MinEdge, + nodebox.wall_side.MaxEdge + }; + + for (v3f &vertex : vertices) { + if(dir == v3s16(-1,0,0)) + vertex.rotateXZBy(0); + if(dir == v3s16(1,0,0)) + vertex.rotateXZBy(180); + if(dir == v3s16(0,0,-1)) + vertex.rotateXZBy(90); + if(dir == v3s16(0,0,1)) + vertex.rotateXZBy(-90); + } + + aabb3f box = aabb3f(vertices[0]); + box.addInternalPoint(vertices[1]); + boxes.push_back(box); + } } + else if (nodebox.type == NODEBOX_CONNECTED) + { + size_t boxes_size = boxes.size(); + boxes_size += nodebox.fixed.size(); + if (neighbors & 1) + boxes_size += nodebox.connect_top.size(); + else + boxes_size += nodebox.disconnected_top.size(); - /* - Initialize mapnode content - */ - content_mapnode_init(); - + if (neighbors & 2) + boxes_size += nodebox.connect_bottom.size(); + else + boxes_size += nodebox.disconnected_bottom.size(); + + if (neighbors & 4) + boxes_size += nodebox.connect_front.size(); + else + boxes_size += nodebox.disconnected_front.size(); + + if (neighbors & 8) + boxes_size += nodebox.connect_left.size(); + else + boxes_size += nodebox.disconnected_left.size(); + + if (neighbors & 16) + boxes_size += nodebox.connect_back.size(); + else + boxes_size += nodebox.disconnected_back.size(); + + if (neighbors & 32) + boxes_size += nodebox.connect_right.size(); + else + boxes_size += nodebox.disconnected_right.size(); + + if (neighbors == 0) + boxes_size += nodebox.disconnected.size(); + + if (neighbors < 4) + boxes_size += nodebox.disconnected_sides.size(); + + boxes.reserve(boxes_size); + +#define BOXESPUSHBACK(c) \ + for (std::vector::const_iterator \ + it = (c).begin(); \ + it != (c).end(); ++it) \ + (boxes).push_back(*it); + + BOXESPUSHBACK(nodebox.fixed); + + if (neighbors & 1) { + BOXESPUSHBACK(nodebox.connect_top); + } else { + BOXESPUSHBACK(nodebox.disconnected_top); + } + + if (neighbors & 2) { + BOXESPUSHBACK(nodebox.connect_bottom); + } else { + BOXESPUSHBACK(nodebox.disconnected_bottom); + } + + if (neighbors & 4) { + BOXESPUSHBACK(nodebox.connect_front); + } else { + BOXESPUSHBACK(nodebox.disconnected_front); + } + + if (neighbors & 8) { + BOXESPUSHBACK(nodebox.connect_left); + } else { + BOXESPUSHBACK(nodebox.disconnected_left); + } + + if (neighbors & 16) { + BOXESPUSHBACK(nodebox.connect_back); + } else { + BOXESPUSHBACK(nodebox.disconnected_back); + } + + if (neighbors & 32) { + BOXESPUSHBACK(nodebox.connect_right); + } else { + BOXESPUSHBACK(nodebox.disconnected_right); + } + + if (neighbors == 0) { + BOXESPUSHBACK(nodebox.disconnected); + } + + if (neighbors < 4) { + BOXESPUSHBACK(nodebox.disconnected_sides); + } + + } + else // NODEBOX_REGULAR + { + boxes.emplace_back(-BS/2,-BS/2,-BS/2,BS/2,BS/2,BS/2); + } } -v3s16 facedir_rotate(u8 facedir, v3s16 dir) +static inline void getNeighborConnectingFace( + const v3s16 &p, const NodeDefManager *nodedef, + Map *map, MapNode n, u8 bitmask, u8 *neighbors) { - /* - Face 2 (normally Z-) direction: - facedir=0: Z- - facedir=1: X- - facedir=2: Z+ - facedir=3: X+ - */ - v3s16 newdir; - if(facedir==0) // Same - newdir = v3s16(dir.X, dir.Y, dir.Z); - else if(facedir == 1) // Face is taken from rotXZccv(-90) - newdir = v3s16(-dir.Z, dir.Y, dir.X); - else if(facedir == 2) // Face is taken from rotXZccv(180) - newdir = v3s16(-dir.X, dir.Y, -dir.Z); - else if(facedir == 3) // Face is taken from rotXZccv(90) - newdir = v3s16(dir.Z, dir.Y, -dir.X); - else - newdir = dir; - return newdir; + MapNode n2 = map->getNode(p); + if (nodedef->nodeboxConnects(n, n2, bitmask)) + *neighbors |= bitmask; } -TileSpec MapNode::getTile(v3s16 dir) +u8 MapNode::getNeighbors(v3s16 p, Map *map) const { - if(content_features(*this).param_type == CPT_FACEDIR_SIMPLE) - dir = facedir_rotate(param1, dir); - - TileSpec spec; - - s32 dir_i = -1; - - if(dir == v3s16(0,0,0)) - dir_i = -1; - else if(dir == v3s16(0,1,0)) - dir_i = 0; - else if(dir == v3s16(0,-1,0)) - dir_i = 1; - else if(dir == v3s16(1,0,0)) - dir_i = 2; - else if(dir == v3s16(-1,0,0)) - dir_i = 3; - else if(dir == v3s16(0,0,1)) - dir_i = 4; - else if(dir == v3s16(0,0,-1)) - dir_i = 5; - - if(dir_i == -1) - // Non-directional - spec = content_features(*this).tiles[0]; - else - spec = content_features(*this).tiles[dir_i]; - - /* - If it contains some mineral, change texture id - */ - if(content_features(*this).param_type == CPT_MINERAL && g_texturesource) - { - u8 mineral = getMineral(); - std::string mineral_texture_name = mineral_block_texture(mineral); - if(mineral_texture_name != "") - { - u32 orig_id = spec.texture.id; - std::string texture_name = g_texturesource->getTextureName(orig_id); - //texture_name += "^blit:"; - texture_name += "^"; - texture_name += mineral_texture_name; - u32 new_id = g_texturesource->getTextureId(texture_name); - spec.texture = g_texturesource->getTexture(new_id); - } + const NodeDefManager *nodedef = map->getNodeDefManager(); + u8 neighbors = 0; + const ContentFeatures &f = nodedef->get(*this); + // locate possible neighboring nodes to connect to + if (f.drawtype == NDT_NODEBOX && f.node_box.type == NODEBOX_CONNECTED) { + v3s16 p2 = p; + + p2.Y++; + getNeighborConnectingFace(p2, nodedef, map, *this, 1, &neighbors); + + p2 = p; + p2.Y--; + getNeighborConnectingFace(p2, nodedef, map, *this, 2, &neighbors); + + p2 = p; + p2.Z--; + getNeighborConnectingFace(p2, nodedef, map, *this, 4, &neighbors); + + p2 = p; + p2.X--; + getNeighborConnectingFace(p2, nodedef, map, *this, 8, &neighbors); + + p2 = p; + p2.Z++; + getNeighborConnectingFace(p2, nodedef, map, *this, 16, &neighbors); + + p2 = p; + p2.X++; + getNeighborConnectingFace(p2, nodedef, map, *this, 32, &neighbors); } - return spec; + return neighbors; } -u8 MapNode::getMineral() +void MapNode::getNodeBoxes(const NodeDefManager *nodemgr, + std::vector *boxes, u8 neighbors) const { - if(content_features(*this).param_type == CPT_MINERAL) - { - return param1 & 0x0f; + const ContentFeatures &f = nodemgr->get(*this); + transformNodeBox(*this, f.node_box, nodemgr, boxes, neighbors); +} + +void MapNode::getCollisionBoxes(const NodeDefManager *nodemgr, + std::vector *boxes, u8 neighbors) const +{ + const ContentFeatures &f = nodemgr->get(*this); + if (f.collision_box.fixed.empty()) + transformNodeBox(*this, f.node_box, nodemgr, boxes, neighbors); + else + transformNodeBox(*this, f.collision_box, nodemgr, boxes, neighbors); +} + +void MapNode::getSelectionBoxes(const NodeDefManager *nodemgr, + std::vector *boxes, u8 neighbors) const +{ + const ContentFeatures &f = nodemgr->get(*this); + transformNodeBox(*this, f.selection_box, nodemgr, boxes, neighbors); +} + +u8 MapNode::getMaxLevel(const NodeDefManager *nodemgr) const +{ + const ContentFeatures &f = nodemgr->get(*this); + // todo: after update in all games leave only if (f.param_type_2 == + if( f.liquid_type == LIQUID_FLOWING || f.param_type_2 == CPT2_FLOWINGLIQUID) + return LIQUID_LEVEL_MAX; + if(f.leveled || f.param_type_2 == CPT2_LEVELED) + return f.leveled_max; + return 0; +} + +u8 MapNode::getLevel(const NodeDefManager *nodemgr) const +{ + const ContentFeatures &f = nodemgr->get(*this); + // todo: after update in all games leave only if (f.param_type_2 == + if(f.liquid_type == LIQUID_SOURCE) + return LIQUID_LEVEL_SOURCE; + if (f.param_type_2 == CPT2_FLOWINGLIQUID) + return getParam2() & LIQUID_LEVEL_MASK; + if(f.liquid_type == LIQUID_FLOWING) // can remove if all param_type_2 setted + return getParam2() & LIQUID_LEVEL_MASK; + if (f.param_type_2 == CPT2_LEVELED) { + u8 level = getParam2() & LEVELED_MASK; + if (level) + return level; } + // Return static value from nodedef if param2 isn't used for level + if (f.leveled > f.leveled_max) + return f.leveled_max; + return f.leveled; +} - return MINERAL_NONE; +s8 MapNode::setLevel(const NodeDefManager *nodemgr, s16 level) +{ + s8 rest = 0; + const ContentFeatures &f = nodemgr->get(*this); + if (f.param_type_2 == CPT2_FLOWINGLIQUID + || f.liquid_type == LIQUID_FLOWING + || f.liquid_type == LIQUID_SOURCE) { + if (level <= 0) { // liquid can’t exist with zero level + setContent(CONTENT_AIR); + return 0; + } + if (level >= LIQUID_LEVEL_SOURCE) { + rest = level - LIQUID_LEVEL_SOURCE; + setContent(f.liquid_alternative_source_id); + setParam2(0); + } else { + setContent(f.liquid_alternative_flowing_id); + setParam2((level & LIQUID_LEVEL_MASK) | (getParam2() & ~LIQUID_LEVEL_MASK)); + } + } else if (f.param_type_2 == CPT2_LEVELED) { + if (level < 0) { // zero means default for a leveled nodebox + rest = level; + level = 0; + } else if (level > f.leveled_max) { + rest = level - f.leveled_max; + level = f.leveled_max; + } + setParam2((level & LEVELED_MASK) | (getParam2() & ~LEVELED_MASK)); + } + return rest; +} + +s8 MapNode::addLevel(const NodeDefManager *nodemgr, s16 add) +{ + s16 level = getLevel(nodemgr); + level += add; + return setLevel(nodemgr, level); } u32 MapNode::serializedLength(u8 version) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); - - if(version == 0) + + if (version == 0) return 1; - else if(version <= 9) + + if (version <= 9) return 2; - else + + if (version <= 23) return 3; + + return 4; } -void MapNode::serialize(u8 *dest, u8 version) +void MapNode::serialize(u8 *dest, u8 version) const { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); - - // Translate to wanted version - MapNode n_foreign = mapnode_translate_from_internal(*this, version); - u8 actual_param0 = n_foreign.param0; + // Can't do this anymore; we have 16-bit dynamically allocated node IDs + // in memory; conversion just won't work in this direction. + if(version < 24) + throw SerializationError("MapNode::serialize: serialization to " + "version < 24 not possible"); - // Convert special values from new version to old - if(version <= 18) + writeU16(dest+0, param0); + writeU8(dest+2, param1); + writeU8(dest+3, param2); +} +void MapNode::deSerialize(u8 *source, u8 version) +{ + if(!ser_ver_supported(version)) + throw VersionMismatchException("ERROR: MapNode format not supported"); + + if(version <= 21) { - // In these versions, CONTENT_IGNORE and CONTENT_AIR - // are 255 and 254 - if(actual_param0 == CONTENT_IGNORE) - actual_param0 = 255; - else if(actual_param0 == CONTENT_AIR) - actual_param0 = 254; + deSerialize_pre22(source, version); + return; } - if(version == 0) - { - dest[0] = actual_param0; + if(version >= 24){ + param0 = readU16(source+0); + param1 = readU8(source+2); + param2 = readU8(source+3); + }else{ + param0 = readU8(source+0); + param1 = readU8(source+1); + param2 = readU8(source+2); + if(param0 > 0x7F){ + param0 |= ((param2&0xF0)<<4); + param2 &= 0x0F; + } } - else if(version <= 9) - { - dest[0] = actual_param0; - dest[1] = n_foreign.param1; +} +void MapNode::serializeBulk(std::ostream &os, int version, + const MapNode *nodes, u32 nodecount, + u8 content_width, u8 params_width, bool compressed) +{ + if (!ser_ver_supported(version)) + throw VersionMismatchException("ERROR: MapNode format not supported"); + + sanity_check(content_width == 2); + sanity_check(params_width == 2); + + // Can't do this anymore; we have 16-bit dynamically allocated node IDs + // in memory; conversion just won't work in this direction. + if (version < 24) + throw SerializationError("MapNode::serializeBulk: serialization to " + "version < 24 not possible"); + + size_t databuf_size = nodecount * (content_width + params_width); + u8 *databuf = new u8[databuf_size]; + + u32 start1 = content_width * nodecount; + u32 start2 = (content_width + 1) * nodecount; + + // Serialize content + for (u32 i = 0; i < nodecount; i++) { + writeU16(&databuf[i * 2], nodes[i].param0); + writeU8(&databuf[start1 + i], nodes[i].param1); + writeU8(&databuf[start2 + i], nodes[i].param2); } + + /* + Compress data to output stream + */ + + if (compressed) + compressZlib(databuf, databuf_size, os); else - { - dest[0] = actual_param0; - dest[1] = n_foreign.param1; - dest[2] = n_foreign.param2; - } + os.write((const char*) &databuf[0], databuf_size); + + delete [] databuf; } -void MapNode::deSerialize(u8 *source, u8 version) + +// Deserialize bulk node data +void MapNode::deSerializeBulk(std::istream &is, int version, + MapNode *nodes, u32 nodecount, + u8 content_width, u8 params_width, bool compressed) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); - - if(version == 0) + + if (version < 22 + || (content_width != 1 && content_width != 2) + || params_width != 2) + FATAL_ERROR("Deserialize bulk node data error"); + + // Uncompress or read data + u32 len = nodecount * (content_width + params_width); + SharedBuffer databuf(len); + if(compressed) { - param0 = source[0]; + std::ostringstream os(std::ios_base::binary); + decompressZlib(is, os); + std::string s = os.str(); + if(s.size() != len) + throw SerializationError("deSerializeBulkNodes: " + "decompress resulted in invalid size"); + memcpy(&databuf[0], s.c_str(), len); + } + else + { + is.read((char*) &databuf[0], len); + if(is.eof() || is.fail()) + throw SerializationError("deSerializeBulkNodes: " + "failed to read bulk node data"); + } + + // Deserialize content + if(content_width == 1) + { + for(u32 i=0; i 0x7F){ + nodes[i].param0 <<= 4; + nodes[i].param0 |= (nodes[i].param2&0xF0)>>4; + nodes[i].param2 &= 0x0F; + } + } + } + else if(content_width == 2) + { + for(u32 i=0; i 0) - param1 = 0; - else - param1 = source[1]; } else if(version <= 9) { @@ -322,21 +835,19 @@ void MapNode::deSerialize(u8 *source, u8 version) param0 = source[0]; param1 = source[1]; param2 = source[2]; + if(param0 > 0x7f){ + param0 <<= 4; + param0 |= (param2&0xf0)>>4; + param2 &= 0x0f; + } } - + // Convert special values from old version to new - if(version <= 18) + if(version <= 19) { // In these versions, CONTENT_IGNORE and CONTENT_AIR // are 255 and 254 - if(param0 == 255) - param0 = CONTENT_IGNORE; - else if(param0 == 254) - param0 = CONTENT_AIR; - } - // version 19 is fucked up with sometimes the old values and sometimes not - if(version == 19) - { + // Version 19 is messed up with sometimes the old values and sometimes not if(param0 == 255) param0 = CONTENT_IGNORE; else if(param0 == 254) @@ -346,55 +857,3 @@ void MapNode::deSerialize(u8 *source, u8 version) // Translate to our known version *this = mapnode_translate_to_internal(*this, version); } - -/* - Gets lighting value at face of node - - Parameters must consist of air and !air. - Order doesn't matter. - - If either of the nodes doesn't exist, light is 0. - - parameters: - daynight_ratio: 0...1000 - n: getNodeParent(p) - n2: getNodeParent(p + face_dir) - face_dir: axis oriented unit vector from p to p2 - - returns encoded light value. -*/ -u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2, - v3s16 face_dir) -{ - try{ - u8 light; - u8 l1 = n.getLightBlend(daynight_ratio); - u8 l2 = n2.getLightBlend(daynight_ratio); - if(l1 > l2) - light = l1; - else - light = l2; - - // Make some nice difference to different sides - - // This makes light come from a corner - /*if(face_dir.X == 1 || face_dir.Z == 1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.X == -1 || face_dir.Z == -1) - light = diminish_light(light);*/ - - // All neighboring faces have different shade (like in minecraft) - if(face_dir.X == 1 || face_dir.X == -1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.Z == 1 || face_dir.Z == -1) - light = diminish_light(light); - - return light; - } - catch(InvalidPositionException &e) - { - return 0; - } -} - -