Index: boden/grund.cc
===================================================================
--- boden/grund.cc	(revision 8547)
+++ boden/grund.cc	(working copy)
@@ -856,10 +856,10 @@
 	for(uint i=0; i<grund_t::BACK_CORNER_COUNT; i++) {
 		corners[i] += corners_add[i];
 	}
+
 	// now test more tiles behind whether they are hidden by this tile
 	static const koord  testdir[grund_t::BACK_CORNER_COUNT] = { koord(-1,0), koord(-1,-1), koord(0,-1) };
-
-	for(int step = 0; step<5  &&  !get_flag(draw_as_obj); step ++) {
+	for(sint16 step = 0; step<grund_t::MAXIMUM_HIDE_TEST_DISTANCE  &&  !get_flag(draw_as_obj); step ++) {
 		sint16 test[grund_t::BACK_CORNER_COUNT];
 
 		for(uint i=0; i<grund_t::BACK_CORNER_COUNT; i++) {
@@ -897,8 +897,9 @@
 			}
 		}
 		if (test[0] < corners[0]  ||  test[1] < corners[1]  ||  test[2] < corners[2]) {
-			// we hide something behind
+			// we hide at least 1 thing behind
 			set_flag(draw_as_obj);
+			break;
 		}
 		else if (test[0] > corners[0]  &&  test[1] > corners[1]  &&  test[2] > corners[2]) {
 			// we cannot hide anything anymore
Index: boden/grund.h
===================================================================
--- boden/grund.h	(revision 8547)
+++ boden/grund.h	(working copy)
@@ -150,6 +150,15 @@
 	 */
 	static sint8 const BIID_ENCODE_FENCE_OFFSET = (sint8)(WALL_IMAGE_COUNT * WALL_IMAGE_COUNT);
 
+	/**
+	 * @brief Maximum distance in tiles that hide test will be performed for.
+	 *
+	 * Maximum distance in tiles that object hide test will be performed for.
+	 * The hide test is needed for correct graphic reproduction of tunnel
+	 * entrances and such.
+	 */
+	static uint16 const MAXIMUM_HIDE_TEST_DISTANCE = 5;
+
 	// just to calculate the offset for skipping the ways ...
 	static uint8 offsets[4];
 
Index: dataobj/rect.cc
===================================================================
--- dataobj/rect.cc	(nonexistent)
+++ dataobj/rect.cc	(working copy)
@@ -0,0 +1,123 @@
+#include "rect.h"
+
+
+rect_t::rect_t() :
+	origin(0, 0),
+	size(0, 0)
+{
+}
+
+rect_t::rect_t(koord const origin, koord const size) :
+	origin(origin),
+	size(size)
+{
+}
+
+rect_t::rect_t(koord const origin, sint16 const x, sint16 const y) :
+	origin(origin),
+	size(x, y)
+{
+}
+
+rect_t::~rect_t()
+{
+}
+
+size_t rect_t::fragment_difference(rect_t const &remove, rect_t *const result, size_t const result_length) const
+{
+	if (result_length < rect_t::MAX_FRAGMENT_DIFFERENCE_COUNT) {
+		assert("rect_t::fragment_difference : attempting to fragment when space in result array is less than MAX_FRAGMENT_DIFFERENCE_COUNT");
+	}
+
+	rect_t internal_remove = remove;
+	internal_remove.mask(*this);
+
+	rect_t *fragment = result;
+
+	if (internal_remove == *this) {
+		// area subset of remove so nothing returned
+	} else if(internal_remove.has_no_area()) {
+		// no overlap so entire area unchanged
+		*fragment = *this;
+		fragment++;
+	} else {
+		// partial overlap so fragmentation occurs
+
+		koord const internal_remove_extent = internal_remove.origin + internal_remove.size;
+		koord const extent = origin + size;
+
+		if (origin.y < internal_remove.origin.y) {
+			// fragment at bottom of remove rect
+			fragment->origin = origin;
+			fragment->size.x = size.x;
+			fragment->size.y = internal_remove.origin.y - origin.y;
+			fragment++;
+		}
+
+		if (origin.x < internal_remove.origin.x) {
+			// fragment at left of remove rect
+			fragment->origin.x = origin.x;
+			fragment->origin.y = internal_remove.origin.y;
+			fragment->size.x = internal_remove.origin.x - origin.x;
+			fragment->size.y = internal_remove.size.y;
+			fragment++;
+		}
+
+		if (extent.x > internal_remove_extent.x) {
+			// fragment at right of remove rect
+			fragment->origin.x = internal_remove_extent.x;
+			fragment->origin.y = internal_remove.origin.y;
+			fragment->size.x = extent.x - internal_remove_extent.x;
+			fragment->size.y = internal_remove.size.y;
+			fragment++;
+		}
+
+		if (extent.y > internal_remove_extent.y) {
+			// fragment at top of remove rect
+			fragment->origin.x = origin.x;
+			fragment->origin.y = internal_remove_extent.y;
+			fragment->size.x = size.x;
+			fragment->size.y = extent.y - internal_remove_extent.y;
+			fragment++;
+		}
+	}
+
+	return (size_t) (fragment - result);
+}
+
+void rect_t::mask(rect_t const &mask_rect)
+{
+	koord extent = origin + size;
+	koord const mask_extent = mask_rect.origin + mask_rect.size;
+
+	if (origin.x >= mask_extent.x || extent.x <= mask_rect.origin.x ||
+		origin.y >= mask_extent.y || extent.y <= mask_rect.origin.y) {
+		// completly masked
+		origin = size = koord(0, 0);
+	} else {
+		// partially masked
+		origin.clip_min(mask_rect.origin);
+		extent.clip_max(mask_extent);
+		size = extent - origin;
+	}
+}
+
+bool rect_t::has_no_area() const
+{
+	return size == koord(0, 0);
+}
+
+void rect_t::discard_area()
+{
+	size = koord(0, 0);
+}
+
+bool rect_t::operator==(rect_t const &rhs) const
+{
+	return origin == rhs.origin && size == rhs.size;
+}
+
+bool rect_t::operator!=(rect_t const &rhs) const
+{
+	return !(*this == rhs);
+}
Index: dataobj/rect.h
===================================================================
--- dataobj/rect.h	(nonexistent)
+++ dataobj/rect.h	(working copy)
@@ -0,0 +1,81 @@
+#ifndef prepmap_h
+#define prepmap_h
+
+#include "koord.h"
+#include <stddef.h>
+
+
+class rect_t {
+public:
+	/**
+	 * @brief Map index is prepared value.
+	 */
+	static size_t const MAX_FRAGMENT_DIFFERENCE_COUNT = 4;
+
+	/**
+	 * @brief Origin coordinates of this rect.
+	 *
+	 * The position of the lower left corner of this rect.
+	 */
+	koord origin;
+
+	/**
+	 * @brief Size of dimensions of this rect.
+	 *
+	 * The size of the dimensions of this rect. This is the number of elements
+	 * covered by each dimension of this rect starting from the origin. Must
+	 * only ever be greater than or equal to 0.
+	 */
+	koord size;
+
+public:
+	rect_t();
+
+	rect_t(koord const origin, koord const size);
+
+	rect_t(koord const origin, sint16 const x, sint16 const y);
+
+	~rect_t();
+
+	/**
+	 * @brief Fragment this rect so as to remove area from another rect.
+	 *
+	 * Fragments this rect such that the resulting rects cover all area
+	 * contained by this rect that is not contained in the remove rect. The
+	 * returned value is the number of valid rect elements in the result array
+	 * that make up the requested area. Result length specifies the space
+	 * available in the result array to store fragmented rects and must be at
+	 * least MAX_FRAGMENT_DIFFERENCE_COUNT long. The fragmentation is baised
+	 * towards wide rects.
+	 */
+	size_t fragment_difference(rect_t const &remove, rect_t *const result, size_t const result_length) const;
+
+	/**
+	 * @brief Mask part of this rect using a masking rect.
+	 *
+	 * Transforms this rect into the rect containing the intersection area
+	 * between this rect and the mask rect. Useful to clamp rects to map bounds.
+	 */
+	void mask(rect_t const &mask_rect);
+
+	/**
+	 * @brief Returns true if this rect represents no area.
+	 *
+	 * Returns true of the size of area is 0. Such rects can occur after masking
+	 * operations or as place holder rects representing no map area.
+	 */
+	bool has_no_area() const;
+
+	/**
+	 * @brief discard the current area of the rect.
+	 *
+	 * Set the size of this rect to 0. Useful to invalidate a rect. The origin
+	 * is not changed.
+	 */
+	void discard_area();
+
+	bool operator==(rect_t const &rhs) const;
+	bool operator!=(rect_t const &rhs) const;
+};
+
+#endif
\ No newline at end of file
Index: display/simview.cc
===================================================================
--- display/simview.cc	(revision 8546)
+++ display/simview.cc	(working copy)
@@ -167,6 +167,24 @@
 	int y_min = (-const_y_off + 4*tile_raster_scale_y( min(hmax_ground, welt->min_height)*TILE_HEIGHT_STEP, IMG_SIZE )
 					+ 4*(menu_height-IMG_SIZE)-IMG_SIZE/2-1) / IMG_SIZE;
 
+	// prepare view
+	rect_t const world_rect(koord(0, 0), welt->get_size());
+
+	koord const estimated_min(((y_min+(-2-((y_min+dpy_width) & 1))) >> 1) + i_off,
+		((y_min-(disp_width - const_x_off) / (IMG_SIZE/2) - 1) >> 1) + j_off);
+
+	sint16 const worst_case_mountain_extra = (welt->max_height - welt->min_height) / 2;
+	koord const estimated_max((((dpy_height+4*4)+(disp_width - const_x_off) / (IMG_SIZE/2) - 1) >> 1) + i_off + worst_case_mountain_extra,
+		(((dpy_height+4*4)-(-2-(((dpy_height+4*4)+dpy_width) & 1))) >> 1) + j_off + worst_case_mountain_extra);
+
+	rect_t view_rect(estimated_min, estimated_max - estimated_min + koord(1, 1));
+	view_rect.mask(world_rect);
+
+	if (view_rect != viewport->prepared_rect) {
+		welt->prepare_tiles(view_rect, viewport->prepared_rect);
+		viewport->prepared_rect = view_rect;
+	}
+
 #ifdef MULTI_THREAD
 	if(  can_multithreading  ) {
 		if(  !spawned_threads  ) {
@@ -307,7 +325,12 @@
 #endif
 }
 
+void main_view_t::clear_prepared() const
+{
+	viewport->prepared_rect.discard_area();
+}
 
+
 #ifdef MULTI_THREAD
 void main_view_t::display_region( koord lt, koord wh, sint16 y_min, sint16 y_max, bool /*force_dirty*/, bool threaded, const sint8 clip_num )
 #else
Index: display/simview.h
===================================================================
--- display/simview.h	(revision 8546)
+++ display/simview.h	(working copy)
@@ -37,6 +37,15 @@
 	void display(bool dirty);
 
 	/**
+	 * @brief Clears the prepared area of the view.
+	 *
+	 * Sets the prepared area of this view to no area. The entire view will have
+	 * to be reprepared on next display call. Intended when the entire world has
+	 * changed, eg switching underground mode or layer.
+	 */
+	void clear_prepared() const;
+
+	/**
 	 * Draws the simulated world in the specified rectangular area of the pixel buffer. This is a internal function of the class.
 	 * <br>
 	 * See lt and wt as the absolute limit a pixel this routine can draw, a clipping rectangle. y_min and y_max are the coordinates this routine starts,
Index: display/viewport.cc
===================================================================
--- display/viewport.cc	(revision 8546)
+++ display/viewport.cc	(working copy)
@@ -302,6 +302,7 @@
 
 
 viewport_t::viewport_t( karte_t *world, const koord ij_off , sint16 x_off , sint16 y_off )
+	: prepared_rect() 
 {
 	this->world = world;
 	assert(world);
Index: display/viewport.h
===================================================================
--- display/viewport.h	(revision 8546)
+++ display/viewport.h	(working copy)
@@ -11,6 +11,7 @@
 #include "scr_coord.h"
 #include "../dataobj/koord.h"
 #include "../dataobj/koord3d.h"
+#include "../dataobj/rect.h"
 #include "../convoihandle_t.h"
 
 class karte_t;
@@ -39,6 +40,16 @@
  */
 class viewport_t
 {
+public:
+	/**
+	 * @brief The prepared area of the view port.
+	 *
+	 * The area that has already been prepared for this view port. When the view
+	 * port is moved then only the new area not already prepared will be
+	 * prepared. If the view port is stationary no area will be prepared.
+	 */
+	rect_t prepared_rect;
+
 private:
 	/// The simulated world this view is associated to.
 	karte_t *world;
Index: gui/components/gui_world_view_t.cc
===================================================================
--- gui/components/gui_world_view_t.cc	(revision 8546)
+++ gui/components/gui_world_view_t.cc	(working copy)
@@ -20,21 +20,40 @@
 #include "../../dataobj/environment.h"
 #include "../../dataobj/koord3d.h"
 
+vector_tpl<world_view_t *> world_view_t::view_list;
 
+void world_view_t::invalidate_all()
+{
+	world_view_t *const *const endpointer = world_view_t::view_list.end();
+	for (world_view_t *const *pointer = world_view_t::view_list.begin() ; pointer != endpointer ; pointer++) {
+		(*pointer)->prepared_rect.discard_area();
+	}
+}
 
 world_view_t::world_view_t(scr_size size ) :
-		raster(get_base_tile_raster_width())
+	raster(get_base_tile_raster_width()),
+	prepared_rect(),
+	display_rect()
 {
 	set_size( size );
+	world_view_t::view_list.append(this);
 }
 
 
 world_view_t::world_view_t() :
-		raster(get_base_tile_raster_width())
+	raster(get_base_tile_raster_width()),
+	prepared_rect(),
+	display_rect()
 {
+	world_view_t::view_list.append(this);
 }
 
+world_view_t::~world_view_t()
+{
+	world_view_t::view_list.remove(this);
+}
 
+
 /**
  * Events werden hiermit an die GUI-components
  * gemeldet
@@ -70,6 +89,7 @@
 			fine_here -= scr_coord(x, y);
 		}
 	}
+	koord const height_offset(y_offset, y_offset);
 
 	grund_t const* const kb = welt->lookup_kartenboden(here);
 	if(!kb) {
@@ -98,6 +118,19 @@
 		return;
 	}
 
+	// prepare view
+	rect_t const world_rect(koord(0, 0), welt->get_size());
+
+	rect_t view_rect = display_rect;
+	view_rect.origin+= here + height_offset;
+	view_rect.mask(world_rect);
+
+	if (view_rect != prepared_rect) {
+		welt->prepare_tiles(view_rect, prepared_rect);
+		prepared_rect = view_rect;
+	}
+
+	// prepare clip area
 	const int clip_x = max(old_clip.x, pos.x);
 	const int clip_y = max(old_clip.y, pos.y);
 	display_set_clip_wh(clip_x, clip_y, min(old_clip.xx, pos.x + size.w) - clip_x, min(old_clip.yy, pos.y + size.h) - clip_y);
@@ -120,7 +153,7 @@
 
 	// display grounds
 	FOR(vector_tpl<koord>, const& off, offsets) {
-		const koord   k     = here + off + koord(y_offset, y_offset);
+		const koord   k     = here + off + height_offset;
 		const sint16  off_x = (off.x - off.y) * 32 * raster / 64 + display_off.x;
 
 		if(  off_x + raster < 0  ||  size.w < off_x  ||  k.x < 0  ||  k.y < 0  ) {
@@ -147,7 +180,7 @@
 
 	// display things
 	FOR(vector_tpl<koord>, const& off, offsets) {
-		const koord   k     = here + off + koord(y_offset, y_offset);
+		const koord   k     = here + off + height_offset;
 		const sint16  off_x = (off.x - off.y) * 32 * raster / 64 + display_off.x;
 		if(  off_x + raster < 0  ||  size.w < off_x  ||  k.x < 0  ||  k.y < 0  ) {
 			continue;
@@ -218,6 +251,7 @@
 	const sint16 max_dx = size.w/(raster/2) + 2;
 	const sint16 max_dy = (size.h/(raster/2) + dy_off)&0x0FFE;
 
+	// build offset list
 	offsets.clear();
 	for(  sint16 dy = -max_dy;  dy <= 5;  ) {
 		{
@@ -233,4 +267,25 @@
 		}
 		dy++;
 	}
+
+	// determine preparation extents
+	koord offset_extent_min(0, 0);
+	koord offset_extent_max(0, 0);
+	koord const *const iter_end = offsets.end();
+	for (koord const *iter = offsets.begin() ; iter != iter_end ; iter++) {
+		sint16 const x = iter->x;
+		sint16 const y = iter->y;
+		if (x < offset_extent_min.x) {
+			offset_extent_min.x = x;
+		}else if (x > offset_extent_max.x) {
+			offset_extent_max.x = x;
+		}
+		if (y < offset_extent_min.y) {
+			offset_extent_min.y = y;
+		}else if (y > offset_extent_max.y) {
+			offset_extent_max.y = y;
+		}
+	}
+
+	display_rect = rect_t(offset_extent_min, offset_extent_max - offset_extent_min + koord(1, 1));
 }
Index: gui/components/gui_world_view_t.h
===================================================================
--- gui/components/gui_world_view_t.h	(revision 8546)
+++ gui/components/gui_world_view_t.h	(working copy)
@@ -12,6 +12,7 @@
 
 #include "../../dataobj/koord3d.h"
 #include "../../tpl/vector_tpl.h"
+#include "../../dataobj/rect.h"
 
 class obj_t;
 
@@ -23,7 +24,34 @@
 class world_view_t : public gui_world_component_t
 {
 private:
+	/**
+	 * @brief Contains a reference to every world_view_t object.
+	 *
+	 * Used to allow mass invalidating of all prepared area for cases such as
+	 * changing underground mode and snow levels.
+	 */
+	static vector_tpl<world_view_t *> view_list;
+
+	/**
+	 * @brief The prepared area of the view port.
+	 *
+	 * The area that has already been prepared for this view port. When the view
+	 * port is moved then only the new area not already prepared will be
+	 * prepared. If the view port is stationary no area will be prepared.
+	 */
+	rect_t prepared_rect;
+
+	/**
+	 * @brief The display area centered around the map origin.
+	 *
+	 * The area used by this view to display the world. It is centered around
+	 * the origin but can easilly be shifted to where the actual view is
+	 * focused.
+	 */
+	rect_t display_rect;
+
 	vector_tpl<koord> offsets; /**< Offsets are stored. */
+
 	sint16            raster;  /**< For this rastersize. */
 
 protected:
@@ -34,10 +62,23 @@
 	void calc_offsets(scr_size size, sint16 dy_off);
 
 public:
+	/**
+	 * @brief Clears all prepared area.
+	 *
+	 * Set prepared rect to have no area. Used when all views must be reprepared
+	 * such as changing underground mode or slice. This method is required
+	 * because object views use completly separate draw logic from the main map
+	 * view and must also have their prepmap invalidated for correct graphic
+	 * reproduction.
+	 */
+	static void invalidate_all();
+
 	world_view_t(scr_size size);
 
 	world_view_t();
 
+	~world_view_t();
+
 	bool infowin_event(event_t const*) OVERRIDE;
 
 	/**
Index: Makefile
===================================================================
--- Makefile	(revision 8546)
+++ Makefile	(working copy)
@@ -264,6 +264,7 @@
 SOURCES += dataobj/marker.cc
 SOURCES += dataobj/powernet.cc
 SOURCES += dataobj/records.cc
+SOURCES += dataobj/rect.cc
 SOURCES += dataobj/ribi.cc
 SOURCES += dataobj/route.cc
 SOURCES += dataobj/scenario.cc
Index: simplan.cc
===================================================================
--- simplan.cc	(revision 8546)
+++ simplan.cc	(working copy)
@@ -620,7 +620,6 @@
 	}
 }
 
-
 /**
  * Finds halt belonging to a player
  * @param player owner of the halts we are interested in.
@@ -794,3 +793,15 @@
 	}
 	return false;
 }
+
+void planquadrat_t::update_underground() const
+{
+	get_kartenboden()->check_update_underground();
+	// update tunnel tiles
+	for(unsigned int i=1; i<get_boden_count(); i++) {
+		grund_t *const gr = get_boden_bei(i);
+		if (gr->ist_tunnel()) {
+			gr->check_update_underground();
+		}
+	}
+}
Index: simplan.h
===================================================================
--- simplan.h	(revision 8546)
+++ simplan.h	(working copy)
@@ -251,6 +251,17 @@
 	void display_overlay(sint16 xpos, sint16 ypos) const;
 
 	static void toggle_horizontal_clip(CLIP_NUM_DEF0);
+
+	/**
+	 * @brief Update this square for underground view.
+	 *
+	 * Updates this square for underground view. This includes calculating
+	 * calculating new back will images as well as water depth texture.
+	 *
+	 * This method does not modify this square object, but does modify the
+	 * grounds it references.
+	 */
+	void update_underground() const;
 };
 
 #endif
Index: simworld.cc
===================================================================
--- simworld.cc	(revision 8546)
+++ simworld.cc	(working copy)
@@ -43,6 +43,7 @@
 #include "simunits.h"
 #include "simversion.h"
 #include "display/simview.h"
+#include "display/prepmap.h"
 #include "simtool.h"
 #include "gui/simwin.h"
 #include "simworld.h"
@@ -5778,29 +5779,49 @@
 void karte_t::update_underground()
 {
 	DBG_MESSAGE( "karte_t::update_underground_map()", "" );
-	world_xy_loop(&karte_t::update_underground_intern, SYNCX_FLAG);
+	get_view()->clear_prepared();
+	world_view_t::invalidate_all();
 	set_dirty();
 }
 
+void karte_t::prepare_tiles(rect_t const &new_area, rect_t const &old_area) {
+	if (new_area == old_area) {
+		// area already prepared
+		return;
+	}
 
-void karte_t::update_underground_intern( sint16 x_min, sint16 x_max, sint16 y_min, sint16 y_max )
-{
-	for(  int y = y_min;  y < y_max;  y++  ) {
-		for(  int x = x_min; x < x_max;  x++  ) {
-			const int nr = y * cached_grid_size.x + x;
-			plan[nr].get_kartenboden()->check_update_underground();
-			// update tunnel tiles
-			for(uint8 i=1; i<plan[nr].get_boden_count(); i++) {
-				grund_t *gr = plan[nr].get_boden_bei(i);
-				if (gr->ist_tunnel()) {
-					gr->check_update_underground();
-				}
+	size_t const prepare_rects_capacity = rect_t::MAX_FRAGMENT_DIFFERENCE_COUNT;
+	rect_t prepare_rects[prepare_rects_capacity];
+	size_t const prepare_rects_length = new_area.fragment_difference(old_area, prepare_rects, prepare_rects_capacity);
+
+	// additional tiles to prepare for correct hiding behaviour
+	sint16 const prefix_tiles_x = min(grund_t::MAXIMUM_HIDE_TEST_DISTANCE, new_area.origin.x);
+	sint16 const prefix_tiles_y = min(grund_t::MAXIMUM_HIDE_TEST_DISTANCE, new_area.origin.y);
+
+	for (size_t rect_index = 0 ; rect_index < prepare_rects_length ; rect_index++) {
+		rect_t const &prepare_rect = prepare_rects[rect_index];
+
+		sint16 x_start = prepare_rect.origin.x;
+		sint16 const x_end = x_start + prepare_rect.size.x;
+		if (x_start == new_area.origin.x) {
+			x_start-= prefix_tiles_x;
+		}
+
+		sint16 y_start = prepare_rect.origin.y;
+		sint16 const y_end = y_start + prepare_rect.size.y;
+		if (y_start == new_area.origin.y) {
+			y_start-= prefix_tiles_y;
+		}
+
+		for (sint16 y = y_start ; y < y_end ; y++) {
+			for (sint16 x = x_start ; x < x_end ; x++) {
+				const planquadrat_t &tile = plan[y * cached_grid_size.x + x];
+				tile.update_underground();
 			}
 		}
 	}
 }
 
-
 void karte_t::calc_climate(koord k, bool recalc)
 {
 	planquadrat_t *pl = access(k);
Index: simworld.h
===================================================================
--- simworld.h	(revision 8546)
+++ simworld.h	(working copy)
@@ -27,6 +27,7 @@
 #include "dataobj/settings.h"
 #include "network/pwd_hash.h"
 #include "dataobj/loadsave.h"
+#include "dataobj/rect.h"
 
 #include "simplan.h"
 
@@ -694,11 +695,6 @@
 	 */
 	void update_map_intern(sint16, sint16, sint16, sint16);
 
-	/**
-	 * Updates images after change of underground mode.
-	 */
-	void update_underground_intern(sint16, sint16, sint16, sint16);
-
 public:
 	/**
 	 * Announce server and current state to listserver.
@@ -816,6 +812,14 @@
 	void update_underground();
 
 	/**
+	 * @brief Prepares an area of the map to be drawn.
+	 *
+	 * New area is the area that will be prepared. Old area is the area that was
+	 * already prepared. Only the difference between the two rects is prepared.
+	 */
+	void prepare_tiles(rect_t const& new_area, rect_t const& old_area);
+
+	/**
 	 * @returns true if world gets destroyed
 	 */
 	bool is_destroying() const { return destroying; }