Remove most exceptions from getNode() (and variants)

src/collision.cpp

@@ -251,9 +251,13 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
 	for(s16 z = min_z; z <= max_z; z++)
 	{
 		v3s16 p(x,y,z);
-		try{
+
+		bool is_position_valid;
+		MapNode n = map->getNodeNoEx(p, &is_position_valid);
+
+		if (is_position_valid) {
 			// Object collides into walkable nodes
-			MapNode n = map->getNode(p);
+
 			const ContentFeatures &f = gamedef->getNodeDefManager()->get(n);
 			if(f.walkable == false)
 				continue;
@@ -275,8 +279,7 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
 				is_object.push_back(false);
 			}
 		}
-		catch(InvalidPositionException &e)
+		else {
-		{
 			// Collide with unloaded nodes
 			aabb3f box = getNodeBox(p, BS);
 			cboxes.push_back(box);

src/content_cso.cpp

@@ -60,13 +60,12 @@ public:
 		m_spritenode->setVisible(true);
 		m_spritenode->setSize(size);
 		/* Update brightness */
-		u8 light = 64;
+		u8 light;
-		try{
+		bool pos_ok;
-			MapNode n = env->getMap().getNode(floatToInt(pos, BS));
+		MapNode n = env->getMap().getNodeNoEx(floatToInt(pos, BS), &pos_ok);
-			light = decode_light(n.getLightBlend(env->getDayNightRatio(),
+		light = pos_ok ? decode_light(n.getLightBlend(env->getDayNightRatio(),
-					env->getGameDef()->ndef()));
+							env->getGameDef()->ndef()))
-		}
+		               : 64;
-		catch(InvalidPositionException &e){}
 		video::SColor color(255,light,light,light);
 		m_spritenode->setColor(color);
 	}

src/environment.cpp

@@ -2342,10 +2342,8 @@ void ClientEnvironment::step(float dtime)
 		// (day: LIGHT_SUN, night: 0)
 		MapNode node_at_lplayer(CONTENT_AIR, 0x0f, 0);
 
-		try {
+		v3s16 p = lplayer->getLightPosition();
-			v3s16 p = lplayer->getLightPosition();
+		node_at_lplayer = m_map->getNodeNoEx(p);
-			node_at_lplayer = m_map->getNode(p);
-		} catch (InvalidPositionException &e) {}
 
 		u16 light = getInteriorLight(node_at_lplayer, 0, m_gamedef->ndef());
 		u8 day = light & 0xff;
@@ -2371,15 +2369,16 @@ void ClientEnvironment::step(float dtime)
 		{
 			// Update lighting
 			u8 light = 0;
-			try{
+			bool pos_ok;
-				// Get node at head
+
-				v3s16 p = obj->getLightPosition();
+			// Get node at head
-				MapNode n = m_map->getNode(p);
+			v3s16 p = obj->getLightPosition();
+			MapNode n = m_map->getNodeNoEx(p, &pos_ok);
+			if (pos_ok)
 				light = n.getLightBlend(day_night_ratio, m_gamedef->ndef());
-			}
+			else
-			catch(InvalidPositionException &e){
 				light = blend_light(day_night_ratio, LIGHT_SUN, 0);
-			}
+
 			obj->updateLight(light);
 		}
 	}
@@ -2470,15 +2469,16 @@ u16 ClientEnvironment::addActiveObject(ClientActiveObject *object)
 	object->addToScene(m_smgr, m_texturesource, m_irr);
 	{ // Update lighting immediately
 		u8 light = 0;
-		try{
+		bool pos_ok;
-			// Get node at head
+
-			v3s16 p = object->getLightPosition();
+		// Get node at head
-			MapNode n = m_map->getNode(p);
+		v3s16 p = object->getLightPosition();
+		MapNode n = m_map->getNodeNoEx(p, &pos_ok);
+		if (pos_ok)
 			light = n.getLightBlend(getDayNightRatio(), m_gamedef->ndef());
-		}
+		else
-		catch(InvalidPositionException &e){
 			light = blend_light(getDayNightRatio(), LIGHT_SUN, 0);
-		}
+
 		object->updateLight(light);
 	}
 	return object->getId();

src/game.cpp

@@ -360,12 +360,11 @@ PointedThing getPointedThing(Client *client, v3f player_position,
 		for (s16 z = zstart; z <= zend; z++)
 			for (s16 x = xstart; x <= xend; x++) {
 				MapNode n;
+				bool is_valid_position;
 
-				try {
+				n = map.getNodeNoEx(v3s16(x, y, z), &is_valid_position);
-					n = map.getNode(v3s16(x, y, z));
+				if (!is_valid_position)
-				} catch (InvalidPositionException &e) {
 					continue;
-				}
 
 				if (!isPointableNode(n, client, liquids_pointable))
 					continue;
@@ -873,22 +872,31 @@ bool nodePlacementPrediction(Client &client,
 	std::string prediction = playeritem_def.node_placement_prediction;
 	INodeDefManager *nodedef = client.ndef();
 	ClientMap &map = client.getEnv().getClientMap();
+	MapNode node;
+	bool is_valid_position;
 
-	if (prediction != "" && !nodedef->get(map.getNode(nodepos)).rightclickable) {
+	node = map.getNodeNoEx(nodepos, &is_valid_position);
+	if (!is_valid_position)
+		return false;
+
+	if (prediction != "" && !nodedef->get(node).rightclickable) {
 		verbosestream << "Node placement prediction for "
 			      << playeritem_def.name << " is "
 			      << prediction << std::endl;
 		v3s16 p = neighbourpos;
 
 		// Place inside node itself if buildable_to
-		try {
+		MapNode n_under = map.getNodeNoEx(nodepos, &is_valid_position);
-			MapNode n_under = map.getNode(nodepos);
+		if (is_valid_position)
-
+		{
 			if (nodedef->get(n_under).buildable_to)
 				p = nodepos;
-			else if (!nodedef->get(map.getNode(p)).buildable_to)
+			else {
-				return false;
+				node = map.getNodeNoEx(p, &is_valid_position);
-		} catch (InvalidPositionException &e) {}
+				if (is_valid_position &&!nodedef->get(node).buildable_to)
+					return false;
+			}
+		}
 
 		// Find id of predicted node
 		content_t id;
@@ -946,7 +954,7 @@ bool nodePlacementPrediction(Client &client,
 			else
 				pp = p + v3s16(0, -1, 0);
 
-			if (!nodedef->get(map.getNode(pp)).walkable)
+			if (!nodedef->get(map.getNodeNoEx(pp)).walkable)
 				return false;
 		}
 
@@ -3431,7 +3439,7 @@ void Game::handlePointingAtNode(GameRunData *runData,
 	if (meta) {
 		infotext = narrow_to_wide(meta->getString("infotext"));
 	} else {
-		MapNode n = map.getNode(nodepos);
+		MapNode n = map.getNodeNoEx(nodepos);
 
 		if (nodedef_manager->get(n).tiledef[0].name == "unknown_node.png") {
 			infotext = L"Unknown node: ";
@@ -3489,7 +3497,7 @@ void Game::handlePointingAtNode(GameRunData *runData,
 			}
 
 			if (playeritem_def.node_placement_prediction == "" ||
-					nodedef_manager->get(map.getNode(nodepos)).rightclickable)
+					nodedef_manager->get(map.getNodeNoEx(nodepos)).rightclickable)
 				client->interact(3, pointed); // Report to server
 		}
 	}
@@ -3558,7 +3566,7 @@ void Game::handleDigging(GameRunData *runData,
 
 	LocalPlayer *player = client->getEnv().getLocalPlayer();
 	ClientMap &map = client->getEnv().getClientMap();
-	MapNode n = client->getEnv().getClientMap().getNode(nodepos);
+	MapNode n = client->getEnv().getClientMap().getNodeNoEx(nodepos);
 
 	// NOTE: Similar piece of code exists on the server side for
 	// cheat detection.
@@ -3623,8 +3631,10 @@ void Game::handleDigging(GameRunData *runData,
 		infostream << "Digging completed" << std::endl;
 		client->interact(2, pointed);
 		client->setCrack(-1, v3s16(0, 0, 0));
-		MapNode wasnode = map.getNode(nodepos);
+		bool is_valid_position;
-		client->removeNode(nodepos);
+		MapNode wasnode = map.getNodeNoEx(nodepos, &is_valid_position);
+		if (is_valid_position)
+			client->removeNode(nodepos);
 
 		if (g_settings->getBool("enable_particles")) {
 			const ContentFeatures &features =

src/localplayer.cpp

@@ -101,39 +101,48 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
 		Collision detection
 	*/
 	
+	bool is_valid_position;
+	MapNode node;
+	v3s16 pp;
+
 	/*
 		Check if player is in liquid (the oscillating value)
 	*/
-	try{
+
-		// If in liquid, the threshold of coming out is at higher y
+	// If in liquid, the threshold of coming out is at higher y
-		if(in_liquid)
+	if (in_liquid)
-		{
-			v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
-			in_liquid = nodemgr->get(map->getNode(pp).getContent()).isLiquid();
-			liquid_viscosity = nodemgr->get(map->getNode(pp).getContent()).liquid_viscosity;
-		}
-		// If not in liquid, the threshold of going in is at lower y
-		else
-		{
-			v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
-			in_liquid = nodemgr->get(map->getNode(pp).getContent()).isLiquid();
-			liquid_viscosity = nodemgr->get(map->getNode(pp).getContent()).liquid_viscosity;
-		}
-	}
-	catch(InvalidPositionException &e)
 	{
-		in_liquid = false;
+		pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
+		node = map->getNodeNoEx(pp, &is_valid_position);
+		if (is_valid_position) {
+			in_liquid = nodemgr->get(node.getContent()).isLiquid();
+			liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity;
+		} else {
+			in_liquid = false;
+		}
 	}
+	// If not in liquid, the threshold of going in is at lower y
+	else
+	{
+		pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
+		node = map->getNodeNoEx(pp, &is_valid_position);
+		if (is_valid_position) {
+			in_liquid = nodemgr->get(node.getContent()).isLiquid();
+			liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity;
+		} else {
+			in_liquid = false;
+		}
+	}
+
 
 	/*
 		Check if player is in liquid (the stable value)
 	*/
-	try{
+	pp = floatToInt(position + v3f(0,0,0), BS);
-		v3s16 pp = floatToInt(position + v3f(0,0,0), BS);
+	node = map->getNodeNoEx(pp, &is_valid_position);
-		in_liquid_stable = nodemgr->get(map->getNode(pp).getContent()).isLiquid();
+	if (is_valid_position) {
-	}
+		in_liquid_stable = nodemgr->get(node.getContent()).isLiquid();
-	catch(InvalidPositionException &e)
+	} else {
-	{
 		in_liquid_stable = false;
 	}
 
@@ -141,17 +150,21 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
 	        Check if player is climbing
 	*/
 
-	try {
+
-		v3s16 pp = floatToInt(position + v3f(0,0.5*BS,0), BS);
+	pp = floatToInt(position + v3f(0,0.5*BS,0), BS);
-		v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
+	v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
-		is_climbing = ((nodemgr->get(map->getNode(pp).getContent()).climbable ||
+	node = map->getNodeNoEx(pp, &is_valid_position);
-		nodemgr->get(map->getNode(pp2).getContent()).climbable) && !free_move);
+	bool is_valid_position2;
-	}
+	MapNode node2 = map->getNodeNoEx(pp2, &is_valid_position2);
-	catch(InvalidPositionException &e)
+
-	{
+	if (!(is_valid_position && is_valid_position2)) {
 		is_climbing = false;
+	} else {
+		is_climbing = (nodemgr->get(node.getContent()).climbable
+				|| nodemgr->get(node2.getContent()).climbable) && !free_move;
 	}
 
+
 	/*
 		Collision uncertainty radius
 		Make it a bit larger than the maximum distance of movement
@@ -264,22 +277,20 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
 					max_axis_distance_f > 0.5*BS + sneak_max + 0.1*BS)
 				continue;
 
-			try{
+
-				// The node to be sneaked on has to be walkable
+			// The node to be sneaked on has to be walkable
-				if(nodemgr->get(map->getNode(p)).walkable == false)
+			node = map->getNodeNoEx(p, &is_valid_position);
-					continue;
+			if (!is_valid_position || nodemgr->get(node).walkable == false)
-				// And the node above it has to be nonwalkable
-				if(nodemgr->get(map->getNode(p+v3s16(0,1,0))).walkable == true) {
-					continue;
-				}
-				if (!physics_override_sneak_glitch) {
-					if (nodemgr->get(map->getNode(p+v3s16(0,2,0))).walkable)
-						continue;
-				}
-			}
-			catch(InvalidPositionException &e)
-			{
 				continue;
+			// And the node above it has to be nonwalkable
+			node = map->getNodeNoEx(p + v3s16(0,1,0), &is_valid_position);
+			if (!is_valid_position || nodemgr->get(node).walkable) {
+				continue;
+			}
+			if (!physics_override_sneak_glitch) {
+				node =map->getNodeNoEx(p + v3s16(0,2,0), &is_valid_position);
+				if (!is_valid_position || nodemgr->get(node).walkable)
+					continue;
 			}
 
 			min_distance_f = distance_f;

src/map.cpp

@@ -186,26 +186,42 @@ bool Map::isValidPosition(v3s16 p)
 }
 
 // Returns a CONTENT_IGNORE node if not found
-MapNode Map::getNodeNoEx(v3s16 p)
+MapNode Map::getNodeNoEx(v3s16 p, bool *is_valid_position)
 {
 	v3s16 blockpos = getNodeBlockPos(p);
 	MapBlock *block = getBlockNoCreateNoEx(blockpos);
-	if(block == NULL)
+	if (block == NULL) {
+		if (is_valid_position != NULL)
+			*is_valid_position = false;
 		return MapNode(CONTENT_IGNORE);
+	}
+
 	v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
-	return block->getNodeNoCheck(relpos);
+	bool is_valid_p;
+	MapNode node = block->getNodeNoCheck(relpos, &is_valid_p);
+	if (is_valid_position != NULL)
+		*is_valid_position = is_valid_p;
+	return node;
 }
 
+#if 0
+// Deprecated
 // throws InvalidPositionException if not found
+// TODO: Now this is deprecated, getNodeNoEx should be renamed
 MapNode Map::getNode(v3s16 p)
 {
 	v3s16 blockpos = getNodeBlockPos(p);
 	MapBlock *block = getBlockNoCreateNoEx(blockpos);
-	if(block == NULL)
+	if (block == NULL)
 		throw InvalidPositionException();
 	v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
-	return block->getNodeNoCheck(relpos);
+	bool is_valid_position;
+	MapNode node = block->getNodeNoCheck(relpos, &is_valid_position);
+	if (!is_valid_position)
+		throw InvalidPositionException();
+	return node;
 }
+#endif
 
 // throws InvalidPositionException if not found
 void Map::setNode(v3s16 p, MapNode & n)
@@ -215,9 +231,10 @@ void Map::setNode(v3s16 p, MapNode & n)
 	v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 	// Never allow placing CONTENT_IGNORE, it fucks up stuff
 	if(n.getContent() == CONTENT_IGNORE){
+		bool temp_bool;
 		errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
 				<<" while trying to replace \""
-				<<m_gamedef->ndef()->get(block->getNodeNoCheck(relpos)).name
+				<<m_gamedef->ndef()->get(block->getNodeNoCheck(relpos, &temp_bool)).name
 				<<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
 		debug_stacks_print_to(infostream);
 		return;
@@ -315,89 +332,84 @@ void Map::unspreadLight(enum LightBank bank,
 			// Get the block where the node is located
 			v3s16 blockpos = getNodeBlockPos(n2pos);
 
-			try
+			// Only fetch a new block if the block position has changed
-			{
+			try {
-				// Only fetch a new block if the block position has changed
+				if(block == NULL || blockpos != blockpos_last){
-				try{
+					block = getBlockNoCreate(blockpos);
-					if(block == NULL || blockpos != blockpos_last){
+					blockpos_last = blockpos;
-						block = getBlockNoCreate(blockpos);
-						blockpos_last = blockpos;
 
-						block_checked_in_modified = false;
+					block_checked_in_modified = false;
-						blockchangecount++;
+					blockchangecount++;
-					}
-				}
-				catch(InvalidPositionException &e)
-				{
-					continue;
-				}
-
-				// Calculate relative position in block
-				v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
-				// Get node straight from the block
-				MapNode n2 = block->getNode(relpos);
-
-				bool changed = false;
-
-				//TODO: Optimize output by optimizing light_sources?
-
-				/*
-					If the neighbor is dimmer than what was specified
-					as oldlight (the light of the previous node)
-				*/
-				if(n2.getLight(bank, nodemgr) < oldlight)
-				{
-					/*
-						And the neighbor is transparent and it has some light
-					*/
-					if(nodemgr->get(n2).light_propagates
-							&& n2.getLight(bank, nodemgr) != 0)
-					{
-						/*
-							Set light to 0 and add to queue
-						*/
-
-						u8 current_light = n2.getLight(bank, nodemgr);
-						n2.setLight(bank, 0, nodemgr);
-						block->setNode(relpos, n2);
-
-						unlighted_nodes[n2pos] = current_light;
-						changed = true;
-
-						/*
-							Remove from light_sources if it is there
-							NOTE: This doesn't happen nearly at all
-						*/
-						/*if(light_sources.find(n2pos))
-						{
-							infostream<<"Removed from light_sources"<<std::endl;
-							light_sources.remove(n2pos);
-						}*/
-					}
-
-					/*// DEBUG
-					if(light_sources.find(n2pos) != NULL)
-						light_sources.remove(n2pos);*/
-				}
-				else{
-					light_sources.insert(n2pos);
-				}
-
-				// Add to modified_blocks
-				if(changed == true && block_checked_in_modified == false)
-				{
-					// If the block is not found in modified_blocks, add.
-					if(modified_blocks.find(blockpos) == modified_blocks.end())
-					{
-						modified_blocks[blockpos] = block;
-					}
-					block_checked_in_modified = true;
 				}
 			}
-			catch(InvalidPositionException &e)
+			catch(InvalidPositionException &e) {
-			{
 				continue;
 			}
+
+			// Calculate relative position in block
+			v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
+			// Get node straight from the block
+			bool is_valid_position;
+			MapNode n2 = block->getNode(relpos, &is_valid_position);
+			if (!is_valid_position)
+				continue;
+
+			bool changed = false;
+
+			//TODO: Optimize output by optimizing light_sources?
+
+			/*
+				If the neighbor is dimmer than what was specified
+				as oldlight (the light of the previous node)
+			*/
+			if(n2.getLight(bank, nodemgr) < oldlight)
+			{
+				/*
+					And the neighbor is transparent and it has some light
+				*/
+				if(nodemgr->get(n2).light_propagates
+						&& n2.getLight(bank, nodemgr) != 0)
+				{
+					/*
+						Set light to 0 and add to queue
+					*/
+
+					u8 current_light = n2.getLight(bank, nodemgr);
+					n2.setLight(bank, 0, nodemgr);
+					block->setNode(relpos, n2);
+
+					unlighted_nodes[n2pos] = current_light;
+					changed = true;
+
+					/*
+						Remove from light_sources if it is there
+						NOTE: This doesn't happen nearly at all
+					*/
+					/*if(light_sources.find(n2pos))
+					{
+						infostream<<"Removed from light_sources"<<std::endl;
+						light_sources.remove(n2pos);
+					}*/
+				}
+
+				/*// DEBUG
+				if(light_sources.find(n2pos) != NULL)
+					light_sources.remove(n2pos);*/
+			}
+			else{
+				light_sources.insert(n2pos);
+			}
+
+			// Add to modified_blocks
+			if(changed == true && block_checked_in_modified == false)
+			{
+				// If the block is not found in modified_blocks, add.
+				if(modified_blocks.find(blockpos) == modified_blocks.end())
+				{
+					modified_blocks[blockpos] = block;
+				}
+				block_checked_in_modified = true;
+			}
 		}
 	}
 
@@ -465,7 +477,7 @@ void Map::spreadLight(enum LightBank bank,
 		v3s16 blockpos = getNodeBlockPos(pos);
 
 		// Only fetch a new block if the block position has changed
-		try{
+		try {
 			if(block == NULL || blockpos != blockpos_last){
 				block = getBlockNoCreate(blockpos);
 				blockpos_last = blockpos;
@@ -474,8 +486,7 @@ void Map::spreadLight(enum LightBank bank,
 				blockchangecount++;
 			}
 		}
-		catch(InvalidPositionException &e)
+		catch(InvalidPositionException &e) {
-		{
 			continue;
 		}
 
@@ -486,9 +497,10 @@ void Map::spreadLight(enum LightBank bank,
 		v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
 
 		// Get node straight from the block
-		MapNode n = block->getNode(relpos);
+		bool is_valid_position;
+		MapNode n = block->getNode(relpos, &is_valid_position);
 
-		u8 oldlight = n.getLight(bank, nodemgr);
+		u8 oldlight = is_valid_position ? n.getLight(bank, nodemgr) : 0;
 		u8 newlight = diminish_light(oldlight);
 
 		// Loop through 6 neighbors
@@ -499,67 +511,61 @@ void Map::spreadLight(enum LightBank bank,
 			// Get the block where the node is located
 			v3s16 blockpos = getNodeBlockPos(n2pos);
 
-			try
+			// Only fetch a new block if the block position has changed
+			try {
+				if(block == NULL || blockpos != blockpos_last){
+					block = getBlockNoCreate(blockpos);
+					blockpos_last = blockpos;
+
+					block_checked_in_modified = false;
+					blockchangecount++;
+				}
+			}
+			catch(InvalidPositionException &e) {
+				continue;
+			}
+
+			// Calculate relative position in block
+			v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
+			// Get node straight from the block
+			MapNode n2 = block->getNode(relpos, &is_valid_position);
+			if (!is_valid_position)
+				continue;
+
+			bool changed = false;
+			/*
+				If the neighbor is brighter than the current node,
+				add to list (it will light up this node on its turn)
+			*/
+			if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight))
 			{
-				// Only fetch a new block if the block position has changed
+				lighted_nodes.insert(n2pos);
-				try{
+				changed = true;
-					if(block == NULL || blockpos != blockpos_last){
+			}
-						block = getBlockNoCreate(blockpos);
+			/*
-						blockpos_last = blockpos;
+				If the neighbor is dimmer than how much light this node
-
+				would spread on it, add to list
-						block_checked_in_modified = false;
+			*/
-						blockchangecount++;
+			if(n2.getLight(bank, nodemgr) < newlight)
-					}
+			{
-				}
+				if(nodemgr->get(n2).light_propagates)
-				catch(InvalidPositionException &e)
-				{
-					continue;
-				}
-
-				// Calculate relative position in block
-				v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
-				// Get node straight from the block
-				MapNode n2 = block->getNode(relpos);
-
-				bool changed = false;
-				/*
-					If the neighbor is brighter than the current node,
-					add to list (it will light up this node on its turn)
-				*/
-				if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight))
 				{
+					n2.setLight(bank, newlight, nodemgr);
+					block->setNode(relpos, n2);
 					lighted_nodes.insert(n2pos);
 					changed = true;
 				}
-				/*
-					If the neighbor is dimmer than how much light this node
-					would spread on it, add to list
-				*/
-				if(n2.getLight(bank, nodemgr) < newlight)
-				{
-					if(nodemgr->get(n2).light_propagates)
-					{
-						n2.setLight(bank, newlight, nodemgr);
-						block->setNode(relpos, n2);
-						lighted_nodes.insert(n2pos);
-						changed = true;
-					}
-				}
-
-				// Add to modified_blocks
-				if(changed == true && block_checked_in_modified == false)
-				{
-					// If the block is not found in modified_blocks, add.
-					if(modified_blocks.find(blockpos) == modified_blocks.end())
-					{
-						modified_blocks[blockpos] = block;
-					}
-					block_checked_in_modified = true;
-				}
 			}
-			catch(InvalidPositionException &e)
+
+			// Add to modified_blocks
+			if(changed == true && block_checked_in_modified == false)
 			{
-				continue;
+				// If the block is not found in modified_blocks, add.
+				if(modified_blocks.find(blockpos) == modified_blocks.end())
+				{
+					modified_blocks[blockpos] = block;
+				}
+				block_checked_in_modified = true;
 			}
 		}
 	}
@@ -607,13 +613,11 @@ v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p)
 		// Get the position of the neighbor node
 		v3s16 n2pos = p + dirs[i];
 		MapNode n2;
-		try{
+		bool is_valid_position;
-			n2 = getNode(n2pos);
+		n2 = getNodeNoEx(n2pos, &is_valid_position);
-		}
+		if (!is_valid_position)
-		catch(InvalidPositionException &e)
-		{
 			continue;
-		}
+
 		if(n2.getLight(bank, nodemgr) > brightest_light || found_something == false){
 			brightest_light = n2.getLight(bank, nodemgr);
 			brightest_pos = n2pos;
@@ -656,7 +660,10 @@ s16 Map::propagateSunlight(v3s16 start,
 		}
 
 		v3s16 relpos = pos - blockpos*MAP_BLOCKSIZE;
-		MapNode n = block->getNode(relpos);
+		bool is_valid_position;
+		MapNode n = block->getNode(relpos, &is_valid_position);
+		if (!is_valid_position)
+			break;
 
 		if(nodemgr->get(n).sunlight_propagates)
 		{
@@ -723,39 +730,37 @@ void Map::updateLighting(enum LightBank bank,
 			for(s16 x=0; x<MAP_BLOCKSIZE; x++)
 			for(s16 y=0; y<MAP_BLOCKSIZE; y++)
 			{
-
+				v3s16 p(x,y,z);
-				try{
+				bool is_valid_position;
-					v3s16 p(x,y,z);
+				MapNode n = block->getNode(p, &is_valid_position);
-					MapNode n = block->getNode(p);
+				if (!is_valid_position) {
-					u8 oldlight = n.getLight(bank, nodemgr);
+					/* This would happen when dealing with a
-					n.setLight(bank, 0, nodemgr);
+					   dummy block.
-					block->setNode(p, n);
-
-					// If node sources light, add to list
-					u8 source = nodemgr->get(n).light_source;
-					if(source != 0)
-						light_sources.insert(p + posnodes);
-
-					// Collect borders for unlighting
-					if((x==0 || x == MAP_BLOCKSIZE-1
-					|| y==0 || y == MAP_BLOCKSIZE-1
-					|| z==0 || z == MAP_BLOCKSIZE-1)
-					&& oldlight != 0)
-					{
-						v3s16 p_map = p + posnodes;
-						unlight_from[p_map] = oldlight;
-					}
-				}
-				catch(InvalidPositionException &e)
-				{
-					/*
-						This would happen when dealing with a
-						dummy block.
 					*/
-					//assert(0);
 					infostream<<"updateLighting(): InvalidPositionException"
 							<<std::endl;
+					continue;
 				}
+				u8 oldlight = n.getLight(bank, nodemgr);
+				n.setLight(bank, 0, nodemgr);
+				block->setNode(p, n);
+
+				// If node sources light, add to list
+				u8 source = nodemgr->get(n).light_source;
+				if(source != 0)
+					light_sources.insert(p + posnodes);
+
+				// Collect borders for unlighting
+				if((x==0 || x == MAP_BLOCKSIZE-1
+						|| y==0 || y == MAP_BLOCKSIZE-1
+						|| z==0 || z == MAP_BLOCKSIZE-1)
+						&& oldlight != 0)
+				{
+					v3s16 p_map = p + posnodes;
+					unlight_from[p_map] = oldlight;
+				}
+
+
 			}
 
 			if(bank == LIGHTBANK_DAY)
@@ -965,15 +970,12 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 
 		Otherwise there probably is.
 	*/
-	try{
-		MapNode topnode = getNode(toppos);
 
-		if(topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
+	bool is_valid_position;
-			node_under_sunlight = false;
+	MapNode topnode = getNodeNoEx(toppos, &is_valid_position);
-	}
+
-	catch(InvalidPositionException &e)
+	if(is_valid_position && topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
-	{
+		node_under_sunlight = false;
-	}
 
 	/*
 		Remove all light that has come out of this node
@@ -988,7 +990,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 	{
 		enum LightBank bank = banks[i];
 
-		u8 lightwas = getNode(p).getLight(bank, ndef);
+		u8 lightwas = getNodeNoEx(p).getLight(bank, ndef);
 
 		// Add the block of the added node to modified_blocks
 		v3s16 blockpos = getNodeBlockPos(p);
@@ -1045,13 +1047,10 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 			v3s16 n2pos(p.X, y, p.Z);
 
 			MapNode n2;
-			try{
+
-				n2 = getNode(n2pos);
+			n2 = getNodeNoEx(n2pos, &is_valid_position);
-			}
+			if (!is_valid_position)
-			catch(InvalidPositionException &e)
-			{
 				break;
-			}
 
 			if(n2.getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN)
 			{
@@ -1112,20 +1111,14 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 	};
 	for(u16 i=0; i<7; i++)
 	{
-		try
-		{
-
 		v3s16 p2 = p + dirs[i];
 
-		MapNode n2 = getNode(p2);
+		MapNode n2 = getNodeNoEx(p2, &is_valid_position);
-		if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
+		if(is_valid_position
+				&& (ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR))
 		{
 			m_transforming_liquid.push_back(p2);
 		}
-
-		}catch(InvalidPositionException &e)
-		{
-		}
 	}
 }
 
@@ -1156,15 +1149,11 @@ void Map::removeNodeAndUpdate(v3s16 p,
 		If there is a node at top and it doesn't have sunlight,
 		there will be no sunlight going down.
 	*/
-	try{
+	bool is_valid_position;
-		MapNode topnode = getNode(toppos);
+	MapNode topnode = getNodeNoEx(toppos, &is_valid_position);
 
-		if(topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
+	if(is_valid_position && topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
-			node_under_sunlight = false;
+		node_under_sunlight = false;
-	}
-	catch(InvalidPositionException &e)
-	{
-	}
 
 	std::set<v3s16> light_sources;
 
@@ -1181,7 +1170,7 @@ void Map::removeNodeAndUpdate(v3s16 p,
 			Unlight neighbors (in case the node is a light source)
 		*/
 		unLightNeighbors(bank, p,
-				getNode(p).getLight(bank, ndef),
+				getNodeNoEx(p).getLight(bank, ndef),
 				light_sources, modified_blocks);
 	}
 
@@ -1241,13 +1230,11 @@ void Map::removeNodeAndUpdate(v3s16 p,
 	{
 		// Set the lighting of this node to 0
 		// TODO: Is this needed? Lighting is cleared up there already.
-		try{
+		MapNode n = getNodeNoEx(p, &is_valid_position);
-			MapNode n = getNode(p);
+		if (is_valid_position) {
 			n.setLight(LIGHTBANK_DAY, 0, ndef);
 			setNode(p, n);
-		}
+		} else {
-		catch(InvalidPositionException &e)
-		{
 			assert(0);
 		}
 	}
@@ -1303,20 +1290,15 @@ void Map::removeNodeAndUpdate(v3s16 p,
 	};
 	for(u16 i=0; i<7; i++)
 	{
-		try
-		{
-
 		v3s16 p2 = p + dirs[i];
 
-		MapNode n2 = getNode(p2);
+		bool is_position_valid;
-		if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
+		MapNode n2 = getNodeNoEx(p2, &is_position_valid);
+		if (is_position_valid
+				&& (ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR))
 		{
 			m_transforming_liquid.push_back(p2);
 		}
-
-		}catch(InvalidPositionException &e)
-		{
-		}
 	}
 }
 

src/map.h

@@ -197,14 +197,13 @@ public:
 
 	bool isValidPosition(v3s16 p);
 
-	// throws InvalidPositionException if not found
-	MapNode getNode(v3s16 p);
-
 	// throws InvalidPositionException if not found
 	void setNode(v3s16 p, MapNode & n);
 
 	// Returns a CONTENT_IGNORE node if not found
-	MapNode getNodeNoEx(v3s16 p);
+	// If is_valid_position is not NULL then this will be set to true if the
+	// position is valid, otherwise false
+	MapNode getNodeNoEx(v3s16 p, bool *is_valid_position = NULL);
 
 	void unspreadLight(enum LightBank bank,
 			std::map<v3s16, u8> & from_nodes,

src/mapblock.cpp

@@ -97,54 +97,19 @@ bool MapBlock::isValidPositionParent(v3s16 p)
 	}
 }
 
-MapNode MapBlock::getNodeParent(v3s16 p)
+MapNode MapBlock::getNodeParent(v3s16 p, bool *is_valid_position)
 {
-	if(isValidPosition(p) == false)
+	if (isValidPosition(p) == false)
-	{
+		return m_parent->getNodeNoEx(getPosRelative() + p, is_valid_position);
-		return m_parent->getNode(getPosRelative() + p);
-	}
-	else
-	{
-		if(data == NULL)
-			throw InvalidPositionException();
-		return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
-	}
-}
 
-void MapBlock::setNodeParent(v3s16 p, MapNode & n)
+	if (data == NULL) {
-{
+		if (is_valid_position)
-	if(isValidPosition(p) == false)
+			*is_valid_position = false;
-	{
+		return MapNode(CONTENT_IGNORE);
-		m_parent->setNode(getPosRelative() + p, n);
-	}
-	else
-	{
-		if(data == NULL)
-			throw InvalidPositionException();
-		data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X] = n;
-	}
-}
-
-MapNode MapBlock::getNodeParentNoEx(v3s16 p)
-{
-	if(isValidPosition(p) == false)
-	{
-		try{
-			return m_parent->getNode(getPosRelative() + p);
-		}
-		catch(InvalidPositionException &e)
-		{
-			return MapNode(CONTENT_IGNORE);
-		}
-	}
-	else
-	{
-		if(data == NULL)
-		{
-			return MapNode(CONTENT_IGNORE);
-		}
-		return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
 	}
+	if (is_valid_position)
+		*is_valid_position = true;
+	return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
 }
 
 /*
@@ -183,9 +148,14 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
 #if 1
 			bool no_sunlight = false;
 			bool no_top_block = false;
+
 			// Check if node above block has sunlight
-			try{
+
-				MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z));
+			bool is_valid_position;
+			MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z),
+				&is_valid_position);
+			if (is_valid_position)
+			{
 				if(n.getContent() == CONTENT_IGNORE)
 				{
 					// Trust heuristics
@@ -196,7 +166,7 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
 					no_sunlight = true;
 				}
 			}
-			catch(InvalidPositionException &e)
+			else
 			{
 				no_top_block = true;
 				
@@ -208,7 +178,7 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
 				}
 				else
 				{
-					MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z));
+					MapNode n = getNodeNoEx(v3s16(x, MAP_BLOCKSIZE-1, z));
 					if(m_gamedef->ndef()->get(n).sunlight_propagates == false)
 					{
 						no_sunlight = true;
@@ -308,27 +278,27 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
 				
 				Ignore non-transparent nodes as they always have no light
 			*/
-			try
+
-			{
 			if(block_below_is_valid)
 			{
-				MapNode n = getNodeParent(v3s16(x, -1, z));
+				MapNode n = getNodeParent(v3s16(x, -1, z), &is_valid_position);
-				if(nodemgr->get(n).light_propagates)
+				if (is_valid_position) {
-				{
+					if(nodemgr->get(n).light_propagates)
-					if(n.getLight(LIGHTBANK_DAY, nodemgr) == LIGHT_SUN
+					{
-							&& sunlight_should_go_down == false)
+						if(n.getLight(LIGHTBANK_DAY, nodemgr) == LIGHT_SUN
-						block_below_is_valid = false;
+								&& sunlight_should_go_down == false)
-					else if(n.getLight(LIGHTBANK_DAY, nodemgr) != LIGHT_SUN
+							block_below_is_valid = false;
-							&& sunlight_should_go_down == true)
+						else if(n.getLight(LIGHTBANK_DAY, nodemgr) != LIGHT_SUN
-						block_below_is_valid = false;
+								&& sunlight_should_go_down == true)
+							block_below_is_valid = false;
+					}
+				}
+				else
+				{
+					/*std::cout<<"InvalidBlockException for bottom block node"
+							<<std::endl;*/
+					// Just no block below, no need to panic.
 				}
-			}//if
-			}//try
-			catch(InvalidPositionException &e)
-			{
-				/*std::cout<<"InvalidBlockException for bottom block node"
-						<<std::endl;*/
-				// Just no block below, no need to panic.
 			}
 		}
 	}
@@ -1070,7 +1040,7 @@ std::string analyze_block(MapBlock *block)
 		for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
 		{
 			v3s16 p(x0,y0,z0);
-			MapNode n = block->getNode(p);
+			MapNode n = block->getNodeNoEx(p);
 			content_t c = n.getContent();
 			if(c == CONTENT_IGNORE)
 				some_ignore = true;

src/mapblock.h

@@ -251,37 +251,39 @@ public:
 		Regular MapNode get-setters
 	*/
 	
-	bool isValidPosition(v3s16 p)
+	bool isValidPosition(s16 x, s16 y, s16 z)
 	{
-		if(data == NULL)
+		return data != NULL
-			return false;
+				&& x >= 0 && x < MAP_BLOCKSIZE
-		return (p.X >= 0 && p.X < MAP_BLOCKSIZE
+				&& y >= 0 && y < MAP_BLOCKSIZE
-				&& p.Y >= 0 && p.Y < MAP_BLOCKSIZE
+				&& z >= 0 && z < MAP_BLOCKSIZE;
-				&& p.Z >= 0 && p.Z < MAP_BLOCKSIZE);
 	}
 
-	MapNode getNode(s16 x, s16 y, s16 z)
+	bool isValidPosition(v3s16 p)
 	{
-		if(data == NULL)
+		return isValidPosition(p.X, p.Y, p.Z);
-			throw InvalidPositionException();
+	}
-		if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
+
-		if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
+	MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position)
-		if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
+	{
+		*valid_position = isValidPosition(x, y, z);
+
+		if (!*valid_position)
+			return MapNode(CONTENT_IGNORE);
+
 		return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 	}
 	
-	MapNode getNode(v3s16 p)
+	MapNode getNode(v3s16 p, bool *valid_position)
 	{
-		return getNode(p.X, p.Y, p.Z);
+		return getNode(p.X, p.Y, p.Z, valid_position);
 	}
 	
 	MapNode getNodeNoEx(v3s16 p)
 	{
-		try{
+		bool is_valid;
-			return getNode(p.X, p.Y, p.Z);
+		MapNode node = getNode(p.X, p.Y, p.Z, &is_valid);
-		}catch(InvalidPositionException &e){
+		return is_valid ? node : MapNode(CONTENT_IGNORE);
-			return MapNode(CONTENT_IGNORE);
-		}
 	}
 	
 	void setNode(s16 x, s16 y, s16 z, MapNode & n)
@@ -304,16 +306,18 @@ public:
 		Non-checking variants of the above
 	*/
 
-	MapNode getNodeNoCheck(s16 x, s16 y, s16 z)
+	MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position)
 	{
-		if(data == NULL)
+		*valid_position = data != NULL;
-			throw InvalidPositionException();
+		if(!valid_position)
+			return MapNode(CONTENT_IGNORE);
+
 		return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 	}
 	
-	MapNode getNodeNoCheck(v3s16 p)
+	MapNode getNodeNoCheck(v3s16 p, bool *valid_position)
 	{
-		return getNodeNoCheck(p.X, p.Y, p.Z);
+		return getNodeNoCheck(p.X, p.Y, p.Z, valid_position);
 	}
 	
 	void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
@@ -334,9 +338,8 @@ public:
 		is not valid on this MapBlock.
 	*/
 	bool isValidPositionParent(v3s16 p);
-	MapNode getNodeParent(v3s16 p);
+	MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL);
 	void setNodeParent(v3s16 p, MapNode & n);
-	MapNode getNodeParentNoEx(v3s16 p);
 
 	void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
 	{

src/particles.cpp

@@ -168,18 +168,19 @@ void Particle::step(float dtime)
 void Particle::updateLight()
 {
 	u8 light = 0;
-	try{
+	bool pos_ok;
-		v3s16 p = v3s16(
+
-			floor(m_pos.X+0.5),
+	v3s16 p = v3s16(
-			floor(m_pos.Y+0.5),
+		floor(m_pos.X+0.5),
-			floor(m_pos.Z+0.5)
+		floor(m_pos.Y+0.5),
-		);
+		floor(m_pos.Z+0.5)
-		MapNode n = m_env->getClientMap().getNode(p);
+	);
+	MapNode n = m_env->getClientMap().getNodeNoEx(p, &pos_ok);
+	if (pos_ok)
 		light = n.getLightBlend(m_env->getDayNightRatio(), m_gamedef->ndef());
-	}
+	else
-	catch(InvalidPositionException &e){
 		light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0);
-	}
+
 	m_light = decode_light(light);
 }
 

src/script/lua_api/l_env.cpp

@@ -159,16 +159,15 @@ int ModApiEnvMod::l_get_node_or_nil(lua_State *L)
 	// pos
 	v3s16 pos = read_v3s16(L, 1);
 	// Do it
-	try{
+	bool pos_ok;
-		MapNode n = env->getMap().getNode(pos);
+	MapNode n = env->getMap().getNodeNoEx(pos, &pos_ok);
+	if (pos_ok) {
 		// Return node
 		pushnode(L, n, env->getGameDef()->ndef());
-		return 1;
+	} else {
-	} catch(InvalidPositionException &e)
-	{
 		lua_pushnil(L);
-		return 1;
 	}
+	return 1;
 }
 
 // get_node_light(pos, timeofday)
@@ -185,16 +184,16 @@ int ModApiEnvMod::l_get_node_light(lua_State *L)
 		time_of_day = 24000.0 * lua_tonumber(L, 2);
 	time_of_day %= 24000;
 	u32 dnr = time_to_daynight_ratio(time_of_day, true);
-	try{
+
-		MapNode n = env->getMap().getNode(pos);
+	bool is_position_ok;
+	MapNode n = env->getMap().getNodeNoEx(pos, &is_position_ok);
+	if (is_position_ok) {
 		INodeDefManager *ndef = env->getGameDef()->ndef();
 		lua_pushinteger(L, n.getLightBlend(dnr, ndef));
-		return 1;
+	} else {
-	} catch(InvalidPositionException &e)
-	{
 		lua_pushnil(L);
-		return 1;
 	}
+	return 1;
 }
 
 // place_node(pos, node)

src/server.cpp

@@ -2424,17 +2424,18 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
 					somebody is cheating, by checking the timing.
 				*/
 				MapNode n(CONTENT_IGNORE);
-				try
+				bool pos_ok;
-				{
+				n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
-					n = m_env->getMap().getNode(p_under);
+				if (pos_ok)
-				}
+					n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
-				catch(InvalidPositionException &e)
+
-				{
+				if (!pos_ok) {
 					infostream<<"Server: Not punching: Node not found."
 							<<" Adding block to emerge queue."
 							<<std::endl;
 					m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
 				}
+
 				if(n.getContent() != CONTENT_IGNORE)
 					m_script->node_on_punch(p_under, n, playersao, pointed);
 				// Cheat prevention
@@ -2479,16 +2480,12 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
 			// Only digging of nodes
 			if(pointed.type == POINTEDTHING_NODE)
 			{
-				MapNode n(CONTENT_IGNORE);
+				bool pos_ok;
-				try
+				MapNode n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
-				{
+				if (!pos_ok) {
-					n = m_env->getMap().getNode(p_under);
+					infostream << "Server: Not finishing digging: Node not found."
-				}
+					           << " Adding block to emerge queue."
-				catch(InvalidPositionException &e)
+					           << std::endl;
-				{
-					infostream<<"Server: Not finishing digging: Node not found."
-							<<" Adding block to emerge queue."
-							<<std::endl;
 					m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
 				}