Merge lp:~widelands-dev/widelands/zoom into lp:widelands

[SirVer]

- Adds mouse wheel zoom to the MapView and adapt code for these changes.
  - Overlays (text & soldier icons) are drawn at integer scale only and not at all once scale is < 0.5.
  - This required to change all blitting to be sub-pixel - i.e. float - for the 'destination'.
- Adapted and simplified minimap rendering. It gained a feature too: Minimaps can be drawn using two modes :
    - the map scrolls and the view window stands still (the old one, stil used for in-game)
    - the view window scrolls and the map always looks like the minimap preview. This is now used in the editor.
- Renames Vector -> Vector3f, Point -> Vector2i, Pointf -> Vector2f, Rect -> Recti, FloatRect -> Rectf.
- Refactored object drawing to be simpler and slightly faster:
    - Never pass the field to be drawn to the draw routine.
    - Do not calculate if statics or census should be shown inside the draw routines of the objects, but outside.
    - Move 'owner' field to MapObject - it was duplicated on Bob, Immovable and PlayerImmovable.

Known issues that I will not fix in this branch:
Lua is not aware of zoom and uses zoomless calculations for its moving functions of the view. That means that if the player has zoomed in a scenario and the code wants to move to a certain field, the movement will be wrong. My plan is to remove the Lua functions and add a Animator class to the MapView that will do smooth animations over time in the next branch.

Jaaai - a journey of some 3 years starting with OpenGL finally enabling zoom!

Apologies for the huge diff. If it is unreviewable, I can pull out some of the
changes, like the renames and changing to floating point in rendering and
changing the minimap to two modes - but it would be a hassle and I'd prefer to
get it in as is after b19.

[GunChleoc (gunchleoc)]

This branch creates a problem with the new font renderer - see

https://bugs.launchpad.net/widelands/+bug/536461/comments/14

[SirVer (sirver)]

should be fixed now. ptal.

[GunChleoc (gunchleoc)]

I have given it a quick spin, zooming works fine. I still think it would be good to have some keyboard navigation for it, something like:

bool MapView::handle_key(bool down, SDL_Keysym code) {
 if (down)
  switch (code.sym) {
  case SDLK_PLUS:
   if (code.mod & KMOD_CTRL) {
    <decrease zoom>;
    return true;
   }
   break;
  case SDLK_MINUS:
   if (code.mod & KMOD_CTRL) {
    <increase zoom>;
    return true;
   }
   break;
  case SDLK_0:
   if (code.mod & KMOD_CTRL) {
    <reset zoom>;
    return true;
   }
   break;
  default:
   break;
  }
 return false;
}

[SirVer (sirver)]

I agree, let's do that in the next branch though. this one is so big.

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

Running 'bzr pull --overwrite' failed. Output:

Warning: Permanently added 'bazaar.launchpad.net,91.189.95.84' (RSA) to the list of known hosts.
Permission denied (publickey).
ConnectionReset reading response for 'BzrDir.open_2.1', retrying
Permission denied (publickey).
bzr: ERROR: Connection closed: Unexpected end of message. Please check connectivity and permissions, and report a bug if problems persist.
Using saved parent location: bzr+ssh://bazaar.launchpad.net/~widelands-dev/widelands/zoom/

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

Running 'bzr pull --overwrite' failed. Output:

Permission denied (publickey).
ConnectionReset reading response for 'BzrDir.open_2.1', retrying
Permission denied (publickey).
bzr: ERROR: Connection closed: Unexpected end of message. Please check connectivity and permissions, and report a bug if problems persist.
Using saved parent location: bzr+ssh://bazaar.launchpad.net/~widelands-dev/widelands/zoom/

[GunChleoc (gunchleoc)]

Code review done in last commit. Just some few minor nits + refactoring ideas for the future. And I found some more float coordinates for text that I fixed.

I still have a list of things that I want to test, but looking very good overall :)

[GunChleoc (gunchleoc)]

Testing done - this can go in whenever you're happy.

review: Approve

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

Running 'git fetch bzr_origin' failed. Output:

Traceback (most recent call last):
  File "/usr/local/bin/git-remote-bzr", line 1022, in <module>
    sys.exit(main(sys.argv))
  File "/usr/local/bin/git-remote-bzr", line 994, in main
    repo = get_repo(url, alias)
  File "/usr/local/bin/git-remote-bzr", line 870, in get_repo
    origin = bzrlib.bzrdir.BzrDir.open(url, possible_transports=transports)
  File "/usr/lib/python2.7/dist-packages/bzrlib/controldir.py", line 689, in open
    _unsupported=_unsupported)
  File "/usr/lib/python2.7/dist-packages/bzrlib/controldir.py", line 718, in open_from_transport
    find_format, transport, redirected)
  File "/usr/lib/python2.7/dist-packages/bzrlib/transport/__init__.py", line 1719, in do_catching_redirections
    return action(transport)
  File "/usr/lib/python2.7/dist-packages/bzrlib/controldir.py", line 706, in find_format
    probers=probers)
  File "/usr/lib/python2.7/dist-packages/bzrlib/controldir.py", line 1155, in find_format
    raise errors.NotBranchError(path=transport.base)
bzrlib.errors.NotBranchError: Not a branch: "/home/bunnybot/bunnybot/data/bzr_repo/".

[SirVer (sirver)]

Excellent code review - thanks for that! I applied everything except for one thing:

> move set_owner to superclass as well, where get_owner() is now.

I considered this - but set_owner has different implementations in different classes and makes no sense for some MapObjects (that can never be owned). So I left it in the classes where it was defined.

Bunnybot should be all ready for action again too - and it should now deal fine with many branches.

[SirVer (sirver)]

@bunnybot merge

Lets see if that works again.

[GunChleoc (gunchleoc)]

Thanks for a great feature :)

=== modified file 'src/base/CMakeLists.txt'
--- src/base/CMakeLists.txt	2016-08-15 10:43:23 +0000
+++ src/base/CMakeLists.txt	2016-10-24 20:07:47 +0000
@@ -37,9 +37,9 @@
 
 wl_library(base_geometry
   SRCS
-    point.h
-    point.cc
     rect.h
+    vector.h
+    vector.cc
 )
 
 wl_library(base_md5
@@ -50,7 +50,6 @@
     base_macros
 )
 
-
 wl_library(base_scoped_timer
   SRCS
     scoped_timer.h
@@ -68,3 +67,11 @@
   DEPENDS
     base_i18n
 )
+
+wl_library(base_math
+  SRCS
+    math.h
+    math.cc
+  DEPENDS
+    base_macros
+)

=== added file 'src/base/math.cc'
--- src/base/math.cc	1970-01-01 00:00:00 +0000
+++ src/base/math.cc	2016-10-24 20:07:47 +0000
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2006-2016 by the Widelands Development Team
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+// Dummy file as cmake cannot handle header only libraries :(.

=== added file 'src/base/math.h'
--- src/base/math.h	1970-01-01 00:00:00 +0000
+++ src/base/math.h	2016-10-24 20:07:47 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2006-2016 by the Widelands Development Team
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef WL_BASE_MATH_H
+#define WL_BASE_MATH_H
+
+#include "base/macros.h"
+
+namespace math {
+
+// Returns 1 for positive and -1 for negative numbers.
+template <typename T>
+T sign(const T& val) {
+	return val < T(0.) ? T(-1.) : T(1.);
+}
+
+// Clamps 'val' to 'min' and 'max'.
+template <typename T>
+T clamp(const T& val, const T& low, const T& high) {
+	if (val < low) { return low; }
+	if (val > high) { return high; }
+	return val;
+}
+
+}  // namespace math
+
+#endif  // end of include guard: WL_BASE_MATH_H

=== removed file 'src/base/point.h'
--- src/base/point.h	2016-08-04 15:49:05 +0000
+++ src/base/point.h	1970-01-01 00:00:00 +0000
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2002-2004, 2006-2013 by the Widelands Development Team
- *
- * 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.
- *
- */
-
-#ifndef WL_BASE_POINT_H
-#define WL_BASE_POINT_H
-
-#include <limits>
-
-#include <stdint.h>
-
-template <typename T> struct GenericPoint {
-	GenericPoint(const T& px, const T& py) : x(px), y(py) {
-	}
-	GenericPoint() : GenericPoint(T(0), T(0)) {
-	}
-
-	// Returns an invalid point.
-	static GenericPoint invalid() {
-		return GenericPoint(std::numeric_limits<T>::max(), std::numeric_limits<T>::max());
-	}
-
-	bool operator==(const GenericPoint& other) const {
-		return x == other.x && y == other.y;
-	}
-	bool operator!=(const GenericPoint& other) const {
-		return !(*this == other);
-	}
-
-	GenericPoint operator+(const GenericPoint& other) const {
-		return GenericPoint(x + other.x, y + other.y);
-	}
-
-	GenericPoint operator-() const {
-		return GenericPoint(-x, -y);
-	}
-
-	GenericPoint operator-(const GenericPoint& other) const {
-		return GenericPoint(x - other.x, y - other.y);
-	}
-
-	GenericPoint& operator+=(const GenericPoint& other) {
-		x += other.x;
-		y += other.y;
-		return *this;
-	}
-
-	GenericPoint& operator-=(const GenericPoint& other) {
-		x -= other.x;
-		y -= other.y;
-		return *this;
-	}
-
-	T x, y;
-};
-
-using Point = GenericPoint<int>;
-using FloatPoint = GenericPoint<float>;
-
-/// Returns the point in the middle between a and b (rounded to integer
-/// values).
-Point middle(const Point& a, const Point& b);
-
-#endif  // end of include guard: WL_BASE_POINT_H

=== modified file 'src/base/rect.h'
--- src/base/rect.h	2016-08-04 15:49:05 +0000
+++ src/base/rect.h	2016-10-24 20:07:47 +0000
@@ -20,41 +20,51 @@
 #ifndef WL_BASE_RECT_H
 #define WL_BASE_RECT_H
 
-#include "base/point.h"
+#include "base/vector.h"
 
-template <typename T> struct GenericRect {
-	/// Generates a degenerate Rect at (0, 0) with no height or width.
-	GenericRect() : GenericRect(T(0), T(0), T(0), T(0)) {
+template <typename T> struct Rect {
+	/// Generates a degenerate Recti at (0, 0) with no height or width.
+	Rect() : Rect(T(0), T(0), T(0), T(0)) {
 	}
 
-	GenericRect(const T& gx, const T& gy, const T& W, const T& H) : x(gx), y(gy), w(W), h(H) {
+	Rect(const T& gx, const T& gy, const T& W, const T& H) : x(gx), y(gy), w(W), h(H) {
 	}
 
 	template <typename PointType>
-	GenericRect(const GenericPoint<PointType>& p, const T& width, const T& height)
-	   : GenericRect(T(p.x), T(p.y), width, height) {
+	Rect(const Vector2<PointType>& p, const T& width, const T& height)
+	   : Rect(T(p.x), T(p.y), width, height) {
 	}
 
-	/// The Point (x, y).
-	GenericPoint<T> origin() const {
-		return GenericPoint<T>(x, y);
+	/// The Vector2i (x, y).
+	Vector2<T> origin() const {
+		return Vector2<T>(x, y);
 	}
 
 	/// The point (x + w, y + h).
-	GenericPoint<T> opposite_of_origin() const {
-		return GenericPoint<T>(x + w, y + h);
+	Vector2<T> opposite_of_origin() const {
+		return Vector2<T>(x + w, y + h);
 	}
 
 	/// Returns true if this rectangle contains the given point.
 	/// The bottom and right borders of the rectangle are considered to be excluded.
-	template <typename PointType> bool contains(const GenericPoint<PointType>& pt) const {
+	template <typename PointType> bool contains(const Vector2<PointType>& pt) const {
 		return T(pt.x) >= x && T(pt.x) < x + w && T(pt.y) >= y && T(pt.y) < y + h;
 	}
 
+	// The center point of 'r'.
+	Vector2f center() const {
+		return Vector2f(x + w / 2.f, y + h / 2.f);
+	}
+
+	template<typename Type>
+	Rect<Type> cast() const {
+		return Rect<Type>(Type(x), Type(y), Type(w), Type(h));
+	}
+
 	T x, y, w, h;
 };
 
-using Rect = GenericRect<int>;
-using FloatRect = GenericRect<float>;
+using Recti = Rect<int>;
+using Rectf = Rect<float>;
 
 #endif  // end of include guard: WL_BASE_RECT_H

=== renamed file 'src/base/point.cc' => 'src/base/vector.cc'
--- src/base/point.cc	2015-03-01 09:21:20 +0000
+++ src/base/vector.cc	2016-10-24 20:07:47 +0000
@@ -17,8 +17,14 @@
  *
  */
 
-#include "base/point.h"
-
-Point middle(const Point& a, const Point& b) {
-	return Point((a.x + b.x) / 2, (a.y + b.y) / 2);
+#include "base/vector.h"
+
+#include <cmath>
+
+Vector2f middle(const Vector2f& a, const Vector2f& b) {
+	return Vector2f((a.x + b.x) / 2.f, (a.y + b.y) / 2.f);
+}
+
+Vector2i round(const Vector2f& a) {
+	return Vector2i(std::lround(a.x), std::lround(a.y));
 }

=== renamed file 'src/wui/vector.h' => 'src/base/vector.h'
--- src/wui/vector.h	2016-08-04 15:49:05 +0000
+++ src/base/vector.h	2016-10-24 20:07:47 +0000
@@ -17,23 +17,88 @@
  *
  */
 
-#ifndef WL_WUI_VECTOR_H
-#define WL_WUI_VECTOR_H
+#ifndef WL_BASE_VECTOR_H
+#define WL_BASE_VECTOR_H
 
 #include <cmath>
-
-// hm, floats...
-// tried to be faster with fixed point arithmetics
-// it was, but i'll try to find other opts first
-struct Vector {
-	Vector() : x(0), y(0), z(0) {
-	}
-	Vector(const float X, const float Y, const float Z) : x(X), y(Y), z(Z) {
+#include <limits>
+
+#include <stdint.h>
+
+template <typename T> struct Vector2 {
+	Vector2(const T& px, const T& py) : x(px), y(py) {
+	}
+	Vector2() : Vector2(T(0), T(0)) {
+	}
+
+	// Returns an invalid point.
+	static Vector2 invalid() {
+		return Vector2(std::numeric_limits<T>::max(), std::numeric_limits<T>::max());
+	}
+
+	bool operator==(const Vector2& other) const {
+		return x == other.x && y == other.y;
+	}
+	bool operator!=(const Vector2& other) const {
+		return !(*this == other);
+	}
+
+	Vector2 operator+(const Vector2& other) const {
+		return Vector2(x + other.x, y + other.y);
+	}
+
+	Vector2 operator*(const float a) const {
+		return Vector2(a * x, a * y);
+	}
+
+	Vector2 operator/(const float a) const {
+		return Vector2(x / a, y / a);
+	}
+
+	Vector2 operator-() const {
+		return Vector2(-x, -y);
+	}
+
+	Vector2 operator-(const Vector2& other) const {
+		return Vector2(x - other.x, y - other.y);
+	}
+
+	Vector2& operator+=(const Vector2& other) {
+		x += other.x;
+		y += other.y;
+		return *this;
+	}
+
+	Vector2& operator-=(const Vector2& other) {
+		x -= other.x;
+		y -= other.y;
+		return *this;
+	}
+
+	template<typename Type>
+	Vector2<Type> cast() const {
+		return Vector2<Type>(Type(x), Type(y));
+	}
+
+	T x, y;
+};
+
+using Vector2i = Vector2<int>;
+using Vector2f = Vector2<float>;
+
+/// Returns the point in the middle between a and b.
+Vector2f middle(const Vector2f& a, const Vector2f& b);
+
+// Returns an point rounded to the closest integer.
+Vector2i round(const Vector2f& a);
+
+struct Vector3f {
+	Vector3f(const float X, const float Y, const float Z) : x(X), y(Y), z(Z) {
 	}
 
 	void normalize() {
-		const float f = static_cast<float>(sqrt(x * x + y * y + z * z));
-		if (fabs(f) < 0.00001)  // check for ==0
+		const float f = static_cast<float>(std::sqrt(x * x + y * y + z * z));
+		if (std::fabs(f) < 0.00001f)  // check for ==0
 			return;
 		x /= f;
 		y /= f;
@@ -41,16 +106,16 @@
 	}
 
 	// vector addition
-	Vector operator+(const Vector& other) const {
-		return Vector(x + other.x, y + other.y, z + other.z);
+	Vector3f operator+(const Vector3f& other) const {
+		return Vector3f(x + other.x, y + other.y, z + other.z);
 	}
 
 	// inner product
-	float operator*(const Vector& other) const {
+	float dot(const Vector3f& other) const {
 		return x * other.x + y * other.y + z * other.z;
 	}
 
 	float x, y, z;
 };
 
-#endif  // end of include guard: WL_WUI_VECTOR_H
+#endif  // end of include guard: WL_BASE_VECTOR_H

=== modified file 'src/economy/flag.h'
--- src/economy/flag.h	2016-08-04 15:49:05 +0000
+++ src/economy/flag.h	2016-10-24 20:07:47 +0000
@@ -25,6 +25,7 @@
 
 #include "base/macros.h"
 #include "economy/routing_node.h"
+#include "logic/map_objects/draw_text.h"
 #include "logic/map_objects/immovable.h"
 
 namespace Widelands {
@@ -144,7 +145,11 @@
 	void init(EditorGameBase&) override;
 	void cleanup(EditorGameBase&) override;
 
-	void draw(const EditorGameBase&, RenderTarget&, const FCoords&, const Point&) override;
+	void draw(uint32_t gametime,
+	          DrawText draw_text,
+	          const Vector2f& point_on_dst,
+				 float scale,
+	          RenderTarget* dst) override;
 
 	void wake_up_capacity_queue(Game&);
 

=== modified file 'src/economy/portdock.cc'
--- src/economy/portdock.cc	2016-09-30 07:34:06 +0000
+++ src/economy/portdock.cc	2016-10-24 20:07:47 +0000
@@ -141,7 +141,7 @@
 		expedition_bootstrap_->set_economy(e);
 }
 
-void PortDock::draw(const EditorGameBase&, RenderTarget&, const FCoords&, const Point&) {
+void PortDock::draw(uint32_t, const DrawText, const Vector2f&, float, RenderTarget*) {
 	// do nothing
 }
 

=== modified file 'src/economy/portdock.h'
--- src/economy/portdock.h	2016-08-04 15:49:05 +0000
+++ src/economy/portdock.h	2016-10-24 20:07:47 +0000
@@ -96,7 +96,11 @@
 
 	Flag& base_flag() override;
 	PositionList get_positions(const EditorGameBase&) const override;
-	void draw(const EditorGameBase&, RenderTarget&, const FCoords&, const Point&) override;
+	void draw(uint32_t gametime,
+	          DrawText draw_text,
+	          const Vector2f& point_on_dst,
+				 float scale,
+	          RenderTarget* dst) override;
 
 	void init(EditorGameBase&) override;
 	void cleanup(EditorGameBase&) override;

=== modified file 'src/economy/road.h'
--- src/economy/road.h	2016-08-04 15:49:05 +0000
+++ src/economy/road.h	2016-10-24 20:07:47 +0000
@@ -118,7 +118,11 @@
 	void init(EditorGameBase&) override;
 	void cleanup(EditorGameBase&) override;
 
-	void draw(const EditorGameBase&, RenderTarget&, const FCoords&, const Point&) override;
+	void draw(uint32_t gametime,
+	          DrawText draw_text,
+	          const Vector2f& point_on_dst,
+				 float scale,
+	          RenderTarget* dst) override;
 
 private:
 	void set_path(EditorGameBase&, const Path&);

=== modified file 'src/editor/editorinteractive.cc'
--- src/editor/editorinteractive.cc	2016-09-25 18:46:29 +0000
+++ src/editor/editorinteractive.cc	2016-10-24 20:07:47 +0000
@@ -160,6 +160,8 @@
 	      [this](const Widelands::NoteFieldResourceChanged& note) {
 		      update_resource_overlay(note, egbase().world(), mutable_field_overlay_manager());
 		   });
+
+	minimap_registry().minimap_type = MiniMapType::kStaticMap;
 }
 
 void EditorInteractive::register_overlays() {
@@ -173,7 +175,7 @@
 			const Image* player_image = g_gr->images().get(player_pictures[p - 1]);
 			assert(player_image);
 			mutable_field_overlay_manager()->register_overlay(
-			   sp, player_image, 8, Point(player_image->width() / 2, STARTING_POS_HOTSPOT_Y));
+			   sp, player_image, 8, Vector2i(player_image->width() / 2, STARTING_POS_HOTSPOT_Y));
 		}
 	}
 
@@ -669,7 +671,7 @@
 		}
 
 		// Make sure that we will start at coordinates (0,0).
-		set_viewpoint(Point(0, 0), true);
+		set_viewpoint(Vector2f(0, 0), true);
 		set_sel_pos(Widelands::NodeAndTriangle<>(
 		   Widelands::Coords(0, 0),
 		   Widelands::TCoords<>(Widelands::Coords(0, 0), Widelands::TCoords<>::D)));

=== modified file 'src/editor/tools/set_origin_tool.cc'
--- src/editor/tools/set_origin_tool.cc	2016-08-04 15:49:05 +0000
+++ src/editor/tools/set_origin_tool.cc	2016-10-24 20:07:47 +0000
@@ -30,9 +30,7 @@
                                                Widelands::Map* map) {
 	map->set_origin(center.node);
 	eia.map_changed(EditorInteractive::MapWas::kGloballyMutated);
-	eia.set_rel_viewpoint(Point(-(center.node.x * 2 + (center.node.y & 1)) * (kTriangleWidth / 2),
-	                            -center.node.y * kTriangleHeight),
-	                      true);
+	eia.center_view_on_coords(Widelands::Coords(0, 0));
 	return 0;
 }
 
@@ -46,8 +44,7 @@
 	   map->get_width() - 1 - center.node.x, map->get_height() - 1 - center.node.y);
 	map->set_origin(nc);
 	eia.map_changed(EditorInteractive::MapWas::kGloballyMutated);
-	eia.set_rel_viewpoint(
-	   Point(-(nc.x * 2 + (nc.y & 1)) * (kTriangleWidth / 2), -nc.y * kTriangleHeight), true);
+	eia.center_view_on_coords(Widelands::Coords(0, 0));
 	return 0;
 }
 

=== modified file 'src/editor/tools/set_starting_pos_tool.cc'
--- src/editor/tools/set_starting_pos_tool.cc	2016-08-04 15:49:05 +0000
+++ src/editor/tools/set_starting_pos_tool.cc	2016-10-24 20:07:47 +0000
@@ -113,7 +113,7 @@
 
 			//  add new overlay
 			overlay_manager->register_overlay(
-			   center.node, player_image, 4, Point(player_image->width() / 2, STARTING_POS_HOTSPOT_Y));
+			   center.node, player_image, 4, Vector2i(player_image->width() / 2, STARTING_POS_HOTSPOT_Y));
 
 			//  set new player pos
 			map->set_starting_pos(current_player_, center.node);

=== modified file 'src/editor/ui_menus/main_menu_load_or_save_map.cc'
--- src/editor/ui_menus/main_menu_load_or_save_map.cc	2016-08-04 18:09:55 +0000
+++ src/editor/ui_menus/main_menu_load_or_save_map.cc	2016-10-24 20:07:47 +0000
@@ -89,7 +89,7 @@
 	vbox->add(show_mapnames_, UI::Align::kLeft, true);
 
 	/** TRANSLATORS: Checkbox title. If this checkbox is enabled, map names aren't translated. */
-	cb_dont_localize_mapnames_ = new UI::Checkbox(vbox, Point(0, 0), _("Show original map names"));
+	cb_dont_localize_mapnames_ = new UI::Checkbox(vbox, Vector2i(0, 0), _("Show original map names"));
 	cb_dont_localize_mapnames_->set_state(false);
 	vbox->add_space(2 * padding_);
 	vbox->add(cb_dont_localize_mapnames_, UI::Align::kLeft, true);

=== modified file 'src/editor/ui_menus/main_menu_map_options.cc'
--- src/editor/ui_menus/main_menu_map_options.cc	2016-08-07 10:10:18 +0000
+++ src/editor/ui_menus/main_menu_map_options.cc	2016-10-24 20:07:47 +0000
@@ -227,7 +227,7 @@
                                           std::string tag,
                                           std::string displ_name) {
 	UI::Box* box = new UI::Box(parent, 0, 0, UI::Box::Horizontal, max_w_, checkbox_space_, 0);
-	UI::Checkbox* cb = new UI::Checkbox(box, Point(0, 0), displ_name);
+	UI::Checkbox* cb = new UI::Checkbox(box, Vector2i(0, 0), displ_name);
 	box->add(cb, UI::Align::kLeft, true);
 	box->add_space(checkbox_space_);
 	parent->add(box, UI::Align::kLeft);

=== modified file 'src/editor/ui_menus/main_menu_random_map.cc'
--- src/editor/ui_menus/main_menu_random_map.cc	2016-08-04 15:49:05 +0000
+++ src/editor/ui_menus/main_menu_random_map.cc	2016-10-24 20:07:47 +0000
@@ -184,7 +184,7 @@
                 resources_label_.get_h(),
                 (boost::format(_("%i %%")) % mountainsval_).str(),
                 UI::Align::kHCenter),
-     island_mode_(&box_, Point(0, 0), _("Island mode")),
+     island_mode_(&box_, Vector2i(0, 0), _("Island mode")),
      // Geeky stuff
      map_number_box_(&box_, 0, 0, UI::Box::Horizontal, 0, 0, margin_),
      map_number_label_(&map_number_box_, 0, 0, _("Random Number:")),

=== modified file 'src/editor/ui_menus/main_menu_save_map.h'
--- src/editor/ui_menus/main_menu_save_map.h	2016-08-04 15:49:05 +0000
+++ src/editor/ui_menus/main_menu_save_map.h	2016-10-24 20:07:47 +0000
@@ -40,7 +40,7 @@
 
 private:
 	EditorInteractive& eia();
-	void clicked_ok();
+	void clicked_ok() override;
 	void clicked_make_directory();
 	void clicked_edit_options();
 	void clicked_item();

=== modified file 'src/editor/ui_menus/player_menu.cc'
--- src/editor/ui_menus/player_menu.cc	2016-09-25 11:24:10 +0000
+++ src/editor/ui_menus/player_menu.cc	2016-10-24 20:07:47 +0000
@@ -95,11 +95,11 @@
 	set_inner_size(375, 135);
 
 	UI::Textarea* ta = new UI::Textarea(this, 0, 0, _("Number of Players"));
-	ta->set_pos(Point((get_inner_w() - ta->get_w()) / 2, posy + 5));
+	ta->set_pos(Vector2i((get_inner_w() - ta->get_w()) / 2, posy + 5));
 	posy += spacing + width;
 
 	nr_of_players_ta_ = new UI::Textarea(this, 0, 0, "5");
-	nr_of_players_ta_->set_pos(Point((get_inner_w() - nr_of_players_ta_->get_w()) / 2, posy + 5));
+	nr_of_players_ta_->set_pos(Vector2i((get_inner_w() - nr_of_players_ta_->get_w()) / 2, posy + 5));
 
 	posy += width + spacing + spacing;
 
@@ -292,7 +292,7 @@
 	//  jump to the current node
 	Widelands::Map& map = menu.egbase().map();
 	if (Widelands::Coords const sp = map.get_starting_pos(n))
-		menu.move_view_to(sp);
+		menu.center_view_on_coords(sp);
 
 	//  select tool set mplayer
 	menu.select_tool(menu.tools()->set_starting_pos, EditorTool::First);

=== modified file 'src/editor/ui_menus/tool_change_resources_options_menu.cc'
--- src/editor/ui_menus/tool_change_resources_options_menu.cc	2016-08-04 15:49:05 +0000
+++ src/editor/ui_menus/tool_change_resources_options_menu.cc	2016-10-24 20:07:47 +0000
@@ -100,7 +100,7 @@
 
 	for (Widelands::DescriptionIndex i = 0; i < nr_resources; ++i) {
 		const Widelands::ResourceDescription& resource = *world.get_resource(i);
-		radiogroup_.add_button(&resources_box_, Point(0, 0),
+		radiogroup_.add_button(&resources_box_, Vector2i(0, 0),
 		                       g_gr->images().get(resource.representative_image()),
 		                       resource.descname());
 		resources_box_.add(radiogroup_.get_first_button(), UI::Align::kLeft, false, true);

=== modified file 'src/editor/ui_menus/tool_menu.cc'
--- src/editor/ui_menus/tool_menu.cc	2016-08-04 15:49:05 +0000
+++ src/editor/ui_menus/tool_menu.cc	2016-10-24 20:07:47 +0000
@@ -45,8 +45,8 @@
    : UI::UniqueWindow(&parent, "tool_menu", &registry, 350, 400, _("Tools")) {
 
 #define spacing 5
-	Point const offs(spacing, spacing);
-	Point pos = offs;
+	Vector2i const offs(spacing, spacing);
+	Vector2i pos = offs;
 	int32_t const width = 34;
 	int32_t const height = 34;
 

=== modified file 'src/editor/ui_menus/tool_place_bob_options_menu.cc'
--- src/editor/ui_menus/tool_place_bob_options_menu.cc	2016-08-04 15:49:05 +0000
+++ src/editor/ui_menus/tool_place_bob_options_menu.cc	2016-10-24 20:07:47 +0000
@@ -64,14 +64,14 @@
 	}
 
 	const Image* tab_icon = g_gr->images().get("images/ui_basic/list_first_entry.png");
-	Point pos;
+	Vector2i pos;
 	uint32_t cur_x = bobs_in_row;
 	int32_t i = 0;
 	UI::Box* box = nullptr;
 	while (i < nr_bobs) {
 		if (cur_x == bobs_in_row) {
 			cur_x = 0;
-			pos = Point(5, 15);
+			pos = Vector2i(5, 15);
 			box = new UI::Box(&tabpanel_, 0, 0, UI::Box::Horizontal);
 			tabpanel_.add("icons", tab_icon, box);
 		}

=== modified file 'src/editor/ui_menus/tool_place_immovable_options_menu.cc'
--- src/editor/ui_menus/tool_place_immovable_options_menu.cc	2016-08-04 15:49:05 +0000
+++ src/editor/ui_menus/tool_place_immovable_options_menu.cc	2016-10-24 20:07:47 +0000
@@ -39,7 +39,7 @@
 
 UI::Checkbox* create_immovable_checkbox(UI::Panel* parent, const ImmovableDescr& immovable_descr) {
 	const Image* pic = immovable_descr.representative_image();
-	UI::Checkbox* cb = new UI::Checkbox(parent, Point(0, 0), pic, immovable_descr.descname());
+	UI::Checkbox* cb = new UI::Checkbox(parent, Vector2i(0, 0), pic, immovable_descr.descname());
 	const int kMinClickableArea = 24;
 	cb->set_desired_size(std::max<int>(pic->width(), kMinClickableArea),
 	                     std::max<int>(pic->height(), kMinClickableArea));

=== modified file 'src/editor/ui_menus/tool_set_terrain_options_menu.cc'
--- src/editor/ui_menus/tool_set_terrain_options_menu.cc	2016-08-04 15:49:05 +0000
+++ src/editor/ui_menus/tool_set_terrain_options_menu.cc	2016-10-24 20:07:47 +0000
@@ -53,10 +53,10 @@
 	// Blit the main terrain image
 	const Image& terrain_texture = terrain_descr.get_texture(0);
 	Texture* texture = new Texture(terrain_texture.width(), terrain_texture.height());
-	texture->blit(Rect(0, 0, terrain_texture.width(), terrain_texture.height()), terrain_texture,
-	              Rect(0, 0, terrain_texture.width(), terrain_texture.height()), 1.,
+	texture->blit(Rectf(0, 0, terrain_texture.width(), terrain_texture.height()), terrain_texture,
+	              Rectf(0, 0, terrain_texture.width(), terrain_texture.height()), 1.,
 	              BlendMode::UseAlpha);
-	Point pt(1, terrain_texture.height() - kSmallPicSize - 1);
+	Vector2i pt(1, terrain_texture.height() - kSmallPicSize - 1);
 
 	// Collect tooltips and blit small icons representing "is" values
 	for (const TerrainDescription::Type& terrain_type : terrain_descr.get_types()) {
@@ -64,9 +64,9 @@
 		                terrain_descr.custom_tooltips().end());
 		tooltips.push_back(terrain_type.descname);
 
-		texture->blit(Rect(pt.x, pt.y, terrain_type.icon->width(), terrain_type.icon->height()),
+		texture->blit(Rectf(pt.x, pt.y, terrain_type.icon->width(), terrain_type.icon->height()),
 		              *terrain_type.icon,
-		              Rect(0, 0, terrain_type.icon->width(), terrain_type.icon->height()), 1.,
+		              Rectf(0, 0, terrain_type.icon->width(), terrain_type.icon->height()), 1.,
 		              BlendMode::UseAlpha);
 		pt.x += kSmallPicSize + 1;
 	}
@@ -79,7 +79,7 @@
 	                               .str();
 
 	std::unique_ptr<const Image>& image = offscreen_images->back();
-	UI::Checkbox* cb = new UI::Checkbox(parent, Point(0, 0), image.get(), tooltip);
+	UI::Checkbox* cb = new UI::Checkbox(parent, Vector2i(0, 0), image.get(), tooltip);
 	cb->set_desired_size(image->width() + 1, image->height() + 1);
 	return cb;
 }

=== modified file 'src/game_io/CMakeLists.txt'
--- src/game_io/CMakeLists.txt	2016-01-20 20:12:00 +0000
+++ src/game_io/CMakeLists.txt	2016-10-24 20:07:47 +0000
@@ -30,6 +30,7 @@
     build_info
     economy
     graphic
+    graphic_image_io
     graphic_minimap_renderer
     io_fileread
     io_filesystem
@@ -42,4 +43,5 @@
     scripting_lua_table
     wui
     wui_mapview_pixelfunctions
+    wui_mapview
 )

=== modified file 'src/game_io/game_interactive_player_packet.cc'
--- src/game_io/game_interactive_player_packet.cc	2016-08-04 15:49:05 +0000
+++ src/game_io/game_interactive_player_packet.cc	2016-10-24 20:07:47 +0000
@@ -30,7 +30,22 @@
 
 namespace Widelands {
 
-constexpr uint16_t kCurrentPacketVersion = 3;
+namespace {
+
+constexpr uint16_t kCurrentPacketVersion = 4;
+
+void load_landmarks_pre_zoom(FileRead* fr, InteractiveBase* ibase) {
+	size_t no_of_landmarks = fr->unsigned_8();
+	for (size_t i = 0; i < no_of_landmarks; ++i) {
+		uint8_t set = fr->unsigned_8();
+		QuickNavigation::View view = {Vector2f(fr->signed_32(), fr->signed_32()), 1.f};
+		if (set > 0) {
+			ibase->set_landmark(i, view);
+		}
+	}
+}
+
+}  // namespace
 
 void GameInteractivePlayerPacket::read(FileSystem& fs, Game& game, MapObjectLoader*) {
 	try {
@@ -55,12 +70,19 @@
 				if (player_number > max)
 					throw GameDataError("The game has no players!");
 			}
-			int32_t const x = fr.unsigned_16();
-			int32_t const y = fr.unsigned_16();
+			float viewpoint_x, viewpoint_y;
+			if (packet_version <= 3) {
+				viewpoint_x = fr.unsigned_16();
+				viewpoint_y = fr.unsigned_16();
+			} else {
+				viewpoint_x = fr.float_32();
+				viewpoint_y = fr.float_32();
+			}
+
 			uint32_t const display_flags = fr.unsigned_32();
 
 			if (InteractiveBase* const ibase = game.get_ibase()) {
-				ibase->set_viewpoint(Point(x, y), true);
+				ibase->set_viewpoint(Vector2f(viewpoint_x, viewpoint_y), true);
 
 				uint32_t const loaded_df =
 				   InteractiveBase::dfShowCensus | InteractiveBase::dfShowStatistics;
@@ -73,14 +95,19 @@
 			}
 
 			// Map landmarks
-			if (packet_version >= 3) {
-				if (InteractiveBase* const ibase = game.get_ibase()) {
+			if (InteractiveBase* const ibase = game.get_ibase()) {
+				if (packet_version == 3) {
+					load_landmarks_pre_zoom(&fr, ibase);
+				} else if (packet_version >= 4) {
 					size_t no_of_landmarks = fr.unsigned_8();
 					for (size_t i = 0; i < no_of_landmarks; ++i) {
 						uint8_t set = fr.unsigned_8();
-						Point landmark(fr.signed_32(), fr.signed_32());
+						const float x = fr.float_32();
+						const float y = fr.float_32();
+						const float zoom = fr.float_32();
+						QuickNavigation::View view = {Vector2f(x, y), zoom};
 						if (set > 0) {
-							ibase->set_landmark(i, landmark);
+							ibase->set_landmark(i, view);
 						}
 					}
 				}
@@ -109,12 +136,14 @@
 	fw.unsigned_8(iplayer ? iplayer->player_number() : 1);
 
 	// Map Position
+#ifndef NDEBUG
 	if (ibase) {
 		assert(0 <= ibase->get_viewpoint().x);
 		assert(0 <= ibase->get_viewpoint().y);
 	}
-	fw.unsigned_16(ibase ? ibase->get_viewpoint().x : 0);
-	fw.unsigned_16(ibase ? ibase->get_viewpoint().y : 0);
+#endif
+	fw.float_32(ibase ? ibase->get_viewpoint().x : 0.f);
+	fw.float_32(ibase ? ibase->get_viewpoint().y : 0.f);
 
 	// Display flags
 	fw.unsigned_32(ibase ? ibase->get_display_flags() : 0);
@@ -124,8 +153,9 @@
 	fw.unsigned_8(landmarks.size());
 	for (const QuickNavigation::Landmark& landmark : landmarks) {
 		fw.unsigned_8(landmark.set ? 1 : 0);
-		fw.signed_32(landmark.point.x);
-		fw.signed_32(landmark.point.y);
+		fw.float_32(landmark.view.viewpoint.x);
+		fw.float_32(landmark.view.viewpoint.y);
+		fw.float_32(landmark.view.zoom);
 	}
 
 	fw.write(fs, "binary/interactive_player");

=== modified file 'src/game_io/game_preload_packet.cc'
--- src/game_io/game_preload_packet.cc	2016-08-05 12:32:08 +0000
+++ src/game_io/game_preload_packet.cc	2016-10-24 20:07:47 +0000
@@ -27,6 +27,7 @@
 #include "base/time_string.h"
 #include "build_info.h"
 #include "graphic/graphic.h"
+#include "graphic/image_io.h"
 #include "graphic/minimap_renderer.h"
 #include "logic/game.h"
 #include "logic/game_data_error.h"
@@ -120,13 +121,17 @@
 
 	std::unique_ptr<::StreamWrite> sw(fs.open_stream_write(kMinimapFilename));
 	if (sw.get() != nullptr) {
-		const MiniMapLayer flags =
+		const MiniMapLayer layers =
 		   MiniMapLayer::Owner | MiniMapLayer::Building | MiniMapLayer::Terrain;
+		std::unique_ptr<Texture> texture;
 		if (ipl != nullptr) {  // Player
-			write_minimap_image(game, &ipl->player(), ipl->get_viewpoint(), flags, sw.get());
+			texture = draw_minimap(
+			   game, &ipl->player(), ipl->get_view_area(), MiniMapType::kStaticViewWindow, layers);
 		} else {  // Observer
-			write_minimap_image(game, nullptr, Point(0, 0), flags, sw.get());
+			texture = draw_minimap(game, nullptr, Rectf(), MiniMapType::kStaticMap, layers);
 		}
+		assert(texture != nullptr);
+		save_to_png(texture.get(), sw.get(), ColorType::RGBA);
 		sw->flush();
 	}
 }

=== modified file 'src/graphic/CMakeLists.txt'
--- src/graphic/CMakeLists.txt	2016-02-19 19:10:44 +0000
+++ src/graphic/CMakeLists.txt	2016-10-24 20:07:47 +0000
@@ -124,6 +124,7 @@
     graphic_surface
     io_filesystem
     logic
+    logic_widelands_geometry
 )
 
 wl_library(graphic_draw_programs
@@ -209,7 +210,6 @@
     base_macros
     economy
     graphic
-    graphic_image_io
     graphic_surface
     logic
     wui_mapview_pixelfunctions

=== modified file 'src/graphic/align.cc'
--- src/graphic/align.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/align.cc	2016-10-24 20:07:47 +0000
@@ -53,7 +53,12 @@
 	return alignment;
 }
 
-void correct_for_align(Align align, uint32_t w, uint32_t h, Point* pt) {
+void correct_for_align(Align align, uint32_t w, uint32_t h, Vector2f* pt) {
+	// When correcting for align, we never move from pixel boundaries to
+	// sub-pixels, because this might lead from pixel-perfect rendering to
+	// subsampled rendering - this can lead to blurry texts. That is why we
+	// never do float divisions in this function.
+
 	// Vertical Align
 	if (static_cast<int>(align & (Align::kVCenter | Align::kBottom))) {
 		if (static_cast<int>(align & Align::kVCenter))

=== modified file 'src/graphic/align.h'
--- src/graphic/align.h	2016-08-04 15:49:05 +0000
+++ src/graphic/align.h	2016-10-24 20:07:47 +0000
@@ -20,7 +20,7 @@
 #ifndef WL_GRAPHIC_ALIGN_H
 #define WL_GRAPHIC_ALIGN_H
 
-#include "base/point.h"
+#include "base/vector.h"
 
 namespace UI {
 
@@ -58,6 +58,6 @@
 }
 
 Align mirror_alignment(Align alignment);
-void correct_for_align(Align, uint32_t w, uint32_t h, Point* pt);
+void correct_for_align(Align, uint32_t w, uint32_t h, Vector2f* pt);
 }
 #endif  // end of include guard: WL_GRAPHIC_ALIGN_H

=== modified file 'src/graphic/animation.cc'
--- src/graphic/animation.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/animation.cc	2016-10-24 20:07:47 +0000
@@ -44,7 +44,7 @@
 
 namespace {
 // Parses an array { 12, 23 } into a point.
-void get_point(const LuaTable& table, Point* p) {
+void get_point(const LuaTable& table, Vector2i* p) {
 	std::vector<int> pts = table.array_entries<int>();
 	if (pts.size() != 2) {
 		throw wexception("Expected 2 entries, but got %" PRIuS ".", pts.size());
@@ -68,11 +68,14 @@
 	uint16_t height() const override;
 	uint16_t nr_frames() const override;
 	uint32_t frametime() const override;
-	const Point& hotspot() const override;
+	const Vector2i& hotspot() const override;
 	Image* representative_image(const RGBColor* clr) const override;
 	const std::string& representative_image_filename() const override;
-	virtual void blit(
-	   uint32_t time, const Point&, const Rect& srcrc, const RGBColor* clr, Surface*) const override;
+	virtual void blit(uint32_t time,
+	                  const Rectf& dstrc,
+	                  const Rectf& srcrc,
+	                  const RGBColor* clr,
+	                  Surface*) const override;
 	void trigger_sound(uint32_t framenumber, uint32_t stereo_position) const override;
 
 private:
@@ -85,7 +88,7 @@
 	uint32_t current_frame(uint32_t time) const;
 
 	uint32_t frametime_;
-	Point hotspot_;
+	Vector2i hotspot_;
 	bool hasplrclrs_;
 	std::vector<std::string> image_files_;
 	std::vector<std::string> pc_mask_image_files_;
@@ -207,7 +210,7 @@
 	return frametime_;
 }
 
-const Point& NonPackedAnimation::hotspot() const {
+const Vector2i& NonPackedAnimation::hotspot() const {
 	return hotspot_;
 }
 
@@ -221,11 +224,11 @@
 	Texture* rv = new Texture(w, h);
 	if (!hasplrclrs_ || clr == nullptr) {
 		// No player color means we simply want an exact copy of the original image.
-		rv->blit(Rect(Point(0, 0), w, h), *image, Rect(Point(0, 0), w, h), 1., BlendMode::Copy);
+		rv->blit(Rectf(0, 0, w, h), *image, Rectf(0, 0, w, h), 1., BlendMode::Copy);
 	} else {
-		rv->fill_rect(Rect(Point(0, 0), w, h), RGBAColor(0, 0, 0, 0));
-		rv->blit_blended(Rect(Point(0, 0), w, h), *image,
-		                 *g_gr->images().get(pc_mask_image_files_[0]), Rect(Point(0, 0), w, h), *clr);
+		rv->fill_rect(Rectf(0, 0, w, h), RGBAColor(0, 0, 0, 0));
+		rv->blit_blended(Rectf(0, 0, w, h), *image, *g_gr->images().get(pc_mask_image_files_[0]),
+		                 Rectf(0, 0, w, h), *clr);
 	}
 	return rv;
 }
@@ -255,19 +258,20 @@
 	}
 }
 
-void NonPackedAnimation::blit(
-   uint32_t time, const Point& dst, const Rect& srcrc, const RGBColor* clr, Surface* target) const {
+void NonPackedAnimation::blit(uint32_t time,
+                              const Rectf& dstrc,
+                              const Rectf& srcrc,
+                              const RGBColor* clr,
+                              Surface* target) const {
 	assert(target);
 
 	const uint32_t idx = current_frame(time);
 	assert(idx < nr_frames());
 
 	if (!hasplrclrs_ || clr == nullptr) {
-		target->blit(
-		   Rect(dst.x, dst.y, srcrc.w, srcrc.h), *frames_.at(idx), srcrc, 1., BlendMode::UseAlpha);
+		target->blit(dstrc, *frames_.at(idx), srcrc, 1., BlendMode::UseAlpha);
 	} else {
-		target->blit_blended(
-		   Rect(dst.x, dst.y, srcrc.w, srcrc.h), *frames_.at(idx), *pcmasks_.at(idx), srcrc, *clr);
+		target->blit_blended(dstrc, *frames_.at(idx), *pcmasks_.at(idx), srcrc, *clr);
 	}
 }
 

=== modified file 'src/graphic/animation.h'
--- src/graphic/animation.h	2016-08-04 15:49:05 +0000
+++ src/graphic/animation.h	2016-10-24 20:07:47 +0000
@@ -29,8 +29,8 @@
 #include <boost/utility.hpp>
 
 #include "base/macros.h"
-#include "base/point.h"
 #include "base/rect.h"
+#include "base/vector.h"
 
 class Image;
 class LuaTable;
@@ -68,7 +68,7 @@
 
 	/// The hotspot of this animation. Note that this is ignored when blitting,
 	/// so the caller has to adjust for the hotspot himself.
-	virtual const Point& hotspot() const = 0;
+	virtual const Vector2i& hotspot() const = 0;
 
 	/// An image of the first frame, blended with the given player color.
 	/// The 'clr' is the player color used for blending - the parameter can be
@@ -83,8 +83,11 @@
 	/// color used for blitting - the parameter can be 'nullptr', in which case the
 	/// neutral image will be blitted. The Surface is the target for the blit
 	/// operation and must be non-null.
-	virtual void
-	blit(uint32_t time, const Point&, const Rect& srcrc, const RGBColor* clr, Surface*) const = 0;
+	virtual void blit(uint32_t time,
+	                  const Rectf& dstrc,
+	                  const Rectf& srcrc,
+	                  const RGBColor* clr,
+	                  Surface*) const = 0;
 
 	/// Play the sound effect associated with this animation at the given time.
 	virtual void trigger_sound(uint32_t time, uint32_t stereo_position) const = 0;

=== modified file 'src/graphic/font_handler.cc'
--- src/graphic/font_handler.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/font_handler.cc	2016-10-24 20:07:47 +0000
@@ -46,16 +46,15 @@
  */
 void draw_caret(RenderTarget& dst,
                 const TextStyle& style,
-                const Point& dstpoint,
+                const Vector2f& dstpoint,
                 const std::string& text,
                 uint32_t caret_offset) {
 	int caret_x = style.calc_bare_width(text.substr(0, caret_offset));
 
 	const Image* caret_image = g_gr->images().get("images/ui_basic/caret.png");
-	Point caretpt;
+	Vector2f caretpt;
 	caretpt.x = dstpoint.x + caret_x + LINE_MARGIN - caret_image->width();
-	caretpt.y = dstpoint.y + (style.font->height() - caret_image->height()) / 2;
-
+	caretpt.y = dstpoint.y + (style.font->height() - caret_image->height()) / 2.f;
 	dst.blit(caretpt, caret_image);
 }
 
@@ -202,7 +201,7 @@
  */
 void FontHandler::draw_text(RenderTarget& dst,
                             const TextStyle& style,
-                            Point dstpoint,
+                            Vector2i dstpoint_i,
                             const std::string& text,
                             Align align,
                             uint32_t caret) {
@@ -212,10 +211,11 @@
 	copytext = i18n::make_ligatures(copytext.c_str());
 	const LineCacheEntry& lce = d->get_line(style, copytext);
 
+	Vector2f dstpoint = dstpoint_i.cast<float>();
 	UI::correct_for_align(align, lce.width + 2 * LINE_MARGIN, lce.height, &dstpoint);
 
 	if (lce.image)
-		dst.blit(Point(dstpoint.x + LINE_MARGIN, dstpoint.y), lce.image.get());
+		dst.blit(Vector2f(dstpoint.x + LINE_MARGIN, dstpoint.y), lce.image.get());
 
 	if (caret <= copytext.size())
 		draw_caret(dst, style, dstpoint, copytext, caret);
@@ -226,12 +226,13 @@
  */
 uint32_t FontHandler::draw_text_raw(RenderTarget& dst,
                                     const UI::TextStyle& style,
-                                    Point dstpoint,
+                                    Vector2i dstpoint,
                                     const std::string& text) {
 	const LineCacheEntry& lce = d->get_line(style, text);
 
-	if (lce.image)
-		dst.blit(dstpoint, lce.image.get());
+	if (lce.image) {
+		dst.blit(dstpoint.cast<float>(), lce.image.get());
+	}
 
 	return lce.width;
 }

=== modified file 'src/graphic/font_handler.h'
--- src/graphic/font_handler.h	2016-08-04 15:49:05 +0000
+++ src/graphic/font_handler.h	2016-10-24 20:07:47 +0000
@@ -24,7 +24,7 @@
 #include <memory>
 #include <string>
 
-#include "base/point.h"
+#include "base/vector.h"
 #include "graphic/align.h"
 
 class RenderTarget;
@@ -42,11 +42,11 @@
 
 	void draw_text(RenderTarget&,
 	               const TextStyle&,
-	               Point dstpoint,
+	               Vector2i dstpoint,
 	               const std::string& text,
 	               Align align = UI::Align::kCenterLeft,
 	               uint32_t caret = std::numeric_limits<uint32_t>::max());
-	uint32_t draw_text_raw(RenderTarget&, const TextStyle&, Point dstpoint, const std::string& text);
+	uint32_t draw_text_raw(RenderTarget&, const TextStyle&, Vector2i dstpoint, const std::string& text);
 
 	void get_size(const TextStyle&,
 	              const std::string& text,

=== modified file 'src/graphic/font_handler1.h'
--- src/graphic/font_handler1.h	2016-08-04 15:49:05 +0000
+++ src/graphic/font_handler1.h	2016-10-24 20:07:47 +0000
@@ -25,7 +25,7 @@
 #include <string>
 
 #include "base/macros.h"
-#include "base/point.h"
+#include "base/vector.h"
 #include "graphic/align.h"
 #include "graphic/text/font_set.h"
 

=== modified file 'src/graphic/game_renderer.cc'
--- src/graphic/game_renderer.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/game_renderer.cc	2016-10-24 20:07:47 +0000
@@ -97,23 +97,214 @@
 	return brightness / 255.;
 }
 
-// Returns the road that should be rendered here. The format is like in field,
-// but this is not the physically present road, but the one that should be
-// drawn (i.e. taking into account if there is fog of war involved or road
-// building overlays enabled).
-uint8_t field_roads(const FCoords& coords,
-                    const Map& map,
-                    const EdgeOverlayManager& edge_overlay_manager,
-                    const Player* const player) {
-	uint8_t roads;
-	if (player && !player->see_all()) {
-		const Player::Field& pf = player->fields()[Map::get_index(coords, map.get_width())];
-		roads = pf.roads | edge_overlay_manager.get_overlay(coords);
-	} else {
-		roads = coords.field->get_roads();
-	}
-	roads |= edge_overlay_manager.get_overlay(coords);
-	return roads;
+void draw_objects_for_visible_field(const EditorGameBase& egbase,
+                                    const FieldsToDraw::Field& field,
+                                    const float zoom,
+                                    const DrawText draw_text,
+                                    const Player* player,
+                                    RenderTarget* dst) {
+	BaseImmovable* const imm = field.fcoords.field->get_immovable();
+	if (imm != nullptr && imm->get_positions(egbase).front() == field.fcoords) {
+		DrawText draw_text_for_this_immovable = draw_text;
+		const Player* owner = imm->get_owner();
+		if (player != nullptr && owner != nullptr && !player->see_all() &&
+		    player->is_hostile(*owner)) {
+			draw_text_for_this_immovable =
+			   static_cast<DrawText>(draw_text_for_this_immovable & ~DrawText::kStatistics);
+		}
+
+		imm->draw(
+		   egbase.get_gametime(), draw_text_for_this_immovable, field.rendertarget_pixel, zoom, dst);
+	}
+	for (Bob* bob = field.fcoords.field->get_first_bob(); bob; bob = bob->get_next_bob()) {
+		DrawText draw_text_for_this_bob = draw_text;
+		const Player* owner = bob->get_owner();
+		if (player != nullptr && owner != nullptr && !player->see_all() &&
+		    player->is_hostile(*owner)) {
+			draw_text_for_this_bob =
+			   static_cast<DrawText>(draw_text_for_this_bob & ~DrawText::kStatistics);
+		}
+		bob->draw(egbase, draw_text_for_this_bob, field.rendertarget_pixel, zoom, dst);
+	}
+}
+
+void draw_objets_for_formerly_visible_field(const FieldsToDraw::Field& field,
+                                            const Player::Field& player_field,
+                                            const float zoom,
+                                            RenderTarget* dst) {
+	if (const MapObjectDescr* const map_object_descr =
+	       player_field.map_object_descr[TCoords<>::None]) {
+		if (player_field.constructionsite.becomes) {
+			assert(field.owner != nullptr);
+			const ConstructionsiteInformation& csinf = player_field.constructionsite;
+			// draw the partly finished constructionsite
+			uint32_t anim_idx;
+			try {
+				anim_idx = csinf.becomes->get_animation("build");
+			} catch (MapObjectDescr::AnimationNonexistent&) {
+				try {
+					anim_idx = csinf.becomes->get_animation("unoccupied");
+				} catch (MapObjectDescr::AnimationNonexistent) {
+					anim_idx = csinf.becomes->get_animation("idle");
+				}
+			}
+			const Animation& anim = g_gr->animations().get_animation(anim_idx);
+			const size_t nr_frames = anim.nr_frames();
+			uint32_t cur_frame =
+			   csinf.totaltime ? csinf.completedtime * nr_frames / csinf.totaltime : 0;
+			uint32_t tanim = cur_frame * FRAME_LENGTH;
+
+			const uint16_t w = anim.width();
+			const uint16_t h = anim.height();
+			uint32_t lines = h * csinf.completedtime * nr_frames;
+			if (csinf.totaltime)
+				lines /= csinf.totaltime;
+			assert(h * cur_frame <= lines);
+			lines -= h * cur_frame;
+
+			if (cur_frame) {  // not the first frame
+				// draw the prev frame from top to where next image will be drawing
+				dst->blit_animation(field.rendertarget_pixel, zoom, anim_idx, tanim - FRAME_LENGTH,
+				                    field.owner->get_playercolor(),
+				                    Recti(Vector2i(0, 0), w, h - lines));
+			} else if (csinf.was) {
+				// Is the first frame, but there was another building here before,
+				// get its last build picture and draw it instead.
+				uint32_t a;
+				try {
+					a = csinf.was->get_animation("unoccupied");
+				} catch (MapObjectDescr::AnimationNonexistent&) {
+					a = csinf.was->get_animation("idle");
+				}
+				dst->blit_animation(field.rendertarget_pixel, zoom, a, tanim - FRAME_LENGTH,
+				                    field.owner->get_playercolor(),
+				                    Recti(Vector2i(0, 0), w, h - lines));
+			}
+			assert(lines <= h);
+			dst->blit_animation(field.rendertarget_pixel, zoom, anim_idx, tanim,
+			                    field.owner->get_playercolor(),
+			                    Recti(Vector2i(0, h - lines), w, lines));
+		} else if (upcast(const BuildingDescr, building, map_object_descr)) {
+			assert(field.owner != nullptr);
+			// this is a building therefore we either draw unoccupied or idle animation
+			uint32_t pic;
+			try {
+				pic = building->get_animation("unoccupied");
+			} catch (MapObjectDescr::AnimationNonexistent&) {
+				pic = building->get_animation("idle");
+			}
+			dst->blit_animation(
+			   field.rendertarget_pixel, zoom, pic, 0, field.owner->get_playercolor());
+		} else if (map_object_descr->type() == MapObjectType::FLAG) {
+			assert(field.owner != nullptr);
+			dst->blit_animation(field.rendertarget_pixel, zoom, field.owner->tribe().flag_animation(),
+			                    0, field.owner->get_playercolor());
+		} else if (const uint32_t pic = map_object_descr->main_animation()) {
+			if (field.owner != nullptr) {
+				dst->blit_animation(
+				   field.rendertarget_pixel, zoom, pic, 0, field.owner->get_playercolor());
+			} else {
+				dst->blit_animation(field.rendertarget_pixel, zoom, pic, 0);
+			}
+		}
+	}
+}
+
+// Draws the objects (animations & overlays).
+void draw_objects(const EditorGameBase& egbase,
+                  const float zoom,
+                  const FieldsToDraw& fields_to_draw,
+                  const Player* player,
+                  const DrawText draw_text,
+                  RenderTarget* dst) {
+	std::vector<FieldOverlayManager::OverlayInfo> overlay_info;
+	for (size_t current_index = 0; current_index < fields_to_draw.size(); ++current_index) {
+		const FieldsToDraw::Field& field = fields_to_draw.at(current_index);
+		if (!field.all_neighbors_valid()) {
+			continue;
+		}
+
+		const FieldsToDraw::Field& rn = fields_to_draw.at(field.rn_index);
+		const FieldsToDraw::Field& bln = fields_to_draw.at(field.bln_index);
+		const FieldsToDraw::Field& brn = fields_to_draw.at(field.brn_index);
+
+		if (field.is_border) {
+			assert(field.owner != nullptr);
+			uint32_t const anim_idx = field.owner->tribe().frontier_animation();
+			if (field.vision) {
+				dst->blit_animation(
+				   field.rendertarget_pixel, zoom, anim_idx, 0, field.owner->get_playercolor());
+			}
+			for (const auto& nf : {rn, bln, brn}) {
+				if ((field.vision || nf.vision) && nf.is_border &&
+				    (field.owner == nf.owner || nf.owner == nullptr)) {
+					dst->blit_animation(middle(field.rendertarget_pixel, nf.rendertarget_pixel), zoom,
+					                    anim_idx, 0, field.owner->get_playercolor());
+				}
+			}
+		}
+
+		if (1 < field.vision) {  // Render stuff that belongs to the node.
+			draw_objects_for_visible_field(egbase, field, zoom, draw_text, player, dst);
+		} else if (field.vision == 1) {
+			// We never show census or statistics for objects in the fog.
+			assert(player != nullptr);
+			const Map& map = egbase.map();
+			const Player::Field& player_field =
+			   player->fields()[map.get_index(field.fcoords, map.get_width())];
+			draw_objets_for_formerly_visible_field(field, player_field, zoom, dst);
+		}
+
+		const FieldOverlayManager& overlay_manager = egbase.get_ibase()->field_overlay_manager();
+		{
+			overlay_info.clear();
+			overlay_manager.get_overlays(field.fcoords, &overlay_info);
+			for (const auto& overlay : overlay_info) {
+				dst->blitrect_scale(
+				   Rectf(field.rendertarget_pixel - overlay.hotspot.cast<float>() * zoom,
+				         overlay.pic->width() * zoom, overlay.pic->height() * zoom),
+				   overlay.pic, Recti(0, 0, overlay.pic->width(), overlay.pic->height()), 1.f,
+				   BlendMode::UseAlpha);
+			}
+		}
+
+		{
+			// Render overlays on the right triangle
+			overlay_info.clear();
+			overlay_manager.get_overlays(TCoords<>(field.fcoords, TCoords<>::R), &overlay_info);
+
+			Vector2f tripos(
+			   (field.rendertarget_pixel.x + rn.rendertarget_pixel.x + brn.rendertarget_pixel.x) / 3.f,
+			   (field.rendertarget_pixel.y + rn.rendertarget_pixel.y + brn.rendertarget_pixel.y) /
+			      3.f);
+			for (const auto& overlay : overlay_info) {
+				dst->blitrect_scale(Rectf(tripos - overlay.hotspot.cast<float>() * zoom,
+				                          overlay.pic->width() * zoom, overlay.pic->height() * zoom),
+				                    overlay.pic,
+				                    Recti(0, 0, overlay.pic->width(), overlay.pic->height()), 1.f,
+				                    BlendMode::UseAlpha);
+			}
+		}
+
+		{
+			// Render overlays on the D triangle
+			overlay_info.clear();
+			overlay_manager.get_overlays(TCoords<>(field.fcoords, TCoords<>::D), &overlay_info);
+
+			Vector2f tripos(
+			   (field.rendertarget_pixel.x + bln.rendertarget_pixel.x + brn.rendertarget_pixel.x) /
+			      3.f,
+			   (field.rendertarget_pixel.y + bln.rendertarget_pixel.y + brn.rendertarget_pixel.y) /
+			      3.f);
+			for (const auto& overlay : overlay_info) {
+				dst->blitrect_scale(Rectf(tripos - overlay.hotspot.cast<float>() * zoom,
+				                          overlay.pic->width() * zoom, overlay.pic->height() * zoom),
+				                    overlay.pic,
+				                    Recti(0, 0, overlay.pic->width(), overlay.pic->height()), 1.f,
+				                    BlendMode::UseAlpha);
+			}
+		}
+	}
 }
 
 }  // namespace
@@ -124,46 +315,60 @@
 GameRenderer::~GameRenderer() {
 }
 
-void GameRenderer::rendermap(RenderTarget& dst,
-                             const Widelands::EditorGameBase& egbase,
-                             const Point& view_offset,
-
-                             const Widelands::Player& player) {
-	draw(dst, egbase, view_offset, &player);
-}
-
-void GameRenderer::rendermap(RenderTarget& dst,
-                             const Widelands::EditorGameBase& egbase,
-                             const Point& view_offset) {
-	draw(dst, egbase, view_offset, nullptr);
-}
-
-void GameRenderer::draw(RenderTarget& dst,
-                        const EditorGameBase& egbase,
-                        const Point& view_offset,
-                        const Player* player) {
-	Point tl_map = dst.get_offset() + view_offset;
-
-	assert(tl_map.x >= 0);  // divisions involving negative numbers are bad
-	assert(tl_map.y >= 0);
-
-	int minfx = tl_map.x / kTriangleWidth - 1;
-	int minfy = tl_map.y / kTriangleHeight - 1;
-	int maxfx = (tl_map.x + dst.get_rect().w + (kTriangleWidth / 2)) / kTriangleWidth;
-	int maxfy = (tl_map.y + dst.get_rect().h) / kTriangleHeight;
-
-	// fudge for triangle boundary effects and for height differences
-	minfx -= 1;
-	minfy -= 1;
-	maxfx += 1;
+void GameRenderer::rendermap(const Widelands::EditorGameBase& egbase,
+                             const Vector2f& viewpoint,
+                             const float zoom,
+                             const Widelands::Player& player,
+                             const DrawText draw_text,
+                             RenderTarget* dst) {
+	draw(egbase, viewpoint, zoom, draw_text, &player, dst);
+}
+
+void GameRenderer::rendermap(const Widelands::EditorGameBase& egbase,
+                             const Vector2f& viewpoint,
+                             const float zoom,
+                             const DrawText draw_text,
+                             RenderTarget* dst) {
+	draw(egbase, viewpoint, zoom, draw_text, nullptr, dst);
+}
+
+void GameRenderer::draw(const EditorGameBase& egbase,
+                        const Vector2f& viewpoint,
+                        const float zoom,
+                        const DrawText draw_text,
+                        const Player* player,
+                        RenderTarget* dst) {
+	assert(viewpoint.x >= 0);  // divisions involving negative numbers are bad
+	assert(viewpoint.y >= 0);
+	assert(dst->get_offset().x <= 0);
+	assert(dst->get_offset().y <= 0);
+
+	int minfx = std::floor(viewpoint.x / kTriangleWidth);
+	int minfy = std::floor(viewpoint.y / kTriangleHeight);
+
+	// If a view window is partially moved outside of the display, its 'rect' is
+	// adjusted to be fully contained on the screen - i.e. x = 0 and width is
+	// made smaller. Its offset is made negative to account for this change.
+	// To figure out which fields we need to draw, we have to add the absolute
+	// value of 'offset' to the actual dimension of the 'rect' to get to desired
+	// dimension of the 'rect'
+	const Vector2f br_map = MapviewPixelFunctions::panel_to_map(
+	   viewpoint, zoom, Vector2f(dst->get_rect().w + std::abs(dst->get_offset().x),
+	                             dst->get_rect().h + std::abs(dst->get_offset().y)));
+	int maxfx = std::ceil(br_map.x / kTriangleWidth);
+	int maxfy = std::ceil(br_map.y / kTriangleHeight);
+
+	// Adjust for triangle boundary effects and for height differences.
+	minfx -= 2;
+	maxfx += 2;
+	minfy -= 2;
 	maxfy += 10;
 
-	Surface* surface = dst.get_surface();
+	Surface* surface = dst->get_surface();
 	if (!surface)
 		return;
 
-	const Rect& bounding_rect = dst.get_rect();
-	const Point surface_offset = bounding_rect.origin() + dst.get_offset() - view_offset;
+	const Recti& bounding_rect = dst->get_rect();
 	const int surface_width = surface->width();
 	const int surface_height = surface->height();
 
@@ -171,46 +376,60 @@
 	const EdgeOverlayManager& edge_overlay_manager = egbase.get_ibase()->edge_overlay_manager();
 	const uint32_t gametime = egbase.get_gametime();
 
+	const float scale = 1.f / zoom;
 	fields_to_draw_.reset(minfx, maxfx, minfy, maxfy);
 	for (int32_t fy = minfy; fy <= maxfy; ++fy) {
 		for (int32_t fx = minfx; fx <= maxfx; ++fx) {
 			FieldsToDraw::Field& f =
 			   *fields_to_draw_.mutable_field(fields_to_draw_.calculate_index(fx, fy));
 
-			f.fx = fx;
-			f.fy = fy;
-
-			Coords coords(fx, fy);
-			int x, y;
-			MapviewPixelFunctions::get_basepix(coords, x, y);
-
-			map.normalize_coords(coords);
-			const FCoords& fcoords = map.get_fcoords(coords);
+			f.geometric_coords = Coords(fx, fy);
+
+			f.ln_index = fields_to_draw_.calculate_index(fx - 1, fy);
+			f.rn_index = fields_to_draw_.calculate_index(fx + 1, fy);
+			f.trn_index = fields_to_draw_.calculate_index(fx + (fy & 1), fy - 1);
+			f.bln_index = fields_to_draw_.calculate_index(fx + (fy & 1) - 1, fy + 1);
+			f.brn_index = fields_to_draw_.calculate_index(fx + (fy & 1), fy + 1);
 
 			// Texture coordinates for pseudo random tiling of terrain and road
 			// graphics. Since screen space X increases top-to-bottom and OpenGL
 			// increases bottom-to-top we flip the y coordinate to not have
 			// terrains and road graphics vertically mirrorerd.
-			f.texture_x = float(x) / kTextureSideLength;
-			f.texture_y = -float(y) / kTextureSideLength;
-
-			f.gl_x = f.pixel_x = x + surface_offset.x;
-			f.gl_y = f.pixel_y = y + surface_offset.y - fcoords.field->get_height() * kHeightFactor;
-			pixel_to_gl_renderbuffer(surface_width, surface_height, &f.gl_x, &f.gl_y);
-
-			f.ter_d = fcoords.field->terrain_d();
-			f.ter_r = fcoords.field->terrain_r();
-
-			f.brightness = field_brightness(fcoords, gametime, map, player);
-
-			PlayerNumber owner_number = fcoords.field->get_owned_by();
-			if (owner_number > 0) {
-				f.road_textures = &egbase.player(owner_number).tribe().road_textures();
-			} else {
-				f.road_textures = nullptr;
+			Vector2f map_pixel =
+			   MapviewPixelFunctions::to_map_pixel_ignoring_height(f.geometric_coords);
+			f.texture_coords.x = map_pixel.x / kTextureSideLength;
+			f.texture_coords.y = -map_pixel.y / kTextureSideLength;
+
+			Coords normalized = f.geometric_coords;
+			map.normalize_coords(normalized);
+			f.fcoords = map.get_fcoords(normalized);
+
+			map_pixel.y -= f.fcoords.field->get_height() * kHeightFactor;
+
+			f.rendertarget_pixel = MapviewPixelFunctions::map_to_panel(viewpoint, zoom, map_pixel);
+			f.gl_position = f.surface_pixel = f.rendertarget_pixel +
+			                                  dst->get_rect().origin().cast<float>() +
+			                                  dst->get_offset().cast<float>();
+			pixel_to_gl_renderbuffer(
+			   surface_width, surface_height, &f.gl_position.x, &f.gl_position.y);
+
+			f.brightness = field_brightness(f.fcoords, gametime, map, player);
+
+			PlayerNumber owned_by = f.fcoords.field->get_owned_by();
+			f.owner = owned_by != 0 ? &egbase.player(owned_by) : nullptr;
+			f.is_border = f.fcoords.field->is_border();
+			f.vision = 2;
+			f.roads = f.fcoords.field->get_roads();
+			if (player && !player->see_all()) {
+				const Player::Field& pf = player->fields()[map.get_index(f.fcoords, map.get_width())];
+				f.roads = pf.roads;
+				f.vision = pf.vision;
+				if (pf.vision == 1) {
+					f.owner = pf.owner != 0 ? &egbase.player(owned_by) : nullptr;
+					f.is_border = pf.border;
+				}
 			}
-
-			f.roads = field_roads(fcoords, map, edge_overlay_manager, player);
+			f.roads |= edge_overlay_manager.get_overlay(f.fcoords);
 		}
 	}
 
@@ -219,13 +438,14 @@
 	i.program_id = RenderQueue::Program::kTerrainBase;
 	i.blend_mode = BlendMode::Copy;
 	i.terrain_arguments.destination_rect =
-	   FloatRect(bounding_rect.x, surface_height - bounding_rect.y - bounding_rect.h,
-	             bounding_rect.w, bounding_rect.h);
+	   Rectf(bounding_rect.x, surface_height - bounding_rect.y - bounding_rect.h, bounding_rect.w,
+	         bounding_rect.h);
 	i.terrain_arguments.gametime = gametime;
 	i.terrain_arguments.renderbuffer_width = surface_width;
 	i.terrain_arguments.renderbuffer_height = surface_height;
 	i.terrain_arguments.terrains = &egbase.world().terrains();
 	i.terrain_arguments.fields_to_draw = &fields_to_draw_;
+	i.terrain_arguments.scale = scale;
 	RenderQueue::instance().enqueue(i);
 
 	// Enqueue the drawing of the dither layer.
@@ -237,191 +457,5 @@
 	i.program_id = RenderQueue::Program::kTerrainRoad;
 	RenderQueue::instance().enqueue(i);
 
-	draw_objects(dst, egbase, view_offset, player, minfx, maxfx, minfy, maxfy);
-}
-
-void GameRenderer::draw_objects(RenderTarget& dst,
-                                const EditorGameBase& egbase,
-                                const Point& view_offset,
-                                const Player* player,
-                                int minfx,
-                                int maxfx,
-                                int minfy,
-                                int maxfy) {
-	// TODO(sirver): this should use FieldsToDraw. Would simplify this function a lot.
-	static const uint32_t F = 0;
-	static const uint32_t R = 1;
-	static const uint32_t BL = 2;
-	static const uint32_t BR = 3;
-	const Map& map = egbase.map();
-
-	std::vector<FieldOverlayManager::OverlayInfo> overlay_info;
-	for (int32_t fy = minfy; fy <= maxfy; ++fy) {
-		for (int32_t fx = minfx; fx <= maxfx; ++fx) {
-			Coords ncoords(fx, fy);
-			map.normalize_coords(ncoords);
-			FCoords coords[4];
-			coords[F] = map.get_fcoords(ncoords);
-			coords[R] = map.r_n(coords[F]);
-			coords[BL] = map.bl_n(coords[F]);
-			coords[BR] = map.br_n(coords[F]);
-			Point pos[4];
-			MapviewPixelFunctions::get_basepix(Coords(fx, fy), pos[F].x, pos[F].y);
-			MapviewPixelFunctions::get_basepix(Coords(fx + 1, fy), pos[R].x, pos[R].y);
-			MapviewPixelFunctions::get_basepix(
-			   Coords(fx + (fy & 1) - 1, fy + 1), pos[BL].x, pos[BL].y);
-			MapviewPixelFunctions::get_basepix(Coords(fx + (fy & 1), fy + 1), pos[BR].x, pos[BR].y);
-			for (uint32_t d = 0; d < 4; ++d) {
-				pos[d].y -= coords[d].field->get_height() * kHeightFactor;
-				pos[d] -= view_offset;
-			}
-
-			PlayerNumber owner_number[4];
-			bool isborder[4];
-			Vision vision[4] = {2, 2, 2, 2};
-			for (uint32_t d = 0; d < 4; ++d)
-				owner_number[d] = coords[d].field->get_owned_by();
-			for (uint32_t d = 0; d < 4; ++d)
-				isborder[d] = coords[d].field->is_border();
-
-			if (player && !player->see_all()) {
-				for (uint32_t d = 0; d < 4; ++d) {
-					const Player::Field& pf =
-					   player->fields()[map.get_index(coords[d], map.get_width())];
-					vision[d] = pf.vision;
-					if (pf.vision == 1) {
-						owner_number[d] = pf.owner;
-						isborder[d] = pf.border;
-					}
-				}
-			}
-
-			if (isborder[F]) {
-				const Player& owner = egbase.player(owner_number[F]);
-				uint32_t const anim_idx = owner.tribe().frontier_animation();
-				if (vision[F])
-					dst.blit_animation(pos[F], anim_idx, 0, owner.get_playercolor());
-				for (uint32_t d = 1; d < 4; ++d) {
-					if ((vision[F] || vision[d]) && isborder[d] &&
-					    (owner_number[d] == owner_number[F] || !owner_number[d])) {
-						dst.blit_animation(middle(pos[F], pos[d]), anim_idx, 0, owner.get_playercolor());
-					}
-				}
-			}
-
-			if (1 < vision[F]) {  // Render stuff that belongs to the node.
-				if (BaseImmovable* const imm = coords[F].field->get_immovable())
-					imm->draw(egbase, dst, coords[F], pos[F]);
-				for (Bob* bob = coords[F].field->get_first_bob(); bob; bob = bob->get_next_bob())
-					bob->draw(egbase, dst, pos[F]);
-			} else if (vision[F] == 1) {
-				const Player::Field& f_pl = player->fields()[map.get_index(coords[F], map.get_width())];
-				const Player* owner = owner_number[F] ? egbase.get_player(owner_number[F]) : nullptr;
-				if (const MapObjectDescr* const map_object_descr =
-				       f_pl.map_object_descr[TCoords<>::None]) {
-					if (f_pl.constructionsite.becomes) {
-						assert(owner != nullptr);
-						const ConstructionsiteInformation& csinf = f_pl.constructionsite;
-						// draw the partly finished constructionsite
-						uint32_t anim_idx;
-						try {
-							anim_idx = csinf.becomes->get_animation("build");
-						} catch (MapObjectDescr::AnimationNonexistent&) {
-							try {
-								anim_idx = csinf.becomes->get_animation("unoccupied");
-							} catch (MapObjectDescr::AnimationNonexistent) {
-								anim_idx = csinf.becomes->get_animation("idle");
-							}
-						}
-						const Animation& anim = g_gr->animations().get_animation(anim_idx);
-						const size_t nr_frames = anim.nr_frames();
-						uint32_t cur_frame =
-						   csinf.totaltime ? csinf.completedtime * nr_frames / csinf.totaltime : 0;
-						uint32_t tanim = cur_frame * FRAME_LENGTH;
-
-						const uint16_t w = anim.width();
-						const uint16_t h = anim.height();
-						uint32_t lines = h * csinf.completedtime * nr_frames;
-						if (csinf.totaltime)
-							lines /= csinf.totaltime;
-						assert(h * cur_frame <= lines);
-						lines -= h * cur_frame;
-
-						if (cur_frame) {  // not the first frame
-							// draw the prev frame from top to where next image will be drawing
-							dst.blit_animation(pos[F], anim_idx, tanim - FRAME_LENGTH,
-							                   owner->get_playercolor(), Rect(Point(0, 0), w, h - lines));
-						} else if (csinf.was) {
-							// Is the first frame, but there was another building here before,
-							// get its last build picture and draw it instead.
-							uint32_t a;
-							try {
-								a = csinf.was->get_animation("unoccupied");
-							} catch (MapObjectDescr::AnimationNonexistent&) {
-								a = csinf.was->get_animation("idle");
-							}
-							dst.blit_animation(pos[F], a, tanim - FRAME_LENGTH, owner->get_playercolor(),
-							                   Rect(Point(0, 0), w, h - lines));
-						}
-						assert(lines <= h);
-						dst.blit_animation(pos[F], anim_idx, tanim, owner->get_playercolor(),
-						                   Rect(Point(0, h - lines), w, lines));
-					} else if (upcast(const BuildingDescr, building, map_object_descr)) {
-						assert(owner != nullptr);
-						// this is a building therefore we either draw unoccupied or idle animation
-						uint32_t pic;
-						try {
-							pic = building->get_animation("unoccupied");
-						} catch (MapObjectDescr::AnimationNonexistent&) {
-							pic = building->get_animation("idle");
-						}
-						dst.blit_animation(pos[F], pic, 0, owner->get_playercolor());
-					} else if (map_object_descr->type() == MapObjectType::FLAG) {
-						assert(owner != nullptr);
-						dst.blit_animation(
-						   pos[F], owner->tribe().flag_animation(), 0, owner->get_playercolor());
-					} else if (const uint32_t pic = map_object_descr->main_animation()) {
-						if (owner != nullptr) {
-							dst.blit_animation(pos[F], pic, 0, owner->get_playercolor());
-						} else {
-							dst.blit_animation(pos[F], pic, 0);
-						}
-					}
-				}
-			}
-
-			const FieldOverlayManager& overlay_manager = egbase.get_ibase()->field_overlay_manager();
-			{
-				overlay_info.clear();
-				overlay_manager.get_overlays(coords[F], &overlay_info);
-				for (const auto& overlay : overlay_info) {
-					dst.blit(pos[F] - overlay.hotspot, overlay.pic);
-				}
-			}
-
-			{
-				// Render overlays on the R triangle
-				overlay_info.clear();
-				overlay_manager.get_overlays(TCoords<>(coords[F], TCoords<>::R), &overlay_info);
-
-				Point tripos(
-				   (pos[F].x + pos[R].x + pos[BR].x) / 3, (pos[F].y + pos[R].y + pos[BR].y) / 3);
-				for (const auto& overlay : overlay_info) {
-					dst.blit(tripos - overlay.hotspot, overlay.pic);
-				}
-			}
-
-			{
-				// Render overlays on the D triangle
-				overlay_info.clear();
-				overlay_manager.get_overlays(TCoords<>(coords[F], TCoords<>::D), &overlay_info);
-
-				Point tripos(
-				   (pos[F].x + pos[BL].x + pos[BR].x) / 3, (pos[F].y + pos[BL].y + pos[BR].y) / 3);
-				for (const auto& overlay : overlay_info) {
-					dst.blit(tripos - overlay.hotspot, overlay.pic);
-				}
-			}
-		}
-	}
+	draw_objects(egbase, scale, fields_to_draw_, player, draw_text, dst);
 }

=== modified file 'src/graphic/game_renderer.h'
--- src/graphic/game_renderer.h	2016-08-04 15:49:05 +0000
+++ src/graphic/game_renderer.h	2016-10-24 20:07:47 +0000
@@ -23,8 +23,9 @@
 #include <memory>
 
 #include "base/macros.h"
-#include "base/point.h"
+#include "base/vector.h"
 #include "graphic/gl/fields_to_draw.h"
+#include "logic/map_objects/draw_text.h"
 
 namespace Widelands {
 class Player;
@@ -33,51 +34,39 @@
 
 class RenderTarget;
 
-/**
- * This abstract base class renders the main game view into an
- * arbitrary @ref RenderTarget.
- *
- * Specializations exist for SDL software rendering and for OpenGL rendering.
- *
- * Users of this class should keep instances alive for as long as possible,
- * so that target-specific optimizations (such as caching data) can
- * be effective.
- */
+// Renders the MapView on screen.
 class GameRenderer {
 public:
 	GameRenderer();
 	~GameRenderer();
 
-	// Renders the map from a player's point of view into the given
-	// drawing window. 'view_offset' is the offset of the upper left
-	// corner of the window into the map, in pixels.
-	void rendermap(RenderTarget& dst,
-	               const Widelands::EditorGameBase& egbase,
-	               const Point& view_offset,
-	               const Widelands::Player& player);
+	// Renders the map from a player's point of view into the given drawing
+	// window. The 'viewpoint' is the top left screens pixel map pixel and
+	// 'scale' is the magnification of the view.
+	void rendermap(const Widelands::EditorGameBase& egbase,
+	               const Vector2f& viewpoint,
+	               float scale,
+	               const Widelands::Player& player,
+	               DrawText draw_text,
+	               RenderTarget* dst);
 
 	// Renders the map from an omniscient perspective. This is used
 	// for spectators, players that see all, and in the editor.
-	void
-	rendermap(RenderTarget& dst, const Widelands::EditorGameBase& egbase, const Point& view_offset);
+	void rendermap(const Widelands::EditorGameBase& egbase,
+	               const Vector2f& viewpoint,
+	               float scale,
+	               DrawText draw_text,
+	               RenderTarget* dst);
 
 private:
 	// Draw the map for the given parameters (see rendermap). 'player'
 	// can be nullptr in which case the whole map is drawn.
-	void draw(RenderTarget& dst,
-	          const Widelands::EditorGameBase& egbase,
-	          const Point& view_offset,
-	          const Widelands::Player* player);
-
-	// Draws the objects (animations & overlays).
-	void draw_objects(RenderTarget& dst,
-	                  const Widelands::EditorGameBase& egbase,
-	                  const Point& view_offset,
-	                  const Widelands::Player* player,
-	                  int minfx,
-	                  int maxfx,
-	                  int minfy,
-	                  int maxfy);
+	void draw(const Widelands::EditorGameBase& egbase,
+	          const Vector2f& viewpoint,
+	          float scale,
+	          DrawText draw_text,
+	          const Widelands::Player* player,
+	          RenderTarget* dst);
 
 	// This is owned and handled by us, but handed to the RenderQueue, so we
 	// basically promise that this stays valid for one frame.

=== modified file 'src/graphic/gl/blit_data.h'
--- src/graphic/gl/blit_data.h	2016-01-04 20:54:08 +0000
+++ src/graphic/gl/blit_data.h	2016-10-24 20:07:47 +0000
@@ -38,7 +38,7 @@
 	int parent_height;
 
 	// The subrect in the parent texture.
-	Rect rect;
+	Rectf rect;
 };
 
 #endif  // end of include guard: WL_GRAPHIC_GL_BLIT_DATA_H

=== modified file 'src/graphic/gl/blit_program.cc'
--- src/graphic/gl/blit_program.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/blit_program.cc	2016-10-24 20:07:47 +0000
@@ -108,8 +108,8 @@
 			const float blend_b = current_args.blend.b / 255.;
 			const float blend_a = current_args.blend.a / 255.;
 
-			const FloatRect texture_rect = to_gl_texture(current_args.texture);
-			const FloatRect mask_rect = to_gl_texture(current_args.mask);
+			const Rectf texture_rect = to_gl_texture(current_args.texture);
+			const Rectf mask_rect = to_gl_texture(current_args.mask);
 			float program_flavor = 0;
 			switch (current_args.blit_mode) {
 			case BlitMode::kDirect:
@@ -176,7 +176,7 @@
 	}
 }
 
-void BlitProgram::draw(const FloatRect& gl_dest_rect,
+void BlitProgram::draw(const Rectf& gl_dest_rect,
                        const float z_value,
                        const BlitData& texture,
                        const BlitData& mask,
@@ -186,11 +186,11 @@
 	                mask.texture_id != 0 ? BlitMode::kBlendedWithMask : BlitMode::kDirect}});
 }
 
-void BlitProgram::draw_monochrome(const FloatRect& dest_rect,
+void BlitProgram::draw_monochrome(const Rectf& dest_rect,
                                   const float z_value,
                                   const BlitData& texture,
                                   const RGBAColor& blend) {
-	draw({Arguments{dest_rect, z_value, texture, BlitData{0, 0, 0, Rect()}, blend,
+	draw({Arguments{dest_rect, z_value, texture, BlitData{0, 0, 0, Rectf()}, blend,
 	                BlendMode::UseAlpha, BlitMode::kMonochrome}});
 }
 

=== modified file 'src/graphic/gl/blit_program.h'
--- src/graphic/gl/blit_program.h	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/blit_program.h	2016-10-24 20:07:47 +0000
@@ -36,7 +36,7 @@
 class BlitProgram {
 public:
 	struct Arguments {
-		FloatRect destination_rect;
+		Rectf destination_rect;
 		float z_value;
 		BlitData texture;
 		BlitData mask;
@@ -53,7 +53,7 @@
 	// 'gl_texture_image' to 'gl_dest_rect' in the currently bound framebuffer. All
 	// coordinates are in the OpenGL frame. The 'texture_mask' is used to selectively apply
 	// the 'blend'. This is used for blitting player colored images.
-	void draw(const FloatRect& gl_dest_rect,
+	void draw(const Rectf& gl_dest_rect,
 	          const float z_value,
 	          const BlitData& texture,
 	          const BlitData& mask,
@@ -64,7 +64,7 @@
 	// 'texture' to 'gl_dest_rect' in the currently bound framebuffer. All
 	// coordinates are in the OpenGL frame. The image is first converted to
 	// luminance, then all values are multiplied with blend.
-	void draw_monochrome(const FloatRect& gl_dest_rect,
+	void draw_monochrome(const Rectf& gl_dest_rect,
 	                     const float z_value,
 	                     const BlitData& blit_source,
 	                     const RGBAColor& blend);

=== modified file 'src/graphic/gl/coordinate_conversion.h'
--- src/graphic/gl/coordinate_conversion.h	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/coordinate_conversion.h	2016-10-24 20:07:47 +0000
@@ -38,34 +38,34 @@
 // Converts 'rect' given on a screen of 'width' x 'height' pixels into a rect
 // in opengl coordinates in a renderbuffer, i.e. in [-1, 1]. The returned
 // rectangle has positive width and height.
-inline FloatRect rect_to_gl_renderbuffer(const int width, const int height, const Rect& rect) {
+inline Rectf rect_to_gl_renderbuffer(const int width, const int height, const Rectf& rect) {
 	float left = rect.x;
 	float top = rect.y;
 	float right = rect.x + rect.w;
 	float bottom = rect.y + rect.h;
 	pixel_to_gl_renderbuffer(width, height, &left, &top);
 	pixel_to_gl_renderbuffer(width, height, &right, &bottom);
-	return FloatRect(left, bottom, right - left, top - bottom);
+	return Rectf(left, bottom, right - left, top - bottom);
 }
 
 // Converts 'rect' given on a texture of 'width' x 'height' pixels into a rect
 // in opengl coordinates in a texture, i.e. in [0, 1]. Texture pixels are sampled in their center.
 // The returned rectangle has positive width and height.
-inline FloatRect rect_to_gl_texture(const int width, const int height, const FloatRect& rect) {
+inline Rectf rect_to_gl_texture(const int width, const int height, const Rectf& rect) {
 	float left = rect.x;
 	float top = rect.y;
 	float right = rect.x + rect.w;
 	float bottom = rect.y + rect.h;
 	pixel_to_gl_texture(width, height, &left, &top);
 	pixel_to_gl_texture(width, height, &right, &bottom);
-	return FloatRect(left, bottom, right - left, top - bottom);
+	return Rectf(left, bottom, right - left, top - bottom);
 }
 
 // Convert 'blit_data' from pixel space into opengl space.
-inline FloatRect to_gl_texture(const BlitData& blit_data) {
+inline Rectf to_gl_texture(const BlitData& blit_data) {
 	return rect_to_gl_texture(
 	   blit_data.parent_width, blit_data.parent_height,
-	   FloatRect(blit_data.rect.x, blit_data.rect.y, blit_data.rect.w, blit_data.rect.h));
+	   Rectf(blit_data.rect.x, blit_data.rect.y, blit_data.rect.w, blit_data.rect.h));
 }
 
 #endif  // end of include guard: WL_GRAPHIC_GL_COORDINATE_CONVERSION_H

=== modified file 'src/graphic/gl/dither_program.cc'
--- src/graphic/gl/dither_program.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/dither_program.cc	2016-10-24 20:07:47 +0000
@@ -56,14 +56,14 @@
 
 void DitherProgram::add_vertex(const FieldsToDraw::Field& field,
                                const TrianglePoint triangle_point,
-                               const FloatPoint& texture_offset) {
+                               const Vector2f& texture_offset) {
 	vertices_.emplace_back();
 	PerVertexData& back = vertices_.back();
 
-	back.gl_x = field.gl_x;
-	back.gl_y = field.gl_y;
-	back.texture_x = field.texture_x;
-	back.texture_y = field.texture_y;
+	back.gl_x = field.gl_position.x;
+	back.gl_y = field.gl_position.y;
+	back.texture_x = field.texture_coords.x;
+	back.texture_y = field.texture_coords.y;
 	back.brightness = field.brightness;
 	back.texture_offset_x = texture_offset.x;
 	back.texture_offset_y = texture_offset.y;
@@ -98,7 +98,7 @@
 	}
 	const Widelands::TerrainDescription& other_terrain_description = terrains.get(other_terrain);
 	if (terrains.get(my_terrain).dither_layer() < other_terrain_description.dither_layer()) {
-		const FloatPoint texture_offset =
+		const Vector2f texture_offset =
 		   to_gl_texture(other_terrain_description.get_texture(gametime).blit_data()).origin();
 		add_vertex(fields_to_draw.at(idx1), TrianglePoint::kTopRight, texture_offset);
 		add_vertex(fields_to_draw.at(idx2), TrianglePoint::kTopLeft, texture_offset);
@@ -156,50 +156,49 @@
 		// The bottom right neighbor fields_to_draw is needed for both triangles
 		// associated with this field. If it is not in fields_to_draw, there is no need to
 		// draw any triangles.
-		const int brn_index = fields_to_draw.calculate_index(field.fx + (field.fy & 1), field.fy + 1);
-		if (brn_index == -1) {
+		if (field.brn_index == FieldsToDraw::kInvalidIndex) {
 			continue;
 		}
 
 		// Dithering triangles for Down triangle.
-		const int bln_index =
-		   fields_to_draw.calculate_index(field.fx + (field.fy & 1) - 1, field.fy + 1);
-		if (bln_index != -1) {
-			maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, brn_index, current_index,
-			                             bln_index, field.ter_d, field.ter_r);
-
-			const int terrain_dd = fields_to_draw.at(bln_index).ter_r;
-			maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, bln_index, brn_index,
-			                             current_index, field.ter_d, terrain_dd);
-
-			const int ln_index = fields_to_draw.calculate_index(field.fx - 1, field.fy);
-			if (ln_index != -1) {
-				const int terrain_l = fields_to_draw.at(ln_index).ter_r;
+		if (field.bln_index != FieldsToDraw::kInvalidIndex) {
+			maybe_add_dithering_triangle(
+			   gametime, terrains, fields_to_draw, field.brn_index, current_index, field.bln_index,
+			   field.fcoords.field->terrain_d(), field.fcoords.field->terrain_r());
+
+			const int terrain_dd = fields_to_draw.at(field.bln_index).fcoords.field->terrain_r();
+			maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, field.bln_index,
+			                             field.brn_index, current_index,
+			                             field.fcoords.field->terrain_d(), terrain_dd);
+
+			if (field.ln_index != FieldsToDraw::kInvalidIndex) {
+				const int terrain_l = fields_to_draw.at(field.ln_index).fcoords.field->terrain_r();
 				maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, current_index,
-				                             bln_index, brn_index, field.ter_d, terrain_l);
+				                             field.bln_index, field.brn_index,
+				                             field.fcoords.field->terrain_d(), terrain_l);
 			}
 		}
 
 		// Dithering for right triangle.
-		const int rn_index = fields_to_draw.calculate_index(field.fx + 1, field.fy);
-		if (rn_index != -1) {
-			maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, current_index, brn_index,
-			                             rn_index, field.ter_r, field.ter_d);
-			int terrain_rr = fields_to_draw.at(rn_index).ter_d;
-			maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, brn_index, rn_index,
-			                             current_index, field.ter_r, terrain_rr);
+		if (field.rn_index != FieldsToDraw::kInvalidIndex) {
+			maybe_add_dithering_triangle(
+			   gametime, terrains, fields_to_draw, current_index, field.brn_index, field.rn_index,
+			   field.fcoords.field->terrain_r(), field.fcoords.field->terrain_d());
+			int terrain_rr = fields_to_draw.at(field.rn_index).fcoords.field->terrain_d();
+			maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, field.brn_index,
+			                             field.rn_index, current_index,
+			                             field.fcoords.field->terrain_r(), terrain_rr);
 
-			const int trn_index =
-			   fields_to_draw.calculate_index(field.fx + (field.fy & 1), field.fy - 1);
-			if (trn_index != -1) {
-				const int terrain_u = fields_to_draw.at(trn_index).ter_d;
-				maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, rn_index,
-				                             current_index, brn_index, field.ter_r, terrain_u);
+			if (field.trn_index != FieldsToDraw::kInvalidIndex) {
+				const int terrain_u = fields_to_draw.at(field.trn_index).fcoords.field->terrain_d();
+				maybe_add_dithering_triangle(gametime, terrains, fields_to_draw, field.rn_index,
+				                             current_index, field.brn_index,
+				                             field.fcoords.field->terrain_r(), terrain_u);
 			}
 		}
 	}
 
 	const BlitData& blit_data = terrains.get(0).get_texture(0).blit_data();
-	const FloatRect texture_coordinates = to_gl_texture(blit_data);
+	const Rectf texture_coordinates = to_gl_texture(blit_data);
 	gl_draw(blit_data.texture_id, texture_coordinates.w, texture_coordinates.h, z_value);
 }

=== modified file 'src/graphic/gl/dither_program.h'
--- src/graphic/gl/dither_program.h	2016-01-08 21:00:39 +0000
+++ src/graphic/gl/dither_program.h	2016-10-24 20:07:47 +0000
@@ -22,7 +22,7 @@
 
 #include <memory>
 
-#include "base/point.h"
+#include "base/vector.h"
 #include "graphic/gl/fields_to_draw.h"
 #include "graphic/gl/utils.h"
 #include "logic/description_maintainer.h"
@@ -66,7 +66,7 @@
 	// this vertex.
 	void add_vertex(const FieldsToDraw::Field& field,
 	                TrianglePoint triangle_point,
-	                const FloatPoint& texture_offset);
+	                const Vector2f& texture_offset);
 
 	struct PerVertexData {
 		float gl_x;

=== modified file 'src/graphic/gl/draw_line_program.h'
--- src/graphic/gl/draw_line_program.h	2016-02-02 09:02:53 +0000
+++ src/graphic/gl/draw_line_program.h	2016-10-24 20:07:47 +0000
@@ -22,8 +22,8 @@
 
 #include <vector>
 
-#include "base/point.h"
 #include "base/rect.h"
+#include "base/vector.h"
 #include "graphic/blend_mode.h"
 #include "graphic/color.h"
 #include "graphic/gl/utils.h"

=== modified file 'src/graphic/gl/fields_to_draw.h'
--- src/graphic/gl/fields_to_draw.h	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/fields_to_draw.h	2016-10-24 20:07:47 +0000
@@ -21,29 +21,64 @@
 #define WL_GRAPHIC_GL_FIELDS_TO_DRAW_H
 
 #include <cstddef>
+#include <limits>
 #include <string>
 #include <vector>
 
 #include <stdint.h>
 
+#include "base/vector.h"
 #include "logic/map_objects/tribes/road_textures.h"
+#include "logic/player.h"
+#include "logic/widelands.h"
+#include "logic/widelands_geometry.h"
 
 // Helper struct that contains the data needed for drawing all fields. All
 // methods are inlined for performance reasons.
 class FieldsToDraw {
 public:
+	static constexpr int kInvalidIndex = std::numeric_limits<int>::min();
+
 	struct Field {
-		int fx, fy;        // geometric coordinates (i.e. map coordinates that can be out of bounds).
-		float gl_x, gl_y;  // GL Position of this field.
-		float pixel_x, pixel_y;             // Pixel position relative to top left.
-		float texture_x, texture_y;         // Texture coordinates.
-		float brightness;                   // brightness of the pixel
-		uint8_t ter_r, ter_d;               // Texture index of the right and down triangle.
-		uint8_t roads;                      // Bitmask of roads to render, see logic/roadtype.h.
-		const RoadTextures* road_textures;  // Road Textures to use for drawing.
+		Widelands::Coords geometric_coords;  // geometric coordinates (i.e. map coordinates that can
+		                                     // be out of bounds).
+		Widelands::FCoords fcoords;  // The normalized coords and the field this is refering to.
+		Vector2f gl_position;        // GL Position of this field.
+
+		// Surface pixel this will be plotted on.
+		Vector2f surface_pixel;
+
+		// Rendertarget pixel this will be plotted on. This is only different by
+		// the Rendertarget::get_rect().origin() of the view window.
+		Vector2f rendertarget_pixel;
+		Vector2f texture_coords;  // Texture coordinates.
+		float brightness;         // brightness of the pixel
+
+		// The next values are not necessarily the true data of this field, but
+		// what the player should see. For example in fog of war we always draw
+		// what we saw last.
+		uint8_t roads;  // Bitmask of roads to render, see logic/roadtype.h.
+		bool is_border;
+		Widelands::Vision vision;
+		Widelands::Player* owner;  // can be nullptr.
+
+		// Index of neighbors in this 'FieldsToDraw'. kInvalidIndex if this
+		// neighbor is not contained.
+		int ln_index;
+		int rn_index;
+		int trn_index;
+		int bln_index;
+		int brn_index;
+
+		inline bool all_neighbors_valid() const {
+			return ln_index != kInvalidIndex && rn_index != kInvalidIndex &&
+			       trn_index != kInvalidIndex && bln_index != kInvalidIndex &&
+			       brn_index != kInvalidIndex;
+		}
 	};
 
-	FieldsToDraw() = default;
+	FieldsToDraw() {
+	}
 
 	// Resize this fields to draw for reuse.
 	void reset(int minfx, int maxfx, int minfy, int maxfy) {
@@ -60,15 +95,16 @@
 	}
 
 	// Calculates the index of the given field with ('fx', 'fy') being geometric
-	// coordinates in the map. Returns -1 if this field is not in the fields_to_draw.
+	// coordinates in the map. Returns kInvalidIndex if this field is not in the
+	// fields_to_draw.
 	inline int calculate_index(int fx, int fy) const {
 		uint16_t xidx = fx - min_fx_;
 		if (xidx >= w_) {
-			return -1;
+			return kInvalidIndex;
 		}
 		uint16_t yidx = fy - min_fy_;
 		if (yidx >= h_) {
-			return -1;
+			return kInvalidIndex;
 		}
 		return yidx * w_ + xidx;
 	}

=== modified file 'src/graphic/gl/fill_rect_program.cc'
--- src/graphic/gl/fill_rect_program.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/fill_rect_program.cc	2016-10-24 20:07:47 +0000
@@ -37,7 +37,7 @@
 	attr_color_ = glGetAttribLocation(gl_program_.object(), "attr_color");
 }
 
-void FillRectProgram::draw(const FloatRect& destination_rect,
+void FillRectProgram::draw(const Rectf& destination_rect,
                            const float z_value,
                            const RGBAColor& color,
                            const BlendMode blend_mode) {

=== modified file 'src/graphic/gl/fill_rect_program.h'
--- src/graphic/gl/fill_rect_program.h	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/fill_rect_program.h	2016-10-24 20:07:47 +0000
@@ -30,7 +30,7 @@
 class FillRectProgram {
 public:
 	struct Arguments {
-		FloatRect destination_rect;
+		Rectf destination_rect;
 		float z_value;
 		RGBAColor color;
 		BlendMode blend_mode;
@@ -41,7 +41,7 @@
 
 	// Fills a solid rect in 'color'. If blend_mode is BlendMode::UseAlpha, this
 	// will brighten the rect, if it is BlendMode::Subtract it darkens it.
-	void draw(const FloatRect& destination_rect,
+	void draw(const Rectf& destination_rect,
 	          float z_value,
 	          const RGBAColor& color,
 	          BlendMode blend_mode);

=== modified file 'src/graphic/gl/road_program.cc'
--- src/graphic/gl/road_program.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/road_program.cc	2016-10-24 20:07:47 +0000
@@ -50,6 +50,7 @@
                            const int renderbuffer_height,
                            const FieldsToDraw::Field& start,
                            const FieldsToDraw::Field& end,
+                           const float scale,
                            const Widelands::RoadType road_type,
                            const Direction direction,
                            uint32_t* gl_texture) {
@@ -59,8 +60,8 @@
 	// The overshot of the road in either direction in percent.
 	static constexpr float kRoadElongationInPercent = .1;
 
-	const float delta_x = end.pixel_x - start.pixel_x;
-	const float delta_y = end.pixel_y - start.pixel_y;
+	const float delta_x = end.surface_pixel.x - start.surface_pixel.x;
+	const float delta_y = end.surface_pixel.y - start.surface_pixel.y;
 	const float vector_length = std::hypot(delta_x, delta_y);
 
 	const float road_overshoot_x = delta_x * kRoadElongationInPercent;
@@ -68,13 +69,15 @@
 
 	// Find the reciprocal unit vector, so that we can calculate start and end
 	// points for the quad that will make the road.
-	const float road_thickness_x = (-delta_y / vector_length) * kRoadThicknessInPixels;
-	const float road_thickness_y = (delta_x / vector_length) * kRoadThicknessInPixels;
+	const float road_thickness_x = (-delta_y / vector_length) * kRoadThicknessInPixels * scale;
+	const float road_thickness_y = (delta_x / vector_length) * kRoadThicknessInPixels * scale;
 
+	assert(start.owner != nullptr);
 	const Image& texture =
 	   road_type == Widelands::RoadType::kNormal ?
-	      start.road_textures->get_normal_texture(start.fx, start.fy, direction) :
-	      start.road_textures->get_busy_texture(start.fx, start.fy, direction);
+	      start.owner->tribe().road_textures().get_normal_texture(
+	         start.geometric_coords, direction) :
+	      start.owner->tribe().road_textures().get_busy_texture(start.geometric_coords, direction);
 	if (*gl_texture == 0) {
 		*gl_texture = texture.blit_data().texture_id;
 	}
@@ -82,27 +85,27 @@
 	// one texture atlas.
 	assert(*gl_texture == texture.blit_data().texture_id);
 
-	const FloatRect texture_rect = to_gl_texture(texture.blit_data());
+	const Rectf texture_rect = to_gl_texture(texture.blit_data());
 
 	vertices_.emplace_back(PerVertexData{
-	   start.pixel_x - road_overshoot_x + road_thickness_x,
-	   start.pixel_y - road_overshoot_y + road_thickness_y, texture_rect.x, texture_rect.y,
+	   start.surface_pixel.x - road_overshoot_x + road_thickness_x,
+	   start.surface_pixel.y - road_overshoot_y + road_thickness_y, texture_rect.x, texture_rect.y,
 	   start.brightness,
 	});
 	pixel_to_gl_renderbuffer(
 	   renderbuffer_width, renderbuffer_height, &vertices_.back().gl_x, &vertices_.back().gl_y);
 
 	vertices_.emplace_back(PerVertexData{
-	   start.pixel_x - road_overshoot_x - road_thickness_x,
-	   start.pixel_y - road_overshoot_y - road_thickness_y, texture_rect.x,
+	   start.surface_pixel.x - road_overshoot_x - road_thickness_x,
+	   start.surface_pixel.y - road_overshoot_y - road_thickness_y, texture_rect.x,
 	   texture_rect.y + texture_rect.h, start.brightness,
 	});
 	pixel_to_gl_renderbuffer(
 	   renderbuffer_width, renderbuffer_height, &vertices_.back().gl_x, &vertices_.back().gl_y);
 
 	vertices_.emplace_back(PerVertexData{
-	   end.pixel_x + road_overshoot_x + road_thickness_x,
-	   end.pixel_y + road_overshoot_y + road_thickness_y, texture_rect.x + texture_rect.w,
+	   end.surface_pixel.x + road_overshoot_x + road_thickness_x,
+	   end.surface_pixel.y + road_overshoot_y + road_thickness_y, texture_rect.x + texture_rect.w,
 	   texture_rect.y, end.brightness,
 	});
 	pixel_to_gl_renderbuffer(
@@ -116,8 +119,8 @@
 	vertices_.emplace_back(vertices_.at(vertices_.size() - 2));
 
 	vertices_.emplace_back(PerVertexData{
-	   end.pixel_x + road_overshoot_x - road_thickness_x,
-	   end.pixel_y + road_overshoot_y - road_thickness_y, texture_rect.x + texture_rect.w,
+	   end.surface_pixel.x + road_overshoot_x - road_thickness_x,
+	   end.surface_pixel.y + road_overshoot_y - road_thickness_y, texture_rect.x + texture_rect.w,
 	   texture_rect.y + texture_rect.h, end.brightness,
 	});
 	pixel_to_gl_renderbuffer(
@@ -127,7 +130,8 @@
 void RoadProgram::draw(const int renderbuffer_width,
                        const int renderbuffer_height,
                        const FieldsToDraw& fields_to_draw,
-                       float z_value) {
+                       const float scale,
+                       const float z_value) {
 	vertices_.clear();
 
 	uint32_t gl_texture = 0;
@@ -135,36 +139,32 @@
 		const FieldsToDraw::Field& field = fields_to_draw.at(current_index);
 
 		// Road to right neighbor.
-		const int rn_index = fields_to_draw.calculate_index(field.fx + 1, field.fy);
-		if (rn_index != -1) {
+		if (field.rn_index != FieldsToDraw::kInvalidIndex) {
 			const Widelands::RoadType road =
 			   static_cast<Widelands::RoadType>(field.roads & Widelands::RoadType::kMask);
 			if (road != Widelands::RoadType::kNone) {
-				add_road(renderbuffer_width, renderbuffer_height, field, fields_to_draw.at(rn_index),
-				         road, kEast, &gl_texture);
+				add_road(renderbuffer_width, renderbuffer_height, field,
+				         fields_to_draw.at(field.rn_index), scale, road, kEast, &gl_texture);
 			}
 		}
 
 		// Road to bottom right neighbor.
-		const int brn_index = fields_to_draw.calculate_index(field.fx + (field.fy & 1), field.fy + 1);
-		if (brn_index != -1) {
+		if (field.brn_index != FieldsToDraw::kInvalidIndex) {
 			const Widelands::RoadType road =
 			   static_cast<Widelands::RoadType>((field.roads >> 2) & Widelands::RoadType::kMask);
 			if (road != Widelands::RoadType::kNone) {
-				add_road(renderbuffer_width, renderbuffer_height, field, fields_to_draw.at(brn_index),
-				         road, kSouthEast, &gl_texture);
+				add_road(renderbuffer_width, renderbuffer_height, field,
+				         fields_to_draw.at(field.brn_index), scale, road, kSouthEast, &gl_texture);
 			}
 		}
 
 		// Road to bottom right neighbor.
-		const int bln_index =
-		   fields_to_draw.calculate_index(field.fx + (field.fy & 1) - 1, field.fy + 1);
-		if (bln_index != -1) {
+		if (field.bln_index != FieldsToDraw::kInvalidIndex) {
 			const Widelands::RoadType road =
 			   static_cast<Widelands::RoadType>((field.roads >> 4) & Widelands::RoadType::kMask);
 			if (road != Widelands::RoadType::kNone) {
-				add_road(renderbuffer_width, renderbuffer_height, field, fields_to_draw.at(bln_index),
-				         road, kSouthWest, &gl_texture);
+				add_road(renderbuffer_width, renderbuffer_height, field,
+				         fields_to_draw.at(field.bln_index), scale, road, kSouthWest, &gl_texture);
 			}
 		}
 	}

=== modified file 'src/graphic/gl/road_program.h'
--- src/graphic/gl/road_program.h	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/road_program.h	2016-10-24 20:07:47 +0000
@@ -42,6 +42,7 @@
 	void draw(int renderbuffer_width,
 	          int renderbuffer_height,
 	          const FieldsToDraw& fields_to_draw,
+				 float scale,
 	          float z_value);
 
 private:
@@ -61,6 +62,7 @@
 	              int renderbuffer_height,
 	              const FieldsToDraw::Field& start,
 	              const FieldsToDraw::Field& end,
+					  float scale,
 	              const Widelands::RoadType road_type,
 	              const Direction direction,
 	              uint32_t* gl_texture);

=== modified file 'src/graphic/gl/terrain_program.cc'
--- src/graphic/gl/terrain_program.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/terrain_program.cc	2016-10-24 20:07:47 +0000
@@ -71,15 +71,15 @@
 }
 
 void TerrainProgram::add_vertex(const FieldsToDraw::Field& field,
-                                const FloatPoint& texture_offset) {
+                                const Vector2f& texture_offset) {
 	vertices_.emplace_back();
 	PerVertexData& back = vertices_.back();
 
-	back.gl_x = field.gl_x;
-	back.gl_y = field.gl_y;
+	back.gl_x = field.gl_position.x;
+	back.gl_y = field.gl_position.y;
 	back.brightness = field.brightness;
-	back.texture_x = field.texture_x;
-	back.texture_y = field.texture_y;
+	back.texture_x = field.texture_coords.x;
+	back.texture_y = field.texture_coords.y;
 	back.texture_offset_x = texture_offset.x;
 	back.texture_offset_y = texture_offset.y;
 }
@@ -101,34 +101,34 @@
 		// The bottom right neighbor fields_to_draw is needed for both triangles
 		// associated with this field. If it is not in fields_to_draw, there is no need to
 		// draw any triangles.
-		const int brn_index = fields_to_draw.calculate_index(field.fx + (field.fy & 1), field.fy + 1);
-		if (brn_index == -1) {
+		if (field.brn_index == FieldsToDraw::kInvalidIndex) {
 			continue;
 		}
 
 		// Down triangle.
-		const int bln_index =
-		   fields_to_draw.calculate_index(field.fx + (field.fy & 1) - 1, field.fy + 1);
-		if (bln_index != -1) {
-			const FloatPoint texture_offset =
-			   to_gl_texture(terrains.get(field.ter_d).get_texture(gametime).blit_data()).origin();
+		if (field.bln_index != FieldsToDraw::kInvalidIndex) {
+			const Vector2f texture_offset =
+			   to_gl_texture(
+			      terrains.get(field.fcoords.field->terrain_d()).get_texture(gametime).blit_data())
+			      .origin();
 			add_vertex(fields_to_draw.at(current_index), texture_offset);
-			add_vertex(fields_to_draw.at(bln_index), texture_offset);
-			add_vertex(fields_to_draw.at(brn_index), texture_offset);
+			add_vertex(fields_to_draw.at(field.bln_index), texture_offset);
+			add_vertex(fields_to_draw.at(field.brn_index), texture_offset);
 		}
 
 		// Right triangle.
-		const int rn_index = fields_to_draw.calculate_index(field.fx + 1, field.fy);
-		if (rn_index != -1) {
-			const FloatPoint texture_offset =
-			   to_gl_texture(terrains.get(field.ter_r).get_texture(gametime).blit_data()).origin();
+		if (field.rn_index != FieldsToDraw::kInvalidIndex) {
+			const Vector2f texture_offset =
+			   to_gl_texture(
+			      terrains.get(field.fcoords.field->terrain_r()).get_texture(gametime).blit_data())
+			      .origin();
 			add_vertex(fields_to_draw.at(current_index), texture_offset);
-			add_vertex(fields_to_draw.at(brn_index), texture_offset);
-			add_vertex(fields_to_draw.at(rn_index), texture_offset);
+			add_vertex(fields_to_draw.at(field.brn_index), texture_offset);
+			add_vertex(fields_to_draw.at(field.rn_index), texture_offset);
 		}
 	}
 
 	const BlitData& blit_data = terrains.get(0).get_texture(0).blit_data();
-	const FloatRect texture_coordinates = to_gl_texture(blit_data);
+	const Rectf texture_coordinates = to_gl_texture(blit_data);
 	gl_draw(blit_data.texture_id, texture_coordinates.w, texture_coordinates.h, z_value);
 }

=== modified file 'src/graphic/gl/terrain_program.h'
--- src/graphic/gl/terrain_program.h	2016-08-04 15:49:05 +0000
+++ src/graphic/gl/terrain_program.h	2016-10-24 20:07:47 +0000
@@ -22,7 +22,7 @@
 
 #include <vector>
 
-#include "base/point.h"
+#include "base/vector.h"
 #include "graphic/gl/fields_to_draw.h"
 #include "graphic/gl/utils.h"
 #include "logic/description_maintainer.h"
@@ -54,7 +54,7 @@
 	void gl_draw(int gl_texture, float texture_w, float texture_h, float z_value);
 
 	// Adds a vertex to the end of vertices with data from 'field' and 'texture_coordinates'.
-	void add_vertex(const FieldsToDraw::Field& field, const FloatPoint& texture_coordinates);
+	void add_vertex(const FieldsToDraw::Field& field, const Vector2f& texture_coordinates);
 
 	// The program used for drawing the terrain.
 	Gl::Program gl_program_;

=== modified file 'src/graphic/minimap_renderer.cc'
--- src/graphic/minimap_renderer.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/minimap_renderer.cc	2016-10-24 20:07:47 +0000
@@ -25,13 +25,9 @@
 #include "economy/flag.h"
 #include "economy/road.h"
 #include "graphic/graphic.h"
-#include "graphic/image_io.h"
-#include "graphic/texture.h"
 #include "logic/field.h"
-#include "logic/map.h"
 #include "logic/map_objects/world/terrain_description.h"
 #include "logic/map_objects/world/world.h"
-#include "logic/player.h"
 #include "wui/mapviewpixelconstants.h"
 #include "wui/mapviewpixelfunctions.h"
 
@@ -40,12 +36,17 @@
 namespace {
 
 const RGBColor kWhite(255, 255, 255);
+const RGBColor kRed(255, 0, 0);
 
 // Blend two colors.
 inline RGBColor blend_color(const RGBColor& c1, const RGBColor& c2) {
 	return RGBColor((c1.r + c2.r) / 2, (c1.g + c2.g) / 2, (c1.b + c2.b) / 2);
 }
 
+int round_up_to_nearest_even(int number) {
+	return number % 2 == 0 ? number : number + 1;
+}
+
 // Returns the color to be used in the minimap for the given field.
 inline RGBColor calc_minimap_color(const Widelands::EditorGameBase& egbase,
                                    const Widelands::FCoords& f,
@@ -85,83 +86,83 @@
 	return color;
 }
 
-// Draws the dotted frame border onto the minimap.
-bool is_minimap_frameborder(const Widelands::FCoords& f,
-                            const Point& ptopleft,
-                            const Point& pbottomright,
-                            int32_t mapwidth,
-                            int32_t mapheight,
-                            int32_t modx,
-                            int32_t mody) {
-	bool isframepixel = false;
-
-	if (ptopleft.x <= pbottomright.x) {
-		if (f.x >= ptopleft.x && f.x <= pbottomright.x &&
-		    (f.y == ptopleft.y || f.y == pbottomright.y) && f.x % 2 == modx)
-			isframepixel = true;
-	} else {
-		if (((f.x >= ptopleft.x && f.x <= mapwidth) || (f.x >= 0 && f.x <= pbottomright.x)) &&
-		    (f.y == ptopleft.y || f.y == pbottomright.y) && (f.x % 2) == modx)
-			isframepixel = true;
-	}
-
-	if (ptopleft.y <= pbottomright.y) {
-		if (f.y >= ptopleft.y && f.y <= pbottomright.y &&
-		    (f.x == ptopleft.x || f.x == pbottomright.x) && f.y % 2 == mody)
-			isframepixel = true;
-	} else {
-		if (((f.y >= ptopleft.y && f.y <= mapheight) || (f.y >= 0 && f.y <= pbottomright.y)) &&
-		    (f.x == ptopleft.x || f.x == pbottomright.x) && f.y % 2 == mody)
-			isframepixel = true;
-	}
-
-	return isframepixel;
+void draw_view_window(const Map& map,
+                      const Rectf& view_area,
+                      const MiniMapType minimap_type,
+                      const bool zoom,
+                      Texture* texture) {
+	const float divider = zoom ? 1.f : 2.f;
+	const int half_width =
+	   round_up_to_nearest_even(std::ceil(view_area.w / kTriangleWidth / divider));
+	const int half_height =
+	   round_up_to_nearest_even(std::ceil(view_area.h / kTriangleHeight / divider));
+
+	Vector2i center_pixel;
+	switch (minimap_type) {
+	case MiniMapType::kStaticViewWindow:
+		center_pixel = Vector2i(texture->width() / 2, texture->height() / 2);
+		break;
+
+	case MiniMapType::kStaticMap: {
+		Vector2f origin = view_area.center();
+		MapviewPixelFunctions::normalize_pix(map, &origin);
+		center_pixel =
+		   Vector2i(origin.x / kTriangleWidth, origin.y / kTriangleHeight) * (zoom ? 2 : 1);
+		break;
+	}
+	}
+
+	const int width = zoom ? map.get_width() * 2 : map.get_width();
+	const int height = zoom ? map.get_height() * 2 : map.get_height();
+	const auto make_red = [width, height, &texture](int x, int y) {
+		if (x < 0) {
+			x += width;
+		}
+		if (x >= width) {
+			x -= width;
+		}
+		if (y < 0) {
+			y += height;
+		}
+		if (y >= height) {
+			y -= height;
+		}
+		texture->set_pixel(x, y, kRed);
+	};
+
+	bool draw = true;
+	for (int y = -half_height; y <= half_height; ++y) {
+		if (draw) {
+			make_red(-half_width + center_pixel.x, y + center_pixel.y);
+			make_red(half_width + center_pixel.x, y + center_pixel.y);
+		}
+		draw = !draw;
+	}
+
+	draw = true;
+	for (int x = -half_width; x <= half_width; ++x) {
+		if (draw) {
+			make_red(x + center_pixel.x, -half_height + center_pixel.y);
+			make_red(x + center_pixel.x, half_height + center_pixel.y);
+		}
+		draw = !draw;
+	}
 }
 
 // Does the actual work of drawing the minimap.
-void draw_minimap_int(Texture* texture,
-                      const Widelands::EditorGameBase& egbase,
-                      const Widelands::Player* player,
-                      const Point& viewpoint,
-                      MiniMapLayer layers) {
+void do_draw_minimap(Texture* texture,
+                     const Widelands::EditorGameBase& egbase,
+                     const Widelands::Player* player,
+                     const Vector2i& top_left,
+                     MiniMapLayer layers) {
 	const Widelands::Map& map = egbase.map();
-
 	const uint16_t surface_h = texture->height();
 	const uint16_t surface_w = texture->width();
-
-	// size of the display frame
-	int32_t xsize = g_gr->get_xres() / kTriangleWidth / 2;
-	int32_t ysize = g_gr->get_yres() / kTriangleHeight / 2;
-
 	const int32_t mapwidth = egbase.get_map().get_width();
-	const int32_t mapheight = map.get_height();
-
-	Point ptopleft;  // top left point of the current display frame
-	ptopleft.x = viewpoint.x + mapwidth / 2 - xsize;
-	if (ptopleft.x < 0) {
-		ptopleft.x += mapwidth;
-	}
-	ptopleft.y = viewpoint.y + mapheight / 2 - ysize;
-	if (ptopleft.y < 0) {
-		ptopleft.y += mapheight;
-	}
-
-	Point pbottomright;  // bottom right point of the current display frame
-	pbottomright.x = viewpoint.x + mapwidth / 2 + xsize;
-	if (pbottomright.x >= mapwidth) {
-		pbottomright.x -= mapwidth;
-	}
-	pbottomright.y = viewpoint.y + mapheight / 2 + ysize;
-	if (pbottomright.y >= mapheight) {
-		pbottomright.y -= mapheight;
-	}
-
-	uint32_t modx = pbottomright.x % 2;
-	uint32_t mody = pbottomright.y % 2;
 
 	for (uint32_t y = 0; y < surface_h; ++y) {
 		Widelands::FCoords f(
-		   Widelands::Coords(viewpoint.x, viewpoint.y + (layers & MiniMapLayer::Zoom2 ? y / 2 : y)));
+		   Widelands::Coords(top_left.x, top_left.y + (layers & MiniMapLayer::Zoom2 ? y / 2 : y)));
 		map.normalize_coords(f);
 		f.field = &map[f];
 		Widelands::MapIndex i = Widelands::Map::get_index(f, mapwidth);
@@ -170,30 +171,26 @@
 				move_r(mapwidth, f, i);
 			}
 
-			RGBColor pixel_color;
-			if ((layers & MiniMapLayer::ViewWindow) &&
-			    is_minimap_frameborder(f, ptopleft, pbottomright, mapwidth, mapheight, modx, mody)) {
-				pixel_color = RGBColor(255, 0, 0);
-			} else {
-				uint16_t vision =
-				   0;  // See Player::Field::Vision: 1 if seen once, > 1 if seen right now.
-				Widelands::PlayerNumber owner = 0;
-				if (player == nullptr || player->see_all()) {
-					vision = 2;  // Seen right now.
-					owner = f.field->get_owned_by();
-				} else if (player != nullptr) {
-					const auto& field = player->fields()[i];
-					vision = field.vision;
-					owner = field.owner;
-				}
-
-				if (vision > 0) {
-					pixel_color = calc_minimap_color(egbase, f, layers, owner, vision > 1);
-				}
+			uint16_t vision = 0;  // See Player::Field::Vision: 1 if seen once, > 1 if seen right now.
+			Widelands::PlayerNumber owner = 0;
+			if (player == nullptr || player->see_all()) {
+				// This player has omnivision - show the field like it is in reality.
+				vision = 2;  // Seen right now.
+				owner = f.field->get_owned_by();
+			} else if (player != nullptr) {
+				// This player might be affected by fog of war - instead of the
+				// reality, we show her what she last saw on this field. If she has
+				// vision of this field, this will be the same as reality -
+				// otherwise this shows reality as it was the last time she had
+				// vision on the field.
+				// If she never had vision, field.vision will be 0.
+				const auto& field = player->fields()[i];
+				vision = field.vision;
+				owner = field.owner;
 			}
 
-			if (pixel_color.r != 0 || pixel_color.g != 0 || pixel_color.b != 0) {
-				texture->set_pixel(x, y, pixel_color);
+			if (vision > 0) {
+				texture->set_pixel(x, y, calc_minimap_color(egbase, f, layers, owner, vision > 1));
 			}
 		}
 	}
@@ -201,12 +198,38 @@
 
 }  // namespace
 
+Vector2f minimap_pixel_to_mappixel(const Widelands::Map& map,
+                                   const Vector2i& minimap_pixel,
+                                   const Rectf& view_area,
+                                   MiniMapType minimap_type,
+                                   const bool zoom) {
+	Vector2f top_left;
+	switch (minimap_type) {
+	case MiniMapType::kStaticViewWindow:
+		top_left =
+		   view_area.center() -
+		   Vector2f(map.get_width() * kTriangleWidth, map.get_height() * kTriangleHeight) / 2.f;
+		break;
+
+	case MiniMapType::kStaticMap:
+		top_left = Vector2f(0., 0.);
+		break;
+	}
+
+	const float multiplier = zoom ? 2.f : 1.f;
+	Vector2f map_pixel = top_left + Vector2f(minimap_pixel.x / multiplier * kTriangleWidth,
+	                                         minimap_pixel.y / multiplier * kTriangleHeight);
+	MapviewPixelFunctions::normalize_pix(map, &map_pixel);
+	return map_pixel;
+}
+
 std::unique_ptr<Texture> draw_minimap(const EditorGameBase& egbase,
                                       const Player* player,
-                                      const Point& viewpoint,
+                                      const Rectf& view_area,
+                                      const MiniMapType& minimap_type,
                                       MiniMapLayer layers) {
-	// TODO(unknown): Currently the minimap is redrawn every frame. That is not really
-	//       necesary. The created texture could be cached and only redrawn two
+	// TODO(sirver): Currently the minimap is redrawn every frame. That is not really
+	//       necessary. The created texture could be cached and only redrawn two
 	//       or three times per second
 	const Map& map = egbase.map();
 	const int16_t map_w = (layers & MiniMapLayer::Zoom2) ? map.get_width() * 2 : map.get_width();
@@ -214,44 +237,22 @@
 
 	std::unique_ptr<Texture> texture(new Texture(map_w, map_h));
 
-	texture->fill_rect(Rect(0, 0, texture->width(), texture->height()), RGBAColor(0, 0, 0, 255));
+	texture->fill_rect(Rectf(0, 0, texture->width(), texture->height()), RGBAColor(0, 0, 0, 255));
+
+	// Center the view on the middle of the 'view_area'.
+	const bool zoom = layers & MiniMapLayer::Zoom2;
+	Vector2f top_left =
+	   minimap_pixel_to_mappixel(map, Vector2i(0, 0), view_area, minimap_type, zoom);
+	const Coords node =
+	   MapviewPixelFunctions::calc_node_and_triangle(map, top_left.x, top_left.y).node;
 
 	texture->lock();
-	draw_minimap_int(texture.get(), egbase, player, viewpoint, layers);
+	do_draw_minimap(texture.get(), egbase, player, Vector2i(node.x, node.y), layers);
+
+	if (layers & MiniMapLayer::ViewWindow) {
+		draw_view_window(map, view_area, minimap_type, zoom, texture.get());
+	}
 	texture->unlock(Texture::Unlock_Update);
 
 	return texture;
 }
-
-void write_minimap_image(const EditorGameBase& egbase,
-                         const Player* player,
-                         const Point& gviewpoint,
-                         MiniMapLayer layers,
-                         ::StreamWrite* const streamwrite) {
-	assert(streamwrite != nullptr);
-
-	Point viewpoint(gviewpoint);
-
-	// map dimension
-	const int16_t map_w = egbase.get_map().get_width();
-	const int16_t map_h = egbase.get_map().get_height();
-	const int32_t maxx = MapviewPixelFunctions::get_map_end_screen_x(egbase.get_map());
-	const int32_t maxy = MapviewPixelFunctions::get_map_end_screen_y(egbase.get_map());
-	// adjust the viewpoint top topleft in map coords
-	viewpoint.x += g_gr->get_xres() / 2;
-	if (viewpoint.x >= maxx) {
-		viewpoint.x -= maxx;
-	}
-	viewpoint.y += g_gr->get_yres() / 2;
-	if (viewpoint.y >= maxy) {
-		viewpoint.y -= maxy;
-	}
-	viewpoint.x /= kTriangleWidth;
-	viewpoint.y /= kTriangleHeight;
-	viewpoint.x -= map_w / 2;
-	viewpoint.y -= map_h / 2;
-
-	// Render minimap
-	std::unique_ptr<Texture> texture(draw_minimap(egbase, player, viewpoint, layers));
-	save_to_png(texture.get(), streamwrite, ColorType::RGBA);
-}

=== modified file 'src/graphic/minimap_renderer.h'
--- src/graphic/minimap_renderer.h	2016-08-04 15:49:05 +0000
+++ src/graphic/minimap_renderer.h	2016-10-24 20:07:47 +0000
@@ -22,15 +22,12 @@
 
 #include <memory>
 
-#include "base/point.h"
-
-class StreamWrite;
-class Texture;
-
-namespace Widelands {
-class Player;
-class EditorGameBase;
-}
+#include "base/rect.h"
+#include "base/vector.h"
+#include "graphic/texture.h"
+#include "logic/editor_game_base.h"
+#include "logic/map.h"
+#include "logic/player.h"
 
 // Layers for selecting what do display on the minimap.
 enum class MiniMapLayer {
@@ -54,20 +51,31 @@
 	return MiniMapLayer(static_cast<int>(left) ^ static_cast<int>(right));
 }
 
-/// Render the minimap. If player is not nullptr, it renders from that player's
-/// point of view.
-/// \param viewpoint top left corner in map coordinates
+enum class MiniMapType {
+	// Keep the view window always in the center of the minimap and pan the underlying map.
+	kStaticViewWindow,
+
+	// Always align the map at (0, 0) and move the view window instead.
+	kStaticMap,
+};
+
+// Converts between minimap pixel and map pixel.
+// Remember to call 'normalize_pix' after applying the transformation.
+Vector2f minimap_pixel_to_mappixel(const Widelands::Map& map,
+                                   const Vector2i& minimap_pixel,
+                                   const Rectf& view_area,
+                                   MiniMapType minimap_type,
+                                   const bool zoom);
+
+// Render the minimap. If player is not nullptr, it renders from that player's
+// point of view. The 'view_area' designates the currently visible area in the
+// main view in map pixel coordinates and is used to draw the wire frame view
+// window. The 'view_point' is map pixel that will be drawn as the top-left
+// point in the resulting minimap.
 std::unique_ptr<Texture> draw_minimap(const Widelands::EditorGameBase& egbase,
                                       const Widelands::Player* player,
-                                      const Point& viewpoint,
+                                      const Rectf& view_area,
+                                      const MiniMapType& map_draw_type,
                                       MiniMapLayer layers);
 
-/// Render the minimap to a file. 1 pixel will be used for each fields.
-/// \param viewpoint : The game point of view as returned by interactive_base.get_viewpoint();
-void write_minimap_image(const Widelands::EditorGameBase& egbase,
-                         Widelands::Player const* player,
-                         const Point& viewpoint,
-                         MiniMapLayer layers,
-                         StreamWrite* const streamwrite);
-
 #endif  // end of include guard: WL_GRAPHIC_MINIMAP_RENDERER_H

=== modified file 'src/graphic/render_queue.cc'
--- src/graphic/render_queue.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/render_queue.cc	2016-10-24 20:07:47 +0000
@@ -120,14 +120,14 @@
 // creation. Disables GL_SCISSOR_TEST at desctruction again.
 class ScopedScissor {
 public:
-	ScopedScissor(const FloatRect& rect);
+	ScopedScissor(const Rectf& rect);
 	~ScopedScissor();
 
 private:
 	DISALLOW_COPY_AND_ASSIGN(ScopedScissor);
 };
 
-ScopedScissor::ScopedScissor(const FloatRect& rect) {
+ScopedScissor::ScopedScissor(const Rectf& rect) {
 	glScissor(rect.x, rect.y, rect.w, rect.h);
 	glEnable(GL_SCISSOR_TEST);
 }
@@ -249,9 +249,10 @@
 
 		case Program::kTerrainRoad: {
 			ScopedScissor scoped_scissor(item.terrain_arguments.destination_rect);
-			road_program_->draw(
-			   item.terrain_arguments.renderbuffer_width, item.terrain_arguments.renderbuffer_height,
-			   *item.terrain_arguments.fields_to_draw, item.z_value + 2 * kOpenGlZDelta);
+			road_program_->draw(item.terrain_arguments.renderbuffer_width,
+			                    item.terrain_arguments.renderbuffer_height,
+			                    *item.terrain_arguments.fields_to_draw, item.terrain_arguments.scale,
+			                    item.z_value + 2 * kOpenGlZDelta);
 			++i;
 		} break;
 

=== modified file 'src/graphic/render_queue.h'
--- src/graphic/render_queue.h	2016-08-04 15:49:05 +0000
+++ src/graphic/render_queue.h	2016-10-24 20:07:47 +0000
@@ -99,12 +99,12 @@
 		BlitData texture;
 		BlitData mask;
 		RGBAColor blend;
-		FloatRect destination_rect;
+		Rectf destination_rect;
 	};
 
 	struct RectArguments {
 		RGBAColor color;
-		FloatRect destination_rect;
+		Rectf destination_rect;
 	};
 
 	// TODO(sirver): these are really triangle arguments.
@@ -121,7 +121,8 @@
 		int renderbuffer_height;
 		const DescriptionMaintainer<Widelands::TerrainDescription>* terrains;
 		FieldsToDraw* fields_to_draw;
-		FloatRect destination_rect;
+		float scale;
+		Rectf destination_rect;
 	};
 
 	// The union of all possible program arguments represents an Item that is

=== modified file 'src/graphic/rendertarget.cc'
--- src/graphic/rendertarget.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/rendertarget.cc	2016-10-24 20:07:47 +0000
@@ -35,7 +35,7 @@
 /**
  * Sets an arbitrary drawing window.
  */
-void RenderTarget::set_window(const Rect& rc, const Point& ofs) {
+void RenderTarget::set_window(const Recti& rc, const Vector2i& ofs) {
 	rect_ = rc;
 	offset_ = ofs;
 
@@ -69,15 +69,15 @@
  * Returns false if the subwindow is invisible. In that case, the window state
  * is not changed at all. Otherwise, the function returns true.
  */
-bool RenderTarget::enter_window(const Rect& rc, Rect* previous, Point* prevofs) {
-	Rect newrect = rc;
-
-	if (clip(newrect)) {
+bool RenderTarget::enter_window(const Recti& rc, Recti* previous, Vector2i* prevofs) {
+	Rectf newrect_f = rc.cast<float>();
+	if (clip(newrect_f)) {
 		if (previous)
 			*previous = rect_;
 		if (prevofs)
 			*prevofs = offset_;
 
+		const Recti newrect = newrect_f.cast<int>();
 		// Apply the changes
 		offset_ = rc.origin() - (newrect.origin() - rect_.origin() - offset_);
 		rect_ = newrect;
@@ -104,10 +104,10 @@
 /**
  * This functions draws a line in the target
  */
-void RenderTarget::draw_line_strip(const std::vector<FloatPoint>& points,
+void RenderTarget::draw_line_strip(const std::vector<Vector2f>& points,
                                    const RGBColor& color,
                                    float line_width) {
-	std::vector<FloatPoint> adjusted_points;
+	std::vector<Vector2f> adjusted_points;
 	adjusted_points.reserve(points.size());
 	for (const auto& p : points) {
 		adjusted_points.emplace_back(p.x + offset_.x + rect_.x, p.y + offset_.y + rect_.y);
@@ -118,21 +118,21 @@
 /**
  * Clip against window and pass those primitives along to the bitmap.
  */
-void RenderTarget::draw_rect(const Rect& rect, const RGBColor& clr) {
-	Rect r(rect);
+void RenderTarget::draw_rect(const Rectf& rect, const RGBColor& clr) {
+	Rectf r(rect);
 	if (clip(r)) {
 		::draw_rect(r, clr, surface_);
 	}
 }
 
-void RenderTarget::fill_rect(const Rect& rect, const RGBAColor& clr, BlendMode blend_mode) {
-	Rect r(rect);
+void RenderTarget::fill_rect(const Rectf& rect, const RGBAColor& clr, BlendMode blend_mode) {
+	Rectf r(rect);
 	if (clip(r))
 		surface_->fill_rect(r, clr, blend_mode);
 }
 
-void RenderTarget::brighten_rect(const Rect& rect, int32_t factor) {
-	Rect r(rect);
+void RenderTarget::brighten_rect(const Rectf& rect, int32_t factor) {
+	Rectf r(rect);
 	if (clip(r))
 		surface_->brighten_rect(r, factor);
 }
@@ -142,30 +142,32 @@
  *
  * This blit function copies the pixels to the destination surface.
  */
-void RenderTarget::blit(const Point& dst,
+void RenderTarget::blit(const Vector2f& dst,
                         const Image* image,
                         BlendMode blend_mode,
                         UI::Align align) {
-	Point destination_point(dst);
+	Vector2f destination_point(dst);
 	UI::correct_for_align(align, image->width(), image->height(), &destination_point);
 
-	Rect source_rect(Point(0, 0), image->width(), image->height());
-	Rect destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
+	Rectf source_rect(Vector2i(0, 0), image->width(), image->height());
+	Rectf destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
-		surface_->blit(destination_rect, *image, source_rect, 1., blend_mode);
+		// I seem to remember seeing 1. a lot in blitting calls.
+		constexpr float kFullyOpaque = 1.f;
+		surface_->blit(destination_rect, *image, source_rect, kFullyOpaque, blend_mode);
 	}
 }
 
-void RenderTarget::blit_monochrome(const Point& dst,
+void RenderTarget::blit_monochrome(const Vector2f& dst,
                                    const Image* image,
                                    const RGBAColor& blend_mode,
                                    UI::Align align) {
-	Point destination_point(dst);
+	Vector2f destination_point(dst);
 	UI::correct_for_align(align, image->width(), image->height(), &destination_point);
 
-	Rect source_rect(Point(0, 0), image->width(), image->height());
-	Rect destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
+	Rectf source_rect(Vector2i(0, 0), image->width(), image->height());
+	Rectf destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
 		surface_->blit_monochrome(destination_rect, *image, source_rect, blend_mode);
@@ -175,38 +177,40 @@
 /**
  * Like \ref blit, but use only a sub-rectangle of the source image.
  */
-void RenderTarget::blitrect(const Point& dst,
+void RenderTarget::blitrect(const Vector2f& dst,
                             const Image* image,
-                            const Rect& gsrcrc,
+                            const Recti& gsrcrc,
                             BlendMode blend_mode) {
 	assert(0 <= gsrcrc.x);
 	assert(0 <= gsrcrc.y);
 
 	// We want to use the given srcrc, but we must make sure that we are not
 	// blitting outside of the boundaries of 'image'.
-	Rect source_rect(gsrcrc.x, gsrcrc.y, std::min<int32_t>(image->width() - gsrcrc.x, gsrcrc.w),
-	                 std::min<int32_t>(image->height() - gsrcrc.y, gsrcrc.h));
-	Rect destination_rect(dst.x, dst.y, source_rect.w, source_rect.h);
+	Rectf source_rect(gsrcrc.x, gsrcrc.y, std::min<int32_t>(image->width() - gsrcrc.x, gsrcrc.w),
+	                  std::min<int32_t>(image->height() - gsrcrc.y, gsrcrc.h));
+	Rectf destination_rect(dst.x, dst.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
 		surface_->blit(destination_rect, *image, source_rect, 1., blend_mode);
 	}
 }
 
-void RenderTarget::blitrect_scale(Rect destination_rect,
+void RenderTarget::blitrect_scale(Rectf destination_rect,
                                   const Image* image,
-                                  Rect source_rect,
+                                  Recti source_rect_i,
                                   const float opacity,
                                   const BlendMode blend_mode) {
+	Rectf source_rect = source_rect_i.cast<float>();
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
 		surface_->blit(destination_rect, *image, source_rect, opacity, blend_mode);
 	}
 }
 
-void RenderTarget::blitrect_scale_monochrome(Rect destination_rect,
+void RenderTarget::blitrect_scale_monochrome(Rectf destination_rect,
                                              const Image* image,
-                                             Rect source_rect,
+                                             Recti source_rect_i,
                                              const RGBAColor& blend) {
+	Rectf source_rect = source_rect_i.cast<float>();
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
 		surface_->blit_monochrome(destination_rect, *image, source_rect, blend);
 	}
@@ -218,15 +222,15 @@
  * The pixel from ofs inside image is placed at the top-left corner of
  * the filled rectangle.
  */
-void RenderTarget::tile(const Rect& rect,
+void RenderTarget::tile(const Recti& rect,
                         const Image* image,
-                        const Point& gofs,
+                        const Vector2i& gofs,
                         BlendMode blend_mode) {
 	int32_t srcw = image->width();
 	int32_t srch = image->height();
 
-	Rect r(rect);
-	Point ofs(gofs);
+	Rectf r = rect.cast<float>();
+	Vector2i ofs(gofs);
 	if (clip(r)) {
 		if (offset_.x < 0)
 			ofs.x -= offset_.x;
@@ -251,7 +255,7 @@
 		while (ty < r.h) {
 			int tx = 0;
 			int32_t tofsx = ofs.x;
-			Rect srcrc;
+			Rectf srcrc;
 
 			srcrc.y = ofs.y;
 			srcrc.h = srch - ofs.y;
@@ -266,7 +270,7 @@
 				if (tx + srcrc.w > r.w)
 					srcrc.w = r.w - tx;
 
-				const Rect dst_rect(r.x + tx, r.y + ty, srcrc.w, srcrc.h);
+				const Rectf dst_rect(r.x + tx, r.y + ty, srcrc.w, srcrc.h);
 				surface_->blit(dst_rect, *image, srcrc, 1., blend_mode);
 
 				tx += srcrc.w;
@@ -280,54 +284,50 @@
 	}
 }
 
-/**
- * Draws a frame of an animation at the given location
- * Plays sound effect that is registered with this frame (the SoundHandler
- * decides if the sound really does get played)
- *
- * \param dstx, dsty the on-screen location of the animation hot spot
- * \param animation the animation ID
- * \param time the time, in milliseconds, in the animation
- * \param player the player this object belongs to, for player colour
- * purposes. May be 0 (for example, for world objects).
- */
-// TODO(unknown): Correctly calculate the stereo position for sound effects
-// TODO(unknown): The chosen semantics of animation sound effects is problematic:
-// What if the game runs very slowly or very quickly?
-void RenderTarget::blit_animation(const Point& dst, uint32_t animation, uint32_t time) {
+void RenderTarget::blit_animation(const Vector2f& dst,
+                                  const float scale,
+                                  uint32_t animation,
+                                  uint32_t time) {
+	// TODO(unknown): Correctly calculate the stereo position for sound effects
+	// TODO(unknown): The chosen semantics of animation sound effects is problematic:
+	// What if the game runs very slowly or very quickly?
 	const Animation& anim = g_gr->animations().get_animation(animation);
-	do_blit_animation(dst, anim, time, nullptr, Rect(Point(0, 0), anim.width(), anim.height()));
+	do_blit_animation(
+	   dst, scale, anim, time, nullptr, Recti(Vector2i(0, 0), anim.width(), anim.height()));
 }
 
-void RenderTarget::blit_animation(const Point& dst,
+void RenderTarget::blit_animation(const Vector2f& dst,
+                                  const float scale,
                                   uint32_t animation,
                                   uint32_t time,
                                   const RGBColor& player_color) {
 	const Animation& anim = g_gr->animations().get_animation(animation);
 	do_blit_animation(
-	   dst, anim, time, &player_color, Rect(Point(0, 0), anim.width(), anim.height()));
+	   dst, scale, anim, time, &player_color, Recti(Vector2i(0, 0), anim.width(), anim.height()));
 }
 
-void RenderTarget::blit_animation(const Point& dst,
+void RenderTarget::blit_animation(const Vector2f& dst,
+                                  const float scale,
                                   uint32_t animation,
                                   uint32_t time,
                                   const RGBColor& player_color,
-                                  const Rect& source_rect) {
+                                  const Recti& source_rect) {
 	do_blit_animation(
-	   dst, g_gr->animations().get_animation(animation), time, &player_color, source_rect);
+	   dst, scale, g_gr->animations().get_animation(animation), time, &player_color, source_rect);
 }
 
-void RenderTarget::do_blit_animation(const Point& dst,
+void RenderTarget::do_blit_animation(const Vector2f& dst,
+                                     const float scale,
                                      const Animation& animation,
                                      uint32_t time,
                                      const RGBColor* player_color,
-                                     const Rect& source_rect) {
-	Rect destination_rect(dst.x - animation.hotspot().x + source_rect.x,
-	                      dst.y - animation.hotspot().y + source_rect.y, source_rect.w,
-	                      source_rect.h);
-	Rect srcrc(source_rect);
-	if (to_surface_geometry(&destination_rect, &srcrc)) {
-		animation.blit(time, destination_rect.origin(), srcrc, player_color, surface_);
+                                     const Recti& source_rect_i) {
+	Rectf source_rect = source_rect_i.cast<float>();
+	Rectf destination_rect(dst.x - (animation.hotspot().x - source_rect.x) * scale,
+	                       dst.y - (animation.hotspot().y - source_rect.y) * scale,
+	                       source_rect.w * scale, source_rect.h * scale);
+	if (to_surface_geometry(&destination_rect, &source_rect)) {
+		animation.blit(time, destination_rect, source_rect, player_color, surface_);
 	}
 
 	// Look if there is a sound effect registered for this frame and trigger the
@@ -355,7 +355,7 @@
  * If true is returned, r a valid rectangle that can be used.
  * If false is returned, r may not be used and may be partially modified.
  */
-bool RenderTarget::clip(Rect& r) const {
+bool RenderTarget::clip(Rectf& r) const {
 	r.x += offset_.x;
 	r.y += offset_.y;
 
@@ -397,7 +397,7 @@
  * Clip against window and source bitmap, returns false if blitting is
  * unnecessary because image is not inside the target surface.
  */
-bool RenderTarget::to_surface_geometry(Rect* destination_rect, Rect* source_rect) const {
+bool RenderTarget::to_surface_geometry(Rectf* destination_rect, Rectf* source_rect) const {
 	assert(0 <= source_rect->x);
 	assert(0 <= source_rect->y);
 	destination_rect->x += offset_.x;
@@ -409,17 +409,16 @@
 	// destination_rect, we do this by making the proportional change.
 
 	// Clipping, from the left.
-	if (destination_rect->x < 0) {
+	if (destination_rect->x < 0.f) {
 		if (destination_rect->w <= -destination_rect->x) {
 			return false;
 		}
-		// Adding 0.5 is a cheap way of turning integer truncation into a rounded value.
-		const int source_rect_pixel_change =
-		   0.5 + -static_cast<double>(destination_rect->x) / destination_rect->w * source_rect->w;
+		const float source_rect_pixel_change =
+		   -destination_rect->x / destination_rect->w * source_rect->w;
 		source_rect->x += source_rect_pixel_change;
 		source_rect->w -= source_rect_pixel_change;
 		destination_rect->w += destination_rect->x;
-		destination_rect->x = 0;
+		destination_rect->x = 0.f;
 	}
 
 	// Clipping, from the right.
@@ -427,25 +426,22 @@
 		if (rect_.w <= destination_rect->x) {
 			return false;
 		}
-		const int new_destination_w = rect_.w - destination_rect->x;
-		// Adding 0.5 is a cheap way of turning integer truncation into a rounded value.
-		source_rect->w =
-		   0.5 + static_cast<double>(new_destination_w) / destination_rect->w * source_rect->w;
+		const float new_destination_w = rect_.w - destination_rect->x;
+		source_rect->w = new_destination_w / destination_rect->w * source_rect->w;
 		destination_rect->w = new_destination_w;
 	}
 
 	// Clipping, from the top.
-	if (destination_rect->y < 0) {
+	if (destination_rect->y < 0.f) {
 		if (destination_rect->h <= -destination_rect->y) {
 			return false;
 		}
-		// Adding 0.5 is a cheap way of turning integer truncation into a rounded value.
-		const int source_rect_pixel_change =
-		   0.5 + -static_cast<double>(destination_rect->y) / destination_rect->h * source_rect->h;
+		const float source_rect_pixel_change =
+		   -destination_rect->y / destination_rect->h * source_rect->h;
 		source_rect->y += source_rect_pixel_change;
 		source_rect->h -= source_rect_pixel_change;
 		destination_rect->h += destination_rect->y;
-		destination_rect->y = 0;
+		destination_rect->y = 0.f;
 	}
 
 	// Clipping, from the bottom.
@@ -453,13 +449,10 @@
 		if (rect_.h <= destination_rect->y) {
 			return false;
 		}
-		const int new_destination_h = rect_.h - destination_rect->y;
-		// Adding 0.5 is a cheap way of turning integer truncation into a rounded value.
-		source_rect->h =
-		   0.5 + static_cast<double>(new_destination_h) / destination_rect->h * source_rect->h;
+		const float new_destination_h = rect_.h - destination_rect->y;
+		source_rect->h = new_destination_h / destination_rect->h * source_rect->h;
 		destination_rect->h = new_destination_h;
 	}
-
 	destination_rect->x += rect_.x;
 	destination_rect->y += rect_.y;
 	return true;

=== modified file 'src/graphic/rendertarget.h'
--- src/graphic/rendertarget.h	2016-08-04 15:49:05 +0000
+++ src/graphic/rendertarget.h	2016-10-24 20:07:47 +0000
@@ -51,31 +51,31 @@
 class RenderTarget {
 public:
 	RenderTarget(Surface*);
-	void set_window(const Rect& rc, const Point& ofs);
-	bool enter_window(const Rect& rc, Rect* previous, Point* prevofs);
+	void set_window(const Recti& rc, const Vector2i& ofs);
+	bool enter_window(const Recti& rc, Recti* previous, Vector2i* prevofs);
 
 	int32_t width() const;
 	int32_t height() const;
 
-	void draw_line_strip(const std::vector<FloatPoint>& points, const RGBColor& color, float width);
-	void draw_rect(const Rect&, const RGBColor&);
-	void fill_rect(const Rect&, const RGBAColor&, BlendMode blend_mode = BlendMode::Copy);
-	void brighten_rect(const Rect&, int32_t factor);
+	void draw_line_strip(const std::vector<Vector2f>& points, const RGBColor& color, float width);
+	void draw_rect(const Rectf&, const RGBColor&);
+	void fill_rect(const Rectf&, const RGBAColor&, BlendMode blend_mode = BlendMode::Copy);
+	void brighten_rect(const Rectf&, int32_t factor);
 
-	void blit(const Point& dst,
+	void blit(const Vector2f& dst,
 	          const Image* image,
 	          BlendMode blend_mode = BlendMode::UseAlpha,
 	          UI::Align = UI::Align::kTopLeft);
 
 	// Like blit. See MonochromeBlitProgram for details.
-	void blit_monochrome(const Point& dst,
+	void blit_monochrome(const Vector2f& dst,
 	                     const Image* image,
 	                     const RGBAColor& blend_mode,
 	                     UI::Align = UI::Align::kTopLeft);
 
-	void blitrect(const Point& dst,
+	void blitrect(const Vector2f& dst,
 	              const Image* image,
-	              const Rect& src,
+	              const Recti& src,
 	              BlendMode blend_mode = BlendMode::UseAlpha);
 
 	// Blits the 'source_rect' from 'image' into the
@@ -83,68 +83,71 @@
 	// multiplied with 'opacity' before blitting. The 'blend_mode'
 	// defines if values are blended with whats already there or just
 	// copied over.
-	// Rect's are taken by value on purpose.
-	void blitrect_scale(Rect destination_rect,
+	// Takes by value on purpose.
+	void blitrect_scale(Rectf destination_rect,
 	                    const Image* image,
-	                    Rect source_rect,
+	                    Recti source_rect,
 	                    float opacity,
 	                    BlendMode blend_mode);
 
-	// Like blitrect_scale. See MonochromeBlitProgram for details. Rect's are
-	// taken by value on purpose.
-	void blitrect_scale_monochrome(Rect destination_rect,
+	// Like blitrect_scale. See MonochromeBlitProgram for details. Takes by
+	// value on purpose.
+	void blitrect_scale_monochrome(Rectf destination_rect,
 	                               const Image* image,
-	                               Rect source_rect,
+	                               Recti source_rect,
 	                               const RGBAColor& blend);
 
-	void tile(const Rect&,
+	void tile(const Recti&,
 	          const Image* image,
-	          const Point& ofs,
+	          const Vector2i& ofs,
 	          BlendMode blend_mode = BlendMode::UseAlpha);
 
-	// Draw the 'animation' as it should appear at 'time' in this target at 'dst'. Optionally, the
-	// animation is
-	// tinted with 'player_color' and cropped to 'source_rect'.
-	void blit_animation(const Point& dst, uint32_t animation, uint32_t time);
-	void blit_animation(const Point& dst,
+	// Draw the 'animation' as it should appear at 'time' in this target at
+	// 'dst'. Optionally, the animation is tinted with 'player_color' and
+	// cropped to 'source_rect'.
+	void blit_animation(const Vector2f& dst, float scale, uint32_t animation, uint32_t time);
+	void blit_animation(const Vector2f& dst,
+	                    float scale,
 	                    uint32_t animation,
 	                    uint32_t time,
 	                    const RGBColor& player_color);
-	void blit_animation(const Point& dst,
+	void blit_animation(const Vector2f& dst,
+	                    float scale,
 	                    uint32_t animation,
 	                    uint32_t time,
 	                    const RGBColor& player_color,
-	                    const Rect& source_rect);
+	                    const Recti& source_rect);
 
 	void reset();
 
 	Surface* get_surface() const {
 		return surface_;
 	}
-	const Rect& get_rect() const {
+	const Recti& get_rect() const {
 		return rect_;
 	}
-	const Point& get_offset() const {
+	const Vector2i& get_offset() const {
 		return offset_;
 	}
 
 protected:
-	bool clip(Rect& r) const;
-	bool to_surface_geometry(Rect* destination_rect, Rect* source_rect) const;
+	bool clip(Rectf& r) const;
+	bool to_surface_geometry(Rectf* destination_rect, Rectf* source_rect) const;
 
 	// Does the actual blitting.
-	void do_blit_animation(const Point& dst,
+	void do_blit_animation(const Vector2f& dst,
+	                       const float scale,
 	                       const Animation& animation,
 	                       uint32_t time,
 	                       const RGBColor* player_color,
-	                       const Rect& source_rect);
+	                       const Recti& source_rect);
 
 	/// The target surface
 	Surface* surface_;
 	/// The current clip rectangle
-	Rect rect_;
+	Recti rect_;
 	/// Drawing offset
-	Point offset_;
+	Vector2i offset_;
 };
 
 #endif  // end of include guard: WL_GRAPHIC_RENDERTARGET_H

=== modified file 'src/graphic/richtext.cc'
--- src/graphic/richtext.cc	2016-08-04 16:24:09 +0000
+++ src/graphic/richtext.cc	2016-10-24 20:07:47 +0000
@@ -41,7 +41,7 @@
  * rectangular bounding box.
  */
 struct Element {
-	explicit Element(const Rect& bounding_box) : bbox(bounding_box) {
+	explicit Element(const Recti& bounding_box) : bbox(bounding_box) {
 	}
 	virtual ~Element() {
 	}
@@ -52,23 +52,23 @@
 	 */
 	virtual void draw(RenderTarget& dst) = 0;
 
-	Rect bbox;
+	Recti bbox;
 };
 
 struct ImageElement : Element {
-	ImageElement(const Rect& bounding_box, const Image* init_image)
+	ImageElement(const Recti& bounding_box, const Image* init_image)
 	   : Element(bounding_box), image(init_image) {
 	}
 
 	void draw(RenderTarget& dst) override {
-		dst.blit(Point(0, 0), image);
+		dst.blit(Vector2f(0, 0), image);
 	}
 
 	const Image* image;
 };
 
 struct TextlineElement : Element {
-	TextlineElement(const Rect& bounding_box,
+	TextlineElement(const Recti& bounding_box,
 	                const TextStyle& init_style,
 	                std::vector<std::string>::const_iterator words_begin,
 	                std::vector<std::string>::const_iterator words_end)
@@ -107,16 +107,16 @@
 			}
 		}
 		// Now render
-		uint32_t x = g_fh->draw_text_raw(dst, style, Point(0, 0), result_words[0]);
+		uint32_t x = g_fh->draw_text_raw(dst, style, Vector2i(0, 0), result_words[0]);
 
 		it = result_words.begin() + 1;
 		if (it != result_words.end()) {
 			do {
 				if (style.underline)
-					x += g_fh->draw_text_raw(dst, style, Point(x, 0), " ");
+					x += g_fh->draw_text_raw(dst, style, Vector2i(x, 0), " ");
 				else
 					x += spacewidth;
-				x += g_fh->draw_text_raw(dst, style, Point(x, 0), *it++);
+				x += g_fh->draw_text_raw(dst, style, Vector2i(x, 0), *it++);
 			} while (it != result_words.end());
 		}
 	}
@@ -357,7 +357,7 @@
 			if (!image)
 				continue;
 
-			Rect bbox;
+			Recti bbox;
 			bbox.x = text.images_width;
 			bbox.y = m->height;
 			bbox.w = image->width();
@@ -423,7 +423,7 @@
 				TextBuilder::Elt elt;
 				elt.miny = elt.maxy = 0;
 
-				Rect bbox;
+				Recti bbox;
 				bbox.x = text.linewidth ? text.linewidth + text.spacewidth : 0;
 				bbox.y = 0;  // filled in later
 				bbox.w = 0;
@@ -486,16 +486,16 @@
  * @note this function may draw content outside the box given offset
  * and @ref width and @ref height, if there were wrapping problems.
  */
-void RichText::draw(RenderTarget& dst, const Point& offset, bool background) {
+void RichText::draw(RenderTarget& dst, const Vector2i& offset, bool background) {
 	for (std::vector<Element*>::const_iterator elt = m->elements.begin(); elt != m->elements.end();
 	     ++elt) {
-		Rect oldbox;
-		Point oldofs;
-		Rect bbox((*elt)->bbox.origin() + offset, (*elt)->bbox.w, (*elt)->bbox.h);
+		Recti oldbox;
+		Vector2i oldofs;
+		Recti bbox((*elt)->bbox.origin() + offset, (*elt)->bbox.w, (*elt)->bbox.h);
 
 		if (dst.enter_window(bbox, &oldbox, &oldofs)) {
 			if (background)
-				dst.fill_rect(Rect(Point(0, 0), bbox.w, bbox.h), m->background_color);
+				dst.fill_rect(Rectf(0.f, 0.f, bbox.w, bbox.h), m->background_color);
 			(*elt)->draw(dst);
 			dst.set_window(oldbox, oldofs);
 		}

=== modified file 'src/graphic/richtext.h'
--- src/graphic/richtext.h	2016-08-04 15:49:05 +0000
+++ src/graphic/richtext.h	2016-10-24 20:07:47 +0000
@@ -24,7 +24,7 @@
 #include <memory>
 #include <string>
 
-#include "base/point.h"
+#include "base/vector.h"
 #include "graphic/color.h"
 
 class RenderTarget;
@@ -50,7 +50,7 @@
 	uint32_t height();
 
 	void parse(const std::string& text);
-	void draw(RenderTarget& dst, const Point& offset, bool background = false);
+	void draw(RenderTarget& dst, const Vector2i& offset, bool background = false);
 
 private:
 	std::unique_ptr<RichTextImpl> m;

=== modified file 'src/graphic/screen.cc'
--- src/graphic/screen.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/screen.cc	2016-10-24 20:07:47 +0000
@@ -53,7 +53,7 @@
 	return std::unique_ptr<Texture>(new Texture(surface));
 }
 
-void Screen::do_blit(const FloatRect& dst_rect,
+void Screen::do_blit(const Rectf& dst_rect,
                      const BlitData& texture,
                      float opacity,
                      BlendMode blend_mode) {
@@ -68,7 +68,7 @@
 	RenderQueue::instance().enqueue(i);
 }
 
-void Screen::do_blit_blended(const FloatRect& dst_rect,
+void Screen::do_blit_blended(const Rectf& dst_rect,
                              const BlitData& texture,
                              const BlitData& mask,
                              const RGBColor& blend) {
@@ -83,7 +83,7 @@
 	RenderQueue::instance().enqueue(i);
 }
 
-void Screen::do_blit_monochrome(const FloatRect& dst_rect,
+void Screen::do_blit_monochrome(const Rectf& dst_rect,
                                 const BlitData& texture,
                                 const RGBAColor& blend) {
 	RenderQueue::Item i;
@@ -105,7 +105,7 @@
 	RenderQueue::instance().enqueue(i);
 }
 
-void Screen::do_fill_rect(const FloatRect& dst_rect, const RGBAColor& color, BlendMode blend_mode) {
+void Screen::do_fill_rect(const Rectf& dst_rect, const RGBAColor& color, BlendMode blend_mode) {
 	RenderQueue::Item i;
 	i.blend_mode = blend_mode;
 	i.program_id = RenderQueue::Program::kRect;

=== modified file 'src/graphic/screen.h'
--- src/graphic/screen.h	2016-08-04 15:49:05 +0000
+++ src/graphic/screen.h	2016-10-24 20:07:47 +0000
@@ -43,20 +43,20 @@
 	std::unique_ptr<Texture> to_texture() const;
 
 private:
-	void do_blit(const FloatRect& dst_rect,
+	void do_blit(const Rectf& dst_rect,
 	             const BlitData& texture,
 	             float opacity,
 	             BlendMode blend_mode) override;
-	void do_blit_blended(const FloatRect& dst_rect,
+	void do_blit_blended(const Rectf& dst_rect,
 	                     const BlitData& texture,
 	                     const BlitData& mask,
 	                     const RGBColor& blend) override;
-	void do_blit_monochrome(const FloatRect& dst_rect,
+	void do_blit_monochrome(const Rectf& dst_rect,
 	                        const BlitData& texture,
 	                        const RGBAColor& blend) override;
 	void do_draw_line_strip(std::vector<DrawLineProgram::PerVertexData> vertices) override;
 	void
-	do_fill_rect(const FloatRect& dst_rect, const RGBAColor& color, BlendMode blend_mode) override;
+	do_fill_rect(const Rectf& dst_rect, const RGBAColor& color, BlendMode blend_mode) override;
 
 	const int w_, h_;
 

=== modified file 'src/graphic/surface.cc'
--- src/graphic/surface.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/surface.cc	2016-10-24 20:07:47 +0000
@@ -26,15 +26,15 @@
 #include <SDL.h>
 
 #include "base/macros.h"
-#include "base/point.h"
 #include "base/rect.h"
+#include "base/vector.h"
 #include "graphic/gl/coordinate_conversion.h"
 #include "graphic/gl/utils.h"
 
 namespace {
 
 // Adjust 'original' so that only 'src_rect' is actually blitted.
-BlitData adjust_for_src(BlitData blit_data, const Rect& src_rect) {
+BlitData adjust_for_src(BlitData blit_data, const Rectf& src_rect) {
 	blit_data.rect.x += src_rect.x;
 	blit_data.rect.y += src_rect.y;
 	blit_data.rect.w = src_rect.w;
@@ -44,11 +44,11 @@
 
 // Get the normal of the line between 'start' and 'end'.
 template <typename PointType>
-FloatPoint calculate_line_normal(const PointType& start, const PointType& end) {
+Vector2f calculate_line_normal(const PointType& start, const PointType& end) {
 	const float dx = end.x - start.x;
 	const float dy = end.y - start.y;
 	const float len = std::hypot(dx, dy);
-	return FloatPoint(-dy / len, dx / len);
+	return Vector2f(-dy / len, dx / len);
 }
 
 // Tesselates the line made up of 'points' ino triangles and converts them into
@@ -60,7 +60,7 @@
                           int h,
                           const RGBColor& color,
                           float line_width,
-                          const std::vector<FloatPoint>& points,
+                          const std::vector<Vector2f>& points,
                           std::vector<DrawLineProgram::PerVertexData>* vertices) {
 	const float r = color.r / 255.;
 	const float g = color.g / 255.;
@@ -69,27 +69,27 @@
 	// Iterate over each line segment, i.e. all points but the last, convert
 	// them from pixel space to gl space and draw them.
 	for (size_t i = 0; i < points.size() - 1; ++i) {
-		const FloatPoint p1 = FloatPoint(points[i].x, points[i].y);
-		const FloatPoint p2 = FloatPoint(points[i + 1].x, points[i + 1].y);
+		const Vector2f p1 = Vector2f(points[i].x, points[i].y);
+		const Vector2f p2 = Vector2f(points[i + 1].x, points[i + 1].y);
 
-		const FloatPoint normal = calculate_line_normal(p1, p2);
-		const FloatPoint scaled_normal(0.5f * line_width * normal.x, 0.5f * line_width * normal.y);
+		const Vector2f normal = calculate_line_normal(p1, p2);
+		const Vector2f scaled_normal(0.5f * line_width * normal.x, 0.5f * line_width * normal.y);
 
 		// Quad points are created in rendering order for OpenGL.
 		{
-			FloatPoint p = p1 - scaled_normal;
-			pixel_to_gl_renderbuffer(w, h, &p.x, &p.y);
-			vertices->emplace_back(DrawLineProgram::PerVertexData{p.x, p.y, 0.f, r, g, b, 1.});
-		}
-
-		{
-			FloatPoint p = p2 - scaled_normal;
-			pixel_to_gl_renderbuffer(w, h, &p.x, &p.y);
-			vertices->emplace_back(DrawLineProgram::PerVertexData{p.x, p.y, 0.f, r, g, b, 1.});
-		}
-
-		{
-			FloatPoint p = p1 + scaled_normal;
+			Vector2f p = p1 - scaled_normal;
+			pixel_to_gl_renderbuffer(w, h, &p.x, &p.y);
+			vertices->emplace_back(DrawLineProgram::PerVertexData{p.x, p.y, 0.f, r, g, b, 1.});
+		}
+
+		{
+			Vector2f p = p2 - scaled_normal;
+			pixel_to_gl_renderbuffer(w, h, &p.x, &p.y);
+			vertices->emplace_back(DrawLineProgram::PerVertexData{p.x, p.y, 0.f, r, g, b, 1.});
+		}
+
+		{
+			Vector2f p = p1 + scaled_normal;
 			pixel_to_gl_renderbuffer(w, h, &p.x, &p.y);
 			vertices->emplace_back(DrawLineProgram::PerVertexData{p.x, p.y, 0.f, r, g, b, -1.});
 		}
@@ -98,7 +98,7 @@
 		vertices->push_back(vertices->at(vertices->size() - 2));
 
 		{
-			FloatPoint p = p2 + scaled_normal;
+			Vector2f p = p2 + scaled_normal;
 			pixel_to_gl_renderbuffer(w, h, &p.x, &p.y);
 			vertices->emplace_back(DrawLineProgram::PerVertexData{p.x, p.y, 0.f, r, g, b, -1.});
 		}
@@ -107,12 +107,12 @@
 
 }  // namespace
 
-void Surface::fill_rect(const Rect& rc, const RGBAColor& clr, BlendMode blend_mode) {
-	const FloatRect rect = rect_to_gl_renderbuffer(width(), height(), rc);
+void Surface::fill_rect(const Rectf& rc, const RGBAColor& clr, BlendMode blend_mode) {
+	const Rectf rect = rect_to_gl_renderbuffer(width(), height(), rc);
 	do_fill_rect(rect, clr, blend_mode);
 }
 
-void Surface::brighten_rect(const Rect& rc, const int32_t factor) {
+void Surface::brighten_rect(const Rectf& rc, const int32_t factor) {
 	if (!factor) {
 		return;
 	}
@@ -120,11 +120,11 @@
 	const BlendMode blend_mode = factor < 0 ? BlendMode::Subtract : BlendMode::UseAlpha;
 	const int abs_factor = std::abs(factor);
 	const RGBAColor color(abs_factor, abs_factor, abs_factor, 0);
-	const FloatRect rect = rect_to_gl_renderbuffer(width(), height(), rc);
+	const Rectf rect = rect_to_gl_renderbuffer(width(), height(), rc);
 	do_fill_rect(rect, color, blend_mode);
 }
 
-void Surface::draw_line_strip(std::vector<FloatPoint> points,
+void Surface::draw_line_strip(std::vector<Vector2f> points,
                               const RGBColor& color,
                               float line_width) {
 	if (points.size() < 2) {
@@ -138,41 +138,41 @@
 	do_draw_line_strip(std::move(vertices));
 }
 
-void Surface::blit_monochrome(const Rect& dst_rect,
+void Surface::blit_monochrome(const Rectf& dst_rect,
                               const Image& image,
-                              const Rect& src_rect,
+                              const Rectf& src_rect,
                               const RGBAColor& blend) {
-	const FloatRect rect = rect_to_gl_renderbuffer(width(), height(), dst_rect);
+	const Rectf rect = rect_to_gl_renderbuffer(width(), height(), dst_rect);
 	do_blit_monochrome(rect, adjust_for_src(image.blit_data(), src_rect), blend);
 }
 
-void Surface::blit_blended(const Rect& dst_rect,
+void Surface::blit_blended(const Rectf& dst_rect,
                            const Image& image,
                            const Image& texture_mask,
-                           const Rect& src_rect,
+                           const Rectf& src_rect,
                            const RGBColor& blend) {
-	const FloatRect rect = rect_to_gl_renderbuffer(width(), height(), dst_rect);
+	const Rectf rect = rect_to_gl_renderbuffer(width(), height(), dst_rect);
 	do_blit_blended(rect, adjust_for_src(image.blit_data(), src_rect),
 	                adjust_for_src(texture_mask.blit_data(), src_rect), blend);
 }
 
-void Surface::blit(const Rect& dst_rect,
+void Surface::blit(const Rectf& dst_rect,
                    const Image& image,
-                   const Rect& src_rect,
+                   const Rectf& src_rect,
                    float opacity,
                    BlendMode blend_mode) {
-	const FloatRect rect = rect_to_gl_renderbuffer(width(), height(), dst_rect);
+	const Rectf rect = rect_to_gl_renderbuffer(width(), height(), dst_rect);
 	do_blit(rect, adjust_for_src(image.blit_data(), src_rect), opacity, blend_mode);
 }
 
-void draw_rect(const Rect& rc, const RGBColor& clr, Surface* surface) {
-	const FloatPoint top_left = FloatPoint(rc.x + 0.5f, rc.y + 0.5f);
-	const FloatPoint top_right = FloatPoint(rc.x + rc.w - 0.5f, rc.y + 0.5f);
-	const FloatPoint bottom_right = FloatPoint(rc.x + rc.w - 0.5f, rc.y + rc.h - 0.5f);
-	const FloatPoint bottom_left = FloatPoint(rc.x + 0.5f, rc.y + rc.h - 0.5f);
+void draw_rect(const Rectf& rc, const RGBColor& clr, Surface* surface) {
+	const Vector2f top_left = Vector2f(rc.x + 0.5f, rc.y + 0.5f);
+	const Vector2f top_right = Vector2f(rc.x + rc.w - 0.5f, rc.y + 0.5f);
+	const Vector2f bottom_right = Vector2f(rc.x + rc.w - 0.5f, rc.y + rc.h - 0.5f);
+	const Vector2f bottom_left = Vector2f(rc.x + 0.5f, rc.y + rc.h - 0.5f);
 
 	surface->draw_line_strip({top_left, top_right, bottom_right}, clr, 1);
 	// We need to split this up in order not to miss a pixel on the bottom right corner.
 	surface->draw_line_strip(
-	   {FloatPoint(bottom_right.x + 1, bottom_right.y), bottom_left, top_left}, clr, 1);
+	   {Vector2f(bottom_right.x + 1, bottom_right.y), bottom_left, top_left}, clr, 1);
 }

=== modified file 'src/graphic/surface.h'
--- src/graphic/surface.h	2016-08-04 15:49:05 +0000
+++ src/graphic/surface.h	2016-10-24 20:07:47 +0000
@@ -46,42 +46,42 @@
 
 	/// This draws a part of 'texture'.
 	void blit(
-	   const Rect& dst, const Image&, const Rect& srcrc, const float opacity, BlendMode blend_mode);
+	   const Rectf& dst, const Image&, const Rectf& srcrc, const float opacity, BlendMode blend_mode);
 
 	/// This draws a playercolor blended image.
-	void blit_blended(const Rect& dst,
+	void blit_blended(const Rectf& dst,
 	                  const Image& image,
 	                  const Image& texture_mask,
-	                  const Rect& srcrc,
+	                  const Rectf& srcrc,
 	                  const RGBColor& blend);
 
 	/// This draws a grayed out version.
 	void
-	blit_monochrome(const Rect& dst, const Image&, const Rect& srcrc, const RGBAColor& multiplier);
+	blit_monochrome(const Rectf& dst, const Image&, const Rectf& srcrc, const RGBAColor& multiplier);
 
 	/// Draws a filled rect to the destination.
-	void fill_rect(const Rect&, const RGBAColor&, BlendMode blend_mode = BlendMode::Copy);
+	void fill_rect(const Rectf& dst, const RGBAColor&, BlendMode blend_mode = BlendMode::Copy);
 
 	// Draw a 'width' pixel wide line to the destination. 'points' are taken by
 	// value on purpose.
-	void draw_line_strip(std::vector<FloatPoint> points, const RGBColor& color, float width);
+	void draw_line_strip(std::vector<Vector2f> points, const RGBColor& color, float width);
 
 	/// makes a rectangle on the destination brighter (or darker).
-	void brighten_rect(const Rect&, int factor);
+	void brighten_rect(const Rectf&, int factor);
 
 private:
 	/// The actual implementation of the methods below.
-	virtual void do_blit(const FloatRect& dst_rect,
+	virtual void do_blit(const Rectf& dst_rect,
 	                     const BlitData& texture,
 	                     float opacity,
 	                     BlendMode blend_mode) = 0;
 
-	virtual void do_blit_blended(const FloatRect& dst_rect,
+	virtual void do_blit_blended(const Rectf& dst_rect,
 	                             const BlitData& texture,
 	                             const BlitData& mask,
 	                             const RGBColor& blend) = 0;
 
-	virtual void do_blit_monochrome(const FloatRect& dst_rect,
+	virtual void do_blit_monochrome(const Rectf& dst_rect,
 	                                const BlitData& texture,
 	                                const RGBAColor& blend) = 0;
 
@@ -90,7 +90,7 @@
 	virtual void do_draw_line_strip(std::vector<DrawLineProgram::PerVertexData> vertices) = 0;
 
 	virtual void
-	do_fill_rect(const FloatRect& dst_rect, const RGBAColor& color, BlendMode blend_mode) = 0;
+	do_fill_rect(const Rectf& dst_rect, const RGBAColor& color, BlendMode blend_mode) = 0;
 
 	DISALLOW_COPY_AND_ASSIGN(Surface);
 };
@@ -98,6 +98,6 @@
 /// Draws a rect (frame only) to the surface. The width of the surrounding line
 /// is 1 pixel, i.e. the transparent inner box of the drawn rectangle starts at
 /// (x+1, y+1) and has dimension (w - 2, h - 2).
-void draw_rect(const Rect& rect, const RGBColor&, Surface* destination);
+void draw_rect(const Rectf& rect, const RGBColor&, Surface* destination);
 
 #endif  // end of include guard: WL_GRAPHIC_SURFACE_H

=== modified file 'src/graphic/text/rt_render.cc'
--- src/graphic/text/rt_render.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/text/rt_render.cc	2016-10-24 20:07:47 +0000
@@ -32,8 +32,8 @@
 #include "base/i18n.h"
 #include "base/log.h"
 #include "base/macros.h"
-#include "base/point.h"
 #include "base/rect.h"
+#include "base/vector.h"
 #include "base/wexception.h"
 #include "graphic/align.h"
 #include "graphic/graphic.h"
@@ -173,7 +173,7 @@
 }
 
 struct Reference {
-	Rect dim;
+	Recti dim;
 	string ref;
 };
 
@@ -185,7 +185,7 @@
 		// Should this linear algorithm proof to be too slow (doubtful), the
 		// RefMap could also be efficiently implemented using an R-Tree
 		for (const Reference& c : refs_)
-			if (c.dim.contains(Point(x, y)))
+			if (c.dim.contains(Vector2i(x, y)))
 				return c.ref;
 		return "";
 	}
@@ -469,7 +469,7 @@
 	const vector<Reference> get_references() override {
 		vector<Reference> rv;
 		if (!nodestyle_.reference.empty()) {
-			Reference r = {Rect(0, 0, w_, h_), nodestyle_.reference};
+			Reference r = {Recti(0, 0, w_, h_), nodestyle_.reference};
 			rv.push_back(r);
 		}
 		return rv;
@@ -501,7 +501,7 @@
 	const Texture& img =
 	   font_.render(txt_, nodestyle_.font_color, nodestyle_.font_style, texture_cache);
 	Texture* rv = new Texture(img.width(), img.height());
-	rv->blit(Rect(0, 0, img.width(), img.height()), img, Rect(0, 0, img.width(), img.height()), 1.,
+	rv->blit(Rectf(0, 0, img.width(), img.height()), img, Rectf(0, 0, img.width(), img.height()), 1.,
 	         BlendMode::Copy);
 	return rv;
 }
@@ -536,8 +536,8 @@
 	   font_.render(txt_, nodestyle_.font_color, nodestyle_.font_style, texture_cache);
 	Texture* rv = new Texture(w_, h_);
 	for (uint16_t curx = 0; curx < w_; curx += t.width()) {
-		Rect srcrect(Point(0, 0), min<int>(t.width(), w_ - curx), h_);
-		rv->blit(Rect(curx, 0, srcrect.w, srcrect.h), t, srcrect, 1., BlendMode::Copy);
+		Rectf srcrect(0.f, 0.f, min<int>(t.width(), w_ - curx), h_);
+		rv->blit(Rectf(curx, 0, srcrect.w, srcrect.h), t, srcrect, 1., BlendMode::Copy);
 	}
 	return rv;
 }
@@ -557,7 +557,7 @@
 	Texture* render(TextureCache* texture_cache) override {
 		if (show_spaces_) {
 			Texture* rv = new Texture(w_, h_);
-			rv->fill_rect(Rect(0, 0, w_, h_), RGBAColor(0xcc, 0, 0, 0xcc));
+			rv->fill_rect(Rectf(0, 0, w_, h_), RGBAColor(0xcc, 0, 0, 0xcc));
 			return rv;
 		}
 		return TextNode::render(texture_cache);
@@ -619,8 +619,8 @@
 
 		// Draw background image (tiling)
 		if (background_image_) {
-			Rect dst;
-			Rect srcrect(Point(0, 0), 1, 1);
+			Rectf dst;
+			Rectf srcrect(0, 0, 1, 1);
 			for (uint16_t curx = 0; curx < w_; curx += background_image_->width()) {
 				dst.x = curx;
 				dst.y = 0;
@@ -629,7 +629,7 @@
 				rv->blit(dst, *background_image_, srcrect, 1., BlendMode::Copy);
 			}
 		} else {
-			rv->fill_rect(Rect(0, 0, w_, h_), RGBAColor(255, 255, 255, 0));
+			rv->fill_rect(Rectf(0, 0, w_, h_), RGBAColor(255, 255, 255, 0));
 		}
 		return rv;
 	}
@@ -689,19 +689,19 @@
 			throw TextureTooBig(error_message);
 		}
 		Texture* rv = new Texture(width(), height());
-		rv->fill_rect(Rect(0, 0, rv->width(), rv->height()), RGBAColor(255, 255, 255, 0));
+		rv->fill_rect(Rectf(0, 0, rv->width(), rv->height()), RGBAColor(255, 255, 255, 0));
 
 		// Draw Solid background Color
 		bool set_alpha = true;
 		if (is_background_color_set_) {
-			rv->fill_rect(Rect(Point(margin_.left, margin_.top), w_, h_), background_color_);
+			rv->fill_rect(Rectf(margin_.left, margin_.top, w_, h_), background_color_);
 			set_alpha = false;
 		}
 
 		// Draw background image (tiling)
 		if (background_image_) {
-			Rect dst;
-			Rect src(0, 0, 0, 0);
+			Rectf dst;
+			Rectf src(0, 0, 0, 0);
 
 			for (uint16_t cury = margin_.top; cury < h_ + margin_.top;
 			     cury += background_image_->height()) {
@@ -720,10 +720,9 @@
 		for (RenderNode* n : nodes_to_render_) {
 			Texture* node_texture = n->render(texture_cache);
 			if (node_texture) {
-				Rect dst = Rect(n->x() + margin_.left, n->y() + margin_.top, node_texture->width(),
+				Rectf dst(n->x() + margin_.left, n->y() + margin_.top, node_texture->width(),
 				                node_texture->height());
-				Rect src = Rect(0, 0, node_texture->width(), node_texture->height());
-
+				Rectf src(0, 0, node_texture->width(), node_texture->height());
 				rv->blit(
 				   dst, *node_texture, src, 1., set_alpha ? BlendMode::Copy : BlendMode::UseAlpha);
 				delete node_texture;
@@ -754,7 +753,7 @@
 		nodes_to_render_ = n;
 	}
 	void add_reference(int16_t gx, int16_t gy, uint16_t w, uint16_t h, const string& s) {
-		Reference r = {Rect(gx, gy, w, h), s};
+		Reference r = {Recti(gx, gy, w, h), s};
 		refs_.push_back(r);
 	}
 
@@ -790,8 +789,8 @@
 
 Texture* ImgRenderNode::render(TextureCache* /* texture_cache */) {
 	Texture* rv = new Texture(image_.width(), image_.height());
-	rv->blit(Rect(0, 0, image_.width(), image_.height()), image_,
-	         Rect(0, 0, image_.width(), image_.height()), 1., BlendMode::Copy);
+	rv->blit(Rectf(0, 0, image_.width(), image_.height()), image_,
+	         Rectf(0, 0, image_.width(), image_.height()), 1., BlendMode::Copy);
 	return rv;
 }
 // End: Helper Stuff

=== modified file 'src/graphic/texture.cc'
--- src/graphic/texture.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/texture.cc	2016-10-24 20:07:47 +0000
@@ -144,14 +144,14 @@
 	SDL_FreeSurface(surface);
 }
 
-Texture::Texture(const GLuint texture, const Rect& subrect, int parent_w, int parent_h)
+Texture::Texture(const GLuint texture, const Recti& subrect, int parent_w, int parent_h)
    : owns_texture_(false) {
 	if (parent_w == 0 || parent_h == 0) {
 		throw wexception("Created a sub Texture with zero height and width parent.");
 	}
 
 	blit_data_ = BlitData{
-	   texture, parent_w, parent_h, subrect,
+	   texture, parent_w, parent_h, subrect.cast<float>(),
 	};
 }
 
@@ -172,7 +172,7 @@
 void Texture::init(uint16_t w, uint16_t h) {
 	blit_data_ = {
 	   0,  // initialized below
-	   w, h, Rect(0, 0, w, h),
+	   w, h, Rectf(0, 0, w, h),
 	};
 	if (w * h == 0) {
 		return;
@@ -250,7 +250,7 @@
 	glViewport(0, 0, width(), height());
 }
 
-void Texture::do_blit(const FloatRect& dst_rect,
+void Texture::do_blit(const Rectf& dst_rect,
                       const BlitData& texture,
                       float opacity,
                       BlendMode blend_mode) {
@@ -258,11 +258,11 @@
 		return;
 	}
 	setup_gl();
-	BlitProgram::instance().draw(dst_rect, 0.f, texture, BlitData{0, 0, 0, Rect()},
+	BlitProgram::instance().draw(dst_rect, 0.f, texture, BlitData{0, 0, 0, Rectf()},
 	                             RGBAColor(0, 0, 0, 255 * opacity), blend_mode);
 }
 
-void Texture::do_blit_blended(const FloatRect& dst_rect,
+void Texture::do_blit_blended(const Rectf& dst_rect,
                               const BlitData& texture,
                               const BlitData& mask,
                               const RGBColor& blend) {
@@ -274,7 +274,7 @@
 	BlitProgram::instance().draw(dst_rect, 0.f, texture, mask, blend, BlendMode::UseAlpha);
 }
 
-void Texture::do_blit_monochrome(const FloatRect& dst_rect,
+void Texture::do_blit_monochrome(const Rectf& dst_rect,
                                  const BlitData& texture,
                                  const RGBAColor& blend) {
 	if (blit_data_.texture_id == 0) {
@@ -293,9 +293,7 @@
 	   {DrawLineProgram::Arguments{vertices, 0.f, BlendMode::UseAlpha}});
 }
 
-void Texture::do_fill_rect(const FloatRect& dst_rect,
-                           const RGBAColor& color,
-                           BlendMode blend_mode) {
+void Texture::do_fill_rect(const Rectf& dst_rect, const RGBAColor& color, BlendMode blend_mode) {
 	if (blit_data_.texture_id == 0) {
 		return;
 	}

=== modified file 'src/graphic/texture.h'
--- src/graphic/texture.h	2016-08-04 15:49:05 +0000
+++ src/graphic/texture.h	2016-10-24 20:07:47 +0000
@@ -39,7 +39,7 @@
 
 	// Create a logical texture that is a 'subrect' (in Pixel) in
 	// another texture. Ownership of 'texture' is not taken.
-	Texture(const GLuint texture, const Rect& subrect, int parent_w, int parent_h);
+	Texture(const GLuint texture, const Recti& subrect, int parent_w, int parent_h);
 
 	virtual ~Texture();
 
@@ -83,20 +83,20 @@
 	void init(uint16_t w, uint16_t h);
 
 	// Implements surface.
-	void do_blit(const FloatRect& dst_rect,
+	void do_blit(const Rectf& dst_rect,
 	             const BlitData& texture,
 	             float opacity,
 	             BlendMode blend_mode) override;
-	void do_blit_blended(const FloatRect& dst_rect,
+	void do_blit_blended(const Rectf& dst_rect,
 	                     const BlitData& texture,
 	                     const BlitData& mask,
 	                     const RGBColor& blend) override;
-	void do_blit_monochrome(const FloatRect& dst_rect,
+	void do_blit_monochrome(const Rectf& dst_rect,
 	                        const BlitData& texture,
 	                        const RGBAColor& blend) override;
 	void do_draw_line_strip(std::vector<DrawLineProgram::PerVertexData> vertices) override;
 	void
-	do_fill_rect(const FloatRect& dst_rect, const RGBAColor& color, BlendMode blend_mode) override;
+	do_fill_rect(const Rectf& dst_rect, const RGBAColor& color, BlendMode blend_mode) override;
 
 	// True if we own the texture, i.e. if we need to delete it.
 	bool owns_texture_;

=== modified file 'src/graphic/texture_atlas.cc'
--- src/graphic/texture_atlas.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/texture_atlas.cc	2016-10-24 20:07:47 +0000
@@ -34,14 +34,14 @@
 
 }  // namespace
 
-TextureAtlas::Node::Node(const Rect& init_r) : used(false), r(init_r) {
+TextureAtlas::Node::Node(const Recti& init_r) : used(false), r(init_r) {
 }
 
 void TextureAtlas::Node::split(int item_w, int item_h) {
 	assert(!used);
 
-	down.reset(new Node(Rect(r.x, r.y + item_h, r.w, r.h - item_h)));
-	right.reset(new Node(Rect(r.x + item_w, r.y, r.w - item_w, item_h)));
+	down.reset(new Node(Recti(r.x, r.y + item_h, r.w, r.h - item_h)));
+	right.reset(new Node(Recti(r.x + item_w, r.y, r.w - item_w, item_h)));
 	used = true;
 
 	// Note: we do not change the size of the root. It is not needed
@@ -77,21 +77,21 @@
 std::unique_ptr<Texture> TextureAtlas::pack_as_many_as_possible(
    const int max_dimension, const int texture_atlas_index, std::vector<PackedTexture>* pack_info) {
 
-	std::unique_ptr<Node> root(new Node(Rect(0, 0, blocks_.begin()->texture->width() + kPadding,
-	                                         blocks_.begin()->texture->height() + kPadding)));
+	std::unique_ptr<Node> root(new Node(Recti(0, 0, blocks_.begin()->texture->width() + kPadding,
+	                                          blocks_.begin()->texture->height() + kPadding)));
 
 	const auto grow_right = [&root](int delta_w) {
-		std::unique_ptr<Node> new_root(new Node(Rect(0, 0, root->r.w + delta_w, root->r.h)));
+		std::unique_ptr<Node> new_root(new Node(Recti(0, 0, root->r.w + delta_w, root->r.h)));
 		new_root->used = true;
-		new_root->right.reset(new Node(Rect(root->r.w, 0, delta_w, root->r.h)));
+		new_root->right.reset(new Node(Recti(root->r.w, 0, delta_w, root->r.h)));
 		new_root->down.reset(root.release());
 		root.reset(new_root.release());
 	};
 
 	const auto grow_down = [&root](int delta_h) {
-		std::unique_ptr<Node> new_root(new Node(Rect(0, 0, root->r.w, root->r.h + delta_h)));
+		std::unique_ptr<Node> new_root(new Node(Recti(0, 0, root->r.w, root->r.h + delta_h)));
 		new_root->used = true;
-		new_root->down.reset(new Node(Rect(0, root->r.h, root->r.w, delta_h)));
+		new_root->down.reset(new Node(Recti(0, root->r.h, root->r.w, delta_h)));
 		new_root->right.reset(root.release());
 		root.reset(new_root.release());
 	};
@@ -134,20 +134,20 @@
 	}
 
 	std::unique_ptr<Texture> texture_atlas(new Texture(root->r.w, root->r.h));
-	texture_atlas->fill_rect(Rect(0, 0, root->r.w, root->r.h), RGBAColor(0, 0, 0, 0));
+	texture_atlas->fill_rect(Rectf(0, 0, root->r.w, root->r.h), RGBAColor(0, 0, 0, 0));
 
 	const auto packed_texture_id = texture_atlas->blit_data().texture_id;
 	for (Block& block : packed) {
 		texture_atlas->blit(
-		   Rect(block.node->r.x, block.node->r.y, block.texture->width(), block.texture->height()),
-		   *block.texture, Rect(0, 0, block.texture->width(), block.texture->height()), 1.,
+		   Rectf(block.node->r.x, block.node->r.y, block.texture->width(), block.texture->height()),
+		   *block.texture, Rectf(0, 0, block.texture->width(), block.texture->height()), 1.,
 		   BlendMode::Copy);
 
 		pack_info->emplace_back(PackedTexture(
 		   texture_atlas_index, block.index,
 		   std::unique_ptr<Texture>(new Texture(
 		      packed_texture_id,
-		      Rect(block.node->r.origin(), block.texture->width(), block.texture->height()),
+		      Recti(block.node->r.origin(), block.texture->width(), block.texture->height()),
 		      root->r.w, root->r.h))));
 	}
 	blocks_ = not_packed;

=== modified file 'src/graphic/texture_atlas.h'
--- src/graphic/texture_atlas.h	2016-08-04 15:49:05 +0000
+++ src/graphic/texture_atlas.h	2016-10-24 20:07:47 +0000
@@ -68,11 +68,11 @@
 
 private:
 	struct Node {
-		Node(const Rect& init_r);
+		Node(const Recti& init_r);
 		void split(int w, int h);
 
 		bool used;
-		Rect r;
+		Recti r;
 		std::unique_ptr<Node> right;
 		std::unique_ptr<Node> down;
 

=== modified file 'src/graphic/wordwrap.cc'
--- src/graphic/wordwrap.cc	2016-08-04 15:49:05 +0000
+++ src/graphic/wordwrap.cc	2016-10-24 20:07:47 +0000
@@ -303,7 +303,7 @@
  *
  * \note This also draws the caret, if any.
  */
-void WordWrap::draw(RenderTarget& dst, Point where, Align align, uint32_t caret) {
+void WordWrap::draw(RenderTarget& dst, Vector2i where, Align align, uint32_t caret) {
 	if (lines_.empty())
 		return;
 
@@ -329,7 +329,7 @@
 		if (where.y >= dst.height() || int32_t(where.y + fontheight) <= 0)
 			continue;
 
-		Point point(where.x, where.y);
+		Vector2f point(where.x, where.y);
 
 		if (static_cast<int>(alignment & UI::Align::kRight)) {
 			point.x += wrapwidth_ - LINE_MARGIN;
@@ -346,9 +346,9 @@
 			int caret_x = text_width(line_to_caret, style_.font->size());
 
 			const Image* caret_image = g_gr->images().get("images/ui_basic/caret.png");
-			Point caretpt;
+			Vector2f caretpt;
 			caretpt.x = point.x + caret_x - caret_image->width() + LINE_MARGIN;
-			caretpt.y = point.y + (fontheight - caret_image->height()) / 2;
+			caretpt.y = point.y + (fontheight - caret_image->height()) / 2.f;
 			dst.blit(caretpt, caret_image);
 		}
 	}

=== modified file 'src/graphic/wordwrap.h'
--- src/graphic/wordwrap.h	2016-08-04 15:49:05 +0000
+++ src/graphic/wordwrap.h	2016-10-24 20:07:47 +0000
@@ -21,7 +21,7 @@
 
 #include <string>
 
-#include "base/point.h"
+#include "base/vector.h"
 #include "graphic/align.h"
 #include "graphic/text_layout.h"
 
@@ -50,7 +50,7 @@
 	}
 
 	void draw(RenderTarget& dst,
-	          Point where,
+	          Vector2i where,
 	          Align align = UI::Align::kLeft,
 	          uint32_t caret = std::numeric_limits<uint32_t>::max());
 

=== modified file 'src/io/streamread.cc'
--- src/io/streamread.cc	2016-08-04 15:49:05 +0000
+++ src/io/streamread.cc	2016-10-24 20:07:47 +0000
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cstdarg>
 #include <cstdio>
+#include <cstring>
 
 #include "base/wexception.h"
 
@@ -89,6 +90,15 @@
 	return little_32(x);
 }
 
+float StreamRead::float_32() {
+	uint32_t x;
+	data_complete(&x, 4);
+	x = little_32(x);
+	float rv;
+	memcpy(&rv, &x, 4);
+	return rv;
+}
+
 std::string StreamRead::string() {
 	std::string x;
 	char ch;

=== modified file 'src/io/streamread.h'
--- src/io/streamread.h	2016-08-04 15:49:05 +0000
+++ src/io/streamread.h	2016-10-24 20:07:47 +0000
@@ -67,6 +67,7 @@
 	uint16_t unsigned_16();
 	int32_t signed_32();
 	uint32_t unsigned_32();
+	float float_32();
 	std::string string();
 	virtual char const* c_string() {
 		throw;

=== modified file 'src/io/streamwrite.cc'
--- src/io/streamwrite.cc	2016-08-04 15:49:05 +0000
+++ src/io/streamwrite.cc	2016-10-24 20:07:47 +0000
@@ -20,6 +20,7 @@
 #include "io/streamwrite.h"
 
 #include <cstdarg>
+#include <cstring>
 
 #include "base/wexception.h"
 

=== modified file 'src/io/streamwrite.h'
--- src/io/streamwrite.h	2016-08-04 15:49:05 +0000
+++ src/io/streamwrite.h	2016-10-24 20:07:47 +0000
@@ -82,6 +82,12 @@
 		uint32_t const y = little_32(x);
 		data(&y, 4);
 	}
+	void float_32(const float x) {
+		uint32_t y;
+		memcpy(&y, &x, 4);
+		y = little_32(y);
+		data(&y, 4);
+	}
 	void string(const std::string& str) {
 		data(str.c_str(), str.size() + 1);
 	}

=== modified file 'src/logic/CMakeLists.txt'
--- src/logic/CMakeLists.txt	2016-05-14 07:35:39 +0000
+++ src/logic/CMakeLists.txt	2016-10-24 20:07:47 +0000
@@ -119,6 +119,7 @@
     widelands_geometry_io.cc
     widelands_geometry_io.h
     widelands.h
+    map_objects/draw_text.h
     map_objects/attackable.h
     map_objects/bob.cc
     map_objects/bob.h
@@ -126,15 +127,13 @@
     map_objects/buildcost.h
     map_objects/checkstep.cc
     map_objects/checkstep.h
-    map_objects/immovable_program.h
     map_objects/immovable.cc
     map_objects/immovable.h
+    map_objects/immovable_program.h
     map_objects/map_object.cc
     map_objects/map_object.h
     map_objects/terrain_affinity.cc
     map_objects/terrain_affinity.h
-    map_objects/walkingdir.cc
-    map_objects/walkingdir.h
     map_objects/tribes/battle.cc
     map_objects/tribes/battle.h
     map_objects/tribes/bill_of_materials.h
@@ -181,15 +180,17 @@
     map_objects/tribes/warelist.h
     map_objects/tribes/wareworker.h
     map_objects/tribes/workarea_info.h
+    map_objects/tribes/worker.cc
+    map_objects/tribes/worker.h
     map_objects/tribes/worker_descr.cc
     map_objects/tribes/worker_descr.h
     map_objects/tribes/worker_program.cc
     map_objects/tribes/worker_program.h
-    map_objects/tribes/worker.cc
-    map_objects/tribes/worker.h
-    map_objects/world/critter_program.h
+    map_objects/walkingdir.cc
+    map_objects/walkingdir.h
     map_objects/world/critter.cc
     map_objects/world/critter.h
+    map_objects/world/critter_program.h
     map_objects/world/editor_category.cc
     map_objects/world/editor_category.h
     map_objects/world/map_gen.cc
@@ -209,6 +210,7 @@
     base_i18n
     base_log
     base_macros
+    base_math
     base_md5
     base_scoped_timer
     base_time_string

=== modified file 'src/logic/game.cc'
--- src/logic/game.cc	2016-08-04 15:49:05 +0000
+++ src/logic/game.cc	2016-10-24 20:07:47 +0000
@@ -455,7 +455,7 @@
 		}
 
 		if (get_ipl())
-			get_ipl()->move_view_to(map().get_starting_pos(get_ipl()->player_number()));
+			get_ipl()->center_view_on_coords(map().get_starting_pos(get_ipl()->player_number()));
 
 		// Prepare the map, set default textures
 		map().recalc_default_resources(world());

=== modified file 'src/logic/game_controller.h'
--- src/logic/game_controller.h	2016-08-04 15:49:05 +0000
+++ src/logic/game_controller.h	2016-10-24 20:07:47 +0000
@@ -100,9 +100,6 @@
 	/**
 	 * Report a player result once he has left the game. This may be done through lua
 	 * by the win_condition scripts.
-	 * \param player : the player idx;
-	 * \param result : the player result
-	 * \param info : The info string (\see \struct PlayerEndStatus)
 	 */
 	virtual void report_result(uint8_t /* player */,
 	                           Widelands::PlayerEndResult /*result*/,

=== modified file 'src/logic/map_objects/bob.cc'
--- src/logic/map_objects/bob.cc	2016-08-04 15:49:05 +0000
+++ src/logic/map_objects/bob.cc	2016-10-24 20:07:47 +0000
@@ -25,6 +25,7 @@
 #include <stdint.h>
 
 #include "base/macros.h"
+#include "base/math.h"
 #include "base/wexception.h"
 #include "economy/route.h"
 #include "economy/transfer.h"
@@ -88,7 +89,6 @@
 
 Bob::Bob(const BobDescr& init_descr)
    : MapObject(&init_descr),
-     owner_(nullptr),
      position_(FCoords(Coords(0, 0), nullptr)),  // not linked anywhere
      linknext_(nullptr),
      linkpprev_(nullptr),
@@ -685,45 +685,51 @@
 		return schedule_act(game, walkend_ - game.get_gametime());
 }
 
-/// Calculates the actual position to draw on from the base node position.
-/// This function takes walking etc. into account.
-///
-/// pos is the location, in pixels, of the node position_ (height is already
-/// taken into account).
-Point Bob::calc_drawpos(const EditorGameBase& game, const Point pos) const {
+// Calculates the actual position to draw on from the base node position. This
+// function takes walking etc. into account.
+//
+// pos is the location, in pixels, of the node position_ on screen with scale
+// and height taken into account.
+Vector2f Bob::calc_drawpos(const EditorGameBase& game,
+                             const Vector2f& field_on_dst,
+                             const float scale) const {
 	const Map& map = game.get_map();
 	const FCoords end = position_;
 	FCoords start;
-	Point spos = pos, epos = pos;
+	Vector2f spos = field_on_dst;
+	Vector2f epos = field_on_dst;
+
+	const float triangle_w = kTriangleWidth * scale;
+	const float triangle_h = kTriangleHeight * scale;
 
 	switch (walking_) {
 	case WALK_NW:
 		map.get_brn(end, &start);
-		spos.x += kTriangleWidth / 2;
-		spos.y += kTriangleHeight;
+		spos.x += triangle_w / 2.f;
+		spos.y += triangle_h;
 		break;
 	case WALK_NE:
 		map.get_bln(end, &start);
-		spos.x -= kTriangleWidth / 2;
-		spos.y += kTriangleHeight;
+		spos.x -= triangle_w / 2.f;
+		spos.y += triangle_h;
 		break;
 	case WALK_W:
 		map.get_rn(end, &start);
-		spos.x += kTriangleWidth;
+		spos.x += triangle_w;
 		break;
 	case WALK_E:
 		map.get_ln(end, &start);
-		spos.x -= kTriangleWidth;
+		spos.x -= triangle_w;
 		break;
 	case WALK_SW:
 		map.get_trn(end, &start);
-		spos.x += kTriangleWidth / 2;
-		spos.y -= kTriangleHeight;
+		spos.x += triangle_w / 2.f;
+		spos.y -= triangle_h;
 		break;
 	case WALK_SE:
 		map.get_tln(end, &start);
-		spos.x -= kTriangleWidth / 2;
-		spos.y -= kTriangleHeight;
+		spos.x -= triangle_w / 2.f;
+		spos.y -= triangle_h;
 		break;
 
 	case IDLE:
@@ -732,37 +738,39 @@
 	}
 
 	if (start.field) {
-		spos.y += end.field->get_height() * kHeightFactor;
-		spos.y -= start.field->get_height() * kHeightFactor;
+		spos.y += end.field->get_height() * kHeightFactor * scale;
+		spos.y -= start.field->get_height() * kHeightFactor * scale;
 
 		assert(static_cast<uint32_t>(walkstart_) <= game.get_gametime());
 		assert(walkstart_ < walkend_);
-		float f = static_cast<float>(game.get_gametime() - walkstart_) / (walkend_ - walkstart_);
-
-		if (f < 0)
-			f = 0;
-		else if (f > 1)
-			f = 1;
-
-		epos.x = static_cast<int32_t>(f * epos.x + (1 - f) * spos.x);
-		epos.y = static_cast<int32_t>(f * epos.y + (1 - f) * spos.y);
+		const float f = math::clamp(
+				static_cast<float>(game.get_gametime() - walkstart_) / (walkend_ - walkstart_),
+				0.f, 1.f);
+		epos.x = f * epos.x + (1.f - f) * spos.x;
+		epos.y = f * epos.y + (1.f - f) * spos.y;
 	}
-
 	return epos;
 }
 
 /// It LERPs between start and end position when we are walking.
 /// Note that the current node is actually the node that we are walking to, not
 /// the the one that we start from.
-void Bob::draw(const EditorGameBase& egbase, RenderTarget& dst, const Point& pos) const {
-	if (anim_) {
-		auto* const owner = get_owner();
-		if (owner != nullptr) {
-			dst.blit_animation(calc_drawpos(egbase, pos), anim_, egbase.get_gametime() - animstart_,
-			                   owner->get_playercolor());
-		} else {
-			dst.blit_animation(calc_drawpos(egbase, pos), anim_, egbase.get_gametime() - animstart_);
-		}
+void Bob::draw(const EditorGameBase& egbase,
+               const DrawText&,
+               const Vector2f& field_on_dst,
+               const float scale,
+               RenderTarget* dst) const {
+	if (!anim_) {
+		return;
+	}
+
+	auto* const owner = get_owner();
+	const Vector2f point_on_dst = calc_drawpos(egbase, field_on_dst, scale);
+	if (owner != nullptr) {
+		dst->blit_animation(
+		   point_on_dst, scale, anim_, egbase.get_gametime() - animstart_, owner->get_playercolor());
+	} else {
+		dst->blit_animation(point_on_dst, scale, anim_, egbase.get_gametime() - animstart_);
 	}
 }
 

=== modified file 'src/logic/map_objects/bob.h'
--- src/logic/map_objects/bob.h	2016-08-04 15:49:05 +0000
+++ src/logic/map_objects/bob.h	2016-10-24 20:07:47 +0000
@@ -21,10 +21,11 @@
 #define WL_LOGIC_MAP_OBJECTS_BOB_H
 
 #include "base/macros.h"
-#include "base/point.h"
+#include "base/vector.h"
 #include "economy/route.h"
 #include "graphic/animation.h"
 #include "graphic/diranimations.h"
+#include "logic/map_objects/draw_text.h"
 #include "logic/map_objects/map_object.h"
 #include "logic/map_objects/walkingdir.h"
 #include "logic/widelands_geometry.h"
@@ -240,11 +241,9 @@
 	void schedule_destroy(Game&);
 	void schedule_act(Game&, uint32_t tdelta);
 	void skip_act();
-	Point calc_drawpos(const EditorGameBase&, Point) const;
+	Vector2f calc_drawpos(const EditorGameBase&, const Vector2f& field_on_dst, float scale) const;
 	void set_owner(Player*);
-	Player* get_owner() const {
-		return owner_;
-	}
+
 	void set_position(EditorGameBase&, const Coords&);
 	const FCoords& get_position() const {
 		return position_;
@@ -260,7 +259,15 @@
 	///    onto the \p to node if this function allows it to.
 	virtual bool check_node_blocked(Game&, const FCoords&, bool commit);
 
-	virtual void draw(const EditorGameBase&, RenderTarget&, const Point&) const;
+	// Draws the bob onto the screen with 'field_on_dst' being the position of
+	// the field associated with this bob (if it is walking, that is its
+	// starting field) in pixel space of 'dst' (including scale). The 'scale' is
+	// required to draw the bob in the right size.
+	virtual void draw(const EditorGameBase&,
+	                  const DrawText& draw_text,
+	                  const Vector2f& field_on_dst,
+	                  float scale,
+	                  RenderTarget* dst) const;
 
 	// For debug
 	void log_general_info(const EditorGameBase&) override;
@@ -366,7 +373,6 @@
 	static Task const taskMovepath;
 	static Task const taskMove;
 
-	Player* owner_;     ///< can be 0
 	FCoords position_;  ///< where are we right now?
 	Bob* linknext_;     ///< next object on this node
 	Bob** linkpprev_;

=== added file 'src/logic/map_objects/draw_text.h'
--- src/logic/map_objects/draw_text.h	1970-01-01 00:00:00 +0000
+++ src/logic/map_objects/draw_text.h	2016-10-24 20:07:47 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2006-2016 by the Widelands Development Team
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef WL_LOGIC_MAP_OBJECTS_DRAW_TEXT_H
+#define WL_LOGIC_MAP_OBJECTS_DRAW_TEXT_H
+
+enum DrawText {
+	kNone = 0,
+	kCensus = 1,
+	kStatistics = 2,
+};
+
+inline DrawText operator|(DrawText a, DrawText b) {
+	return static_cast<DrawText>(static_cast<int>(a) | static_cast<int>(b));
+}
+
+#endif  // end of include guard: WL_LOGIC_MAP_OBJECTS_DRAW_TEXT_H
+

=== modified file 'src/logic/map_objects/immovable.cc'
--- src/logic/map_objects/immovable.cc	2016-08-04 15:49:05 +0000
+++ src/logic/map_objects/immovable.cc	2016-10-24 20:07:47 +0000
@@ -324,7 +324,6 @@
  * Create an immovable of this type
 */
 Immovable& ImmovableDescr::create(EditorGameBase& egbase, const Coords& coords) const {
-	assert(this != nullptr);
 	Immovable& result = *new Immovable(*this);
 	result.position_ = coords;
 	result.init(egbase);
@@ -341,7 +340,6 @@
 
 Immovable::Immovable(const ImmovableDescr& imm_descr)
    : BaseImmovable(imm_descr),
-     owner_(nullptr),
      anim_(0),
      animstart_(0),
      program_(nullptr),
@@ -439,19 +437,26 @@
 	}
 }
 
-void Immovable::draw(const EditorGameBase& game,
-                     RenderTarget& dst,
-                     const FCoords&,
-                     const Point& pos) {
-	if (anim_) {
-		if (!anim_construction_total_)
-			dst.blit_animation(pos, anim_, game.get_gametime() - animstart_);
-		else
-			draw_construction(game, dst, pos);
+void Immovable::draw(uint32_t gametime,
+                     const DrawText draw_text,
+                     const Vector2f& point_on_dst,
+                     float scale,
+                     RenderTarget* dst) {
+	if (!anim_) {
+		return;
+	}
+	if (!anim_construction_total_) {
+		dst->blit_animation(point_on_dst, scale, anim_, gametime - animstart_);
+	} else {
+		draw_construction(gametime, draw_text, point_on_dst, scale, dst);
 	}
 }
 
-void Immovable::draw_construction(const EditorGameBase& game, RenderTarget& dst, const Point pos) {
+void Immovable::draw_construction(const uint32_t gametime,
+                                  const DrawText draw_text,
+                                  const Vector2f& point_on_dst,
+                                  const float scale,
+                                  RenderTarget* dst) {
 	const ImmovableProgram::ActConstruction* constructionact = nullptr;
 	if (program_ptr_ < program_->size())
 		constructionact =
@@ -462,7 +467,7 @@
 	uint32_t done = 0;
 	if (anim_construction_done_ > 0) {
 		done = steptime * (anim_construction_done_ - 1);
-		done += std::min(steptime, game.get_gametime() - animstart_);
+		done += std::min(steptime, gametime - animstart_);
 	}
 
 	uint32_t total = anim_construction_total_ * steptime;
@@ -483,21 +488,19 @@
 	const RGBColor& player_color = get_owner()->get_playercolor();
 	if (current_frame > 0) {
 		// Not the first pic, so draw the previous one in the back
-		dst.blit_animation(pos, anim_, (current_frame - 1) * frametime, player_color);
+		dst->blit_animation(point_on_dst, scale, anim_, (current_frame - 1) * frametime, player_color);
 	}
 
 	assert(lines <= curh);
-	dst.blit_animation(pos, anim_, current_frame * frametime, player_color,
-	                   Rect(Point(0, curh - lines), curw, lines));
+	dst->blit_animation(point_on_dst, scale, anim_, current_frame * frametime, player_color,
+	                   Recti(Vector2i(0, curh - lines), curw, lines));
 
 	// Additionally, if statistics are enabled, draw a progression string
-	uint32_t const display_flags = game.get_ibase()->get_display_flags();
-	do_draw_info(display_flags & InteractiveBase::dfShowCensus, descr().descname(),
-	             display_flags & InteractiveBase::dfShowStatistics,
+	do_draw_info(draw_text, descr().descname(),
 	             (boost::format("<font color=%s>%s</font>") % UI_FONT_CLR_DARK.hex_value() %
 	              (boost::format(_("%i%% built")) % (100 * done / total)).str())
 	                .str(),
-	             dst, pos);
+	             point_on_dst, scale, dst);
 }
 
 /**
@@ -1179,7 +1182,7 @@
  * Zero-initialize
 */
 PlayerImmovable::PlayerImmovable(const MapObjectDescr& mo_descr)
-   : BaseImmovable(mo_descr), owner_(nullptr), economy_(nullptr) {
+   : BaseImmovable(mo_descr), economy_(nullptr) {
 }
 
 /**

=== modified file 'src/logic/map_objects/immovable.h'
--- src/logic/map_objects/immovable.h	2016-08-04 15:49:05 +0000
+++ src/logic/map_objects/immovable.h	2016-10-24 20:07:47 +0000
@@ -26,6 +26,7 @@
 #include "base/macros.h"
 #include "graphic/animation.h"
 #include "logic/map_objects/buildcost.h"
+#include "logic/map_objects/draw_text.h"
 #include "logic/map_objects/map_object.h"
 #include "logic/widelands_geometry.h"
 #include "notifications/note_ids.h"
@@ -91,7 +92,18 @@
 	 * if one can be chosen as main.
 	 */
 	virtual PositionList get_positions(const EditorGameBase&) const = 0;
-	virtual void draw(const EditorGameBase&, RenderTarget&, const FCoords&, const Point&) = 0;
+
+	// Draw this immovable onto 'dst' choosing the frame appropriate for
+	// 'gametime'. 'draw_text' decides if census and statistics are written too.
+	// The 'coords_to_draw' are passed one to give objects that occupy multiple
+	// fields a way to only draw themselves once. The 'point_on_dst' determines
+	// the point for the hotspot of the animation and 'scale' determines how big
+	// the immovable will be plotted.
+	virtual void draw(uint32_t gametime,
+	          DrawText draw_text,
+	          const Vector2f& point_on_dst,
+				 float scale,
+	          RenderTarget* dst) = 0;
 
 	static int32_t string_to_size(const std::string& size);
 	static std::string size_to_string(int32_t size);
@@ -189,10 +201,7 @@
 	Immovable(const ImmovableDescr&);
 	~Immovable();
 
-	Player* get_owner() const {
-		return owner_;
-	}
-	void set_owner(Player* player);
+	void set_owner(Player*);
 
 	Coords get_position() const {
 		return position_;
@@ -212,8 +221,11 @@
 	void init(EditorGameBase&) override;
 	void cleanup(EditorGameBase&) override;
 	void act(Game&, uint32_t data) override;
-
-	void draw(const EditorGameBase&, RenderTarget&, const FCoords&, const Point&) override;
+	void draw(uint32_t gametime,
+	          DrawText draw_text,
+	          const Vector2f& point_on_dst,
+	          float scale,
+	          RenderTarget* dst) override;
 
 	void switch_program(Game& game, const std::string& programname);
 	bool construct_ware(Game& game, DescriptionIndex index);
@@ -230,7 +242,6 @@
 	}
 
 protected:
-	Player* owner_;
 	Coords position_;
 
 	uint32_t anim_;
@@ -289,8 +300,11 @@
 
 private:
 	void increment_program_pointer();
-
-	void draw_construction(const EditorGameBase&, RenderTarget&, Point);
+	void draw_construction(uint32_t gametime,
+	                       DrawText draw_text,
+	                       const Vector2f& point_on_dst,
+	                       float scale,
+	                       RenderTarget* dst);
 };
 
 /**
@@ -360,7 +374,6 @@
 	void cleanup(EditorGameBase&) override;
 
 private:
-	Player* owner_;
 	Economy* economy_;