XEEN: Cleanup of the map dialog class

6 files changed, 465 insertions, 439 deletions

diff --git a/engines/xeen/dialogs_automap.cpp b/engines/xeen/dialogs_automap.cpp
deleted file mode 100644
index 93d70fe456..0000000000
--- a/engines/xeen/dialogs_automap.cpp
+++ /dev/null
@@ -1,427 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- */
-
-#include "xeen/dialogs_automap.h"
-#include "xeen/resources.h"
-#include "xeen/xeen.h"
-
-namespace Xeen {
-
-
-void AutoMapDialog::show(XeenEngine *vm) {
-	AutoMapDialog *dlg = new AutoMapDialog(vm);
-	dlg->execute();
-	delete dlg;
-}
-
-void AutoMapDialog::execute() {
-	EventsManager &events = *_vm->_events;
-	Interface &intf = *_vm->_interface;
-	Map &map = *_vm->_map;
-	Party &party = *_vm->_party;
-	Windows &windows = *_vm->_windows;
-	int frame2 = intf._overallFrame * 2;
-	bool frameEndFlag = false;
-
-	Common::Point pt = party._mazePosition;
-	Common::Point arrowPt;
-	SpriteResource globalSprites;
-	globalSprites.load("global.icn");
-
-	if (pt.x < 8 && map.mazeData()._surroundingMazes._west == 0) {
-		arrowPt.x = pt.x * 10 + 4;
-	} else if (pt.x > 23) {
-		arrowPt.x = pt.x * 10 + 100;
-		pt.x = 23;
-	} else if (pt.x > 8 && map.mazeData()._surroundingMazes._east == 0) {
-		arrowPt.x = pt.x * 10 + 4;
-		pt.x = 7;
-	} else {
-		arrowPt.x = 74;
-	}
-
-	if (pt.y < 8 && map.mazeData()._surroundingMazes._south == 0) {
-		arrowPt.y = ((15 - pt.y) << 3) + 13;
-		pt.y = 8;
-	} else if (pt.y > 24) {
-		arrowPt.y = ((15 - (pt.y - 24)) << 3) + 13;
-		pt.y = 24;
-	} else if (pt.y >= 8 && map.mazeData()._surroundingMazes._north == 0) {
-		arrowPt.y = ((15 - pt.y) << 3) + 13;
-		pt.y = 8;
-	} else {
-		arrowPt.y = 69;
-	}
-
-	windows[5].open();
-//	MazeData &mazeData = map.mazeDataCurrent();
-	bool drawFlag = true;
-	int v;
-
-	events.updateGameCounter();
-	do {
-		if (drawFlag)
-			intf.draw3d(false, true);
-		windows[5].writeString("\r");
-
-		if (map._isOutdoors) {
-			// Draw outdoors map
-			for (int yp = 38, yDiff = pt.y + 7; yp < 166; --yDiff, yp += 8) {
-				for (int xp = 80, xDiff = pt.x - 7; xp < 240; xp += 10, ++xDiff) {
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 0);
-
-					if (map._currentSteppedOn) {
-						map._tileSprites.draw(0, map.mazeDataCurrent()._surfaceTypes[v],
-							Common::Point(xp, yp));
-					}
-				}
-			}
-
-			for (int yp = 38, yDiff = pt.y + 7; yp < 166; --yDiff, yp += 8) {
-				for (int xp = 80, xDiff = pt.x - 7; xp < 240; xp += 10, ++xDiff) {
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 4);
-					int wallType = map.mazeDataCurrent()._wallTypes[v];
-
-					if (wallType && map._currentSteppedOn)
-						map._tileSprites.draw(0, wallType, Common::Point(xp, yp));
-				}
-			}
-
-			for (int yp = 38, yDiff = pt.y + 7; yp < 166; yp += 8, --yDiff) {
-				for (int xp = 80, xDiff = -7; xp < 240; xp += 10, ++xDiff) {
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 8);
-
-					if (v && map._currentSteppedOn)
-						map._tileSprites.draw(0, 1, Common::Point(xp, yp));
-				}
-			}
-		} else {
-			// Draw indoors map
-			frame2 = (frame2 + 2) % 8;
-
-			// Draw default ground for all the valid explored areas
-			for (int yp = 38, yDiff = pt.y + 7; yp < 166; yp += 8, --yDiff) {
-				for (int xp = 80, xDiff = pt.x - 7; xp < 240; xp += 10, ++xDiff) {
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 0, 0xffff);
-
-					if (v != INVALID_CELL && map._currentSteppedOn)
-						map._tileSprites.draw(0, 0, Common::Point(xp, yp));
-				}
-			}
-
-			// Draw thinner ground tiles on the left edge of the map
-			for (int yp = 43, yDiff = pt.y + 7; yp < 171; yp += 8, --yDiff) {
-				v = map.mazeLookup(Common::Point(pt.x - 8, yDiff), 0, 0xffff);
-
-				if (v != INVALID_CELL && map._currentSurfaceId != 0 && map._currentSteppedOn)
-					map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
-						map._currentSurfaceId], Common::Point(75, yp));
-			}
-
-			// Draw thin tile portion on top-left corner of map
-			v = map.mazeLookup(Common::Point(pt.x - 8, pt.y + 8), 0, 0xffff);
-			if (v != INVALID_CELL && map._currentSurfaceId != 0 && map._currentSteppedOn)
-				map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
-					map._currentSurfaceId], Common::Point(75, 35));
-
-			// Draw any thin tiles at the very top of the map
-			for (int xp = 85, xDiff = pt.x - 7; xp < 245; xp += 10, ++xDiff) {
-				v = map.mazeLookup(Common::Point(xDiff, pt.y + 8), 0, 0xffff);
-
-				if (v != INVALID_CELL && map._currentSurfaceId != 0 && map._currentSteppedOn)
-					map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
-						map._currentSurfaceId], Common::Point(xp, 35));
-			}
-
-			// Draw the default ground tiles
-			for (int yp = 43, yDiff = pt.y + 7; yp < 171; yp += 8, --yDiff) {
-				for (int xp = 85, xDiff = pt.x - 7; xp < 245; xp += 10, ++xDiff) {
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 0, 0xffff);
-
-					if (v != INVALID_CELL && map._currentSurfaceId && map._currentSteppedOn)
-						map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
-							map._currentSurfaceId], Common::Point(xp, yp));
-				}
-			}
-
-			// Draw walls on left and top edges of map
-			for (int xp = 80, yp = 158, xDiff = pt.x - 7, yDiff = pt.y - 8; xp < 250;
-					xp += 10, yp -= 8, ++xDiff, ++yDiff) {
-				// Draw walls on left edge of map
-				v = map.mazeLookup(Common::Point(pt.x - 8, yDiff), 12);
-
-				int frame;
-				switch (v) {
-				case SURFTYPE_DIRT:
-					frame = 18;
-					break;
-				case SURFTYPE_SNOW:
-					frame = 22;
-					break;
-				case SURFTYPE_SWAMP:
-				case SURFTYPE_CLOUD:
-					frame = 16;
-					break;
-				case SURFTYPE_LAVA:
-				case SURFTYPE_DWATER:
-					frame = 2;
-					break;
-				case SURFTYPE_DESERT:
-					frame = 30;
-					break;
-				case SURFTYPE_ROAD:
-					frame = 32;
-					break;
-				case SURFTYPE_TFLR:
-					frame = 20;
-					break;
-				case SURFTYPE_SKY:
-					frame = 28;
-					break;
-				case SURFTYPE_CROAD:
-					frame = 14;
-					break;
-				case SURFTYPE_SEWER:
-					frame = frame2 + 4;
-					break;
-				case SURFTYPE_SCORCH:
-					frame = 24;
-					break;
-				case SURFTYPE_SPACE:
-					frame = 26;
-					break;
-				default:
-					frame = -1;
-					break;
-				}
-
-				if (frame != -1 && map._currentSteppedOn)
-					map._tileSprites.draw(0, frame, Common::Point(70, yp));
-
-				// Draw walls on top edge of map
-				v = map.mazeLookup(Common::Point(xDiff, pt.y + 8), 0);
-
-				switch (v) {
-				case SURFTYPE_DIRT:
-					frame = 19;
-					break;
-				case SURFTYPE_GRASS:
-					frame = 35;
-					break;
-				case SURFTYPE_SNOW:
-					frame = 23;
-					break;
-				case SURFTYPE_SWAMP:
-				case SURFTYPE_CLOUD:
-					frame = 17;
-					break;
-				case SURFTYPE_LAVA:
-				case SURFTYPE_DWATER:
-					frame = 3;
-					break;
-				case SURFTYPE_DESERT:
-					frame = 31;
-					break;
-				case SURFTYPE_ROAD:
-					frame = 33;
-					break;
-				case SURFTYPE_TFLR:
-					frame = 21;
-					break;
-				case SURFTYPE_SKY:
-					frame = 29;
-					break;
-				case SURFTYPE_CROAD:
-					frame = 15;
-					break;
-				case SURFTYPE_SEWER:
-					frame = frame2 + 5;
-					break;
-				case SURFTYPE_SCORCH:
-					frame = 25;
-					break;
-				case SURFTYPE_SPACE:
-					frame = 27;
-					break;
-				default:
-					frame = -1;
-					break;
-				}
-
-				if (frame != -1 && map._currentSteppedOn)
-					map._tileSprites.draw(0, frame, Common::Point(xp, 30));
-			}
-
-			// Draw the front/back walls of cells in the minimap
-			for (int yCtr = 0, yp = 38, yDiff = pt.y + 7; yCtr < 16; ++yCtr, yp += 8, --yDiff) {
-				for (int xCtr = 0, xp = 80, xDiff = pt.x - 7; xCtr < 16; ++xCtr, xp += 10, ++xDiff) {
-					// Draw the arrow if at the correct position
-					if ((arrowPt.x / 10) == xCtr && (14 - (arrowPt.y / 10)) == yCtr && frameEndFlag) {
-						globalSprites.draw(0, party._mazeDirection + 1,
-							Common::Point(arrowPt.x + 81, arrowPt.y + 29));
-					}
-
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 12);
-					int frame;
-					switch (v) {
-					case SURFTYPE_DIRT:
-						frame = 18;
-						break;
-					case SURFTYPE_GRASS:
-						frame = 34;
-						break;
-					case SURFTYPE_SNOW:
-						frame = 22;
-						break;
-					case SURFTYPE_SWAMP:
-					case SURFTYPE_CLOUD:
-						frame = 16;
-						break;
-					case SURFTYPE_LAVA:
-					case SURFTYPE_DWATER:
-						frame = 2;
-						break;
-					case SURFTYPE_DESERT:
-						frame = 30;
-						break;
-					case SURFTYPE_ROAD:
-						frame = 32;
-						break;
-					case SURFTYPE_TFLR:
-						frame = 20;
-						break;
-					case SURFTYPE_SKY:
-						frame = 28;
-						break;
-					case SURFTYPE_CROAD:
-						frame = 14;
-						break;
-					case SURFTYPE_SEWER:
-						frame = frame2 + 4;
-						break;
-					case SURFTYPE_SCORCH:
-						frame = 24;
-						break;
-					case SURFTYPE_SPACE:
-						frame = 26;
-						break;
-					default:
-						frame = -1;
-						break;
-					}
-
-					if (frame != -1 && map._currentSteppedOn)
-						map._tileSprites.draw(0, frame, Common::Point(xp, yp));
-
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 0);
-					switch (v) {
-					case SURFTYPE_DIRT:
-						frame = 19;
-						break;
-					case SURFTYPE_GRASS:
-						frame = 35;
-						break;
-					case SURFTYPE_SNOW:
-						frame = 23;
-						break;
-					case SURFTYPE_SWAMP:
-					case SURFTYPE_CLOUD:
-						frame = 17;
-						break;
-					case SURFTYPE_LAVA:
-					case SURFTYPE_DWATER:
-						frame = 3;
-						break;
-					case SURFTYPE_DESERT:
-						frame = 31;
-						break;
-					case SURFTYPE_ROAD:
-						frame = 33;
-						break;
-					case SURFTYPE_TFLR:
-						frame = 21;
-						break;
-					case SURFTYPE_SKY:
-						frame = 29;
-						break;
-					case SURFTYPE_CROAD:
-						frame = 15;
-						break;
-					case SURFTYPE_SEWER:
-						frame = frame2 + 5;
-						break;
-					case SURFTYPE_SCORCH:
-						frame = 25;
-						break;
-					case SURFTYPE_SPACE:
-						frame = 27;
-						break;
-					default:
-						frame = -1;
-						break;
-					}
-
-					if (frame != -1 && map._currentSteppedOn)
-						map._tileSprites.draw(0, frame, Common::Point(xp, yp));
-				}
-			}
-
-			// Draw overlay on cells that haven't been stepped on yet
-			for (int yDiff = pt.y + 7, yp = 38; yp < 166; --yDiff, yp += 8) {
-				for (int xp = 80, xDiff = pt.x - 7; xp < 240; xp += 10, ++xDiff) {
-					v = map.mazeLookup(Common::Point(xDiff, yDiff), 0, 0xffff);
-
-					if (v == INVALID_CELL || !map._currentSteppedOn)
-						map._tileSprites.draw(0, 1, Common::Point(xp, yp));
-				}
-			}
-		}
-
-		windows[5].frame();
-		if (!map._isOutdoors) {
-			map._tileSprites.draw(0, 52, Common::Point(76, 30));
-		} else if (frameEndFlag) {
-			globalSprites.draw(0, party._mazeDirection + 1,
-				Common::Point(arrowPt.x + 76, arrowPt.y + 25));
-		}
-
-		if (events.timeElapsed() > 5) {
-			// Set the flag to make the basic arrow blinking effect
-			frameEndFlag = !frameEndFlag;
-			events.updateGameCounter();
-		}
-
-		windows[5].writeString(Common::String::format(Res.MAP_TEXT,
-			map._mazeName.c_str(), party._mazePosition.x,
-			party._mazePosition.y, Res.DIRECTION_TEXT[party._mazeDirection]));
-		windows[5].update();
-		windows[3].update();
-
-		events.pollEvents();
-		drawFlag = false;
-	} while (!_vm->shouldQuit() && !events.isKeyMousePressed());
-
-	events.clearEvents();
-	windows[5].close();
-}
-
-} // End of namespace Xeen
diff --git a/engines/xeen/dialogs_map.cpp b/engines/xeen/dialogs_map.cpp
new file mode 100644
index 0000000000..6f225d5b2c
--- /dev/null
+++ b/engines/xeen/dialogs_map.cpp
@@ -0,0 +1,434 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "xeen/dialogs_map.h"
+#include "xeen/resources.h"
+#include "xeen/xeen.h"
+
+namespace Xeen {
+
+void MapDialog::show(XeenEngine *vm) {
+	MapDialog *dlg = new MapDialog(vm);
+	dlg->execute();
+	delete dlg;
+}
+
+void MapDialog::execute() {
+	EventsManager &events = *_vm->_events;
+	Interface &intf = *_vm->_interface;
+	Map &map = *_vm->_map;
+	Party &party = *_vm->_party;
+	Windows &windows = *_vm->_windows;
+
+	_pt = party._mazePosition;
+	_globalSprites.load("global.icn");
+
+	if (_pt.x < 8 && map.mazeData()._surroundingMazes._west == 0) {
+		_arrowPt.x = _pt.x * 10 + 4;
+	} else if (_pt.x > 23) {
+		_arrowPt.x = _pt.x * 10 + 100;
+		_pt.x = 23;
+	} else if (_pt.x > 8 && map.mazeData()._surroundingMazes._east == 0) {
+		_arrowPt.x = _pt.x * 10 + 4;
+		_pt.x = 7;
+	} else {
+		_arrowPt.x = 74;
+	}
+
+	if (_pt.y < 8 && map.mazeData()._surroundingMazes._south == 0) {
+		_arrowPt.y = ((15 - _pt.y) << 3) + 13;
+		_pt.y = 8;
+	} else if (_pt.y > 24) {
+		_arrowPt.y = ((15 - (_pt.y - 24)) << 3) + 13;
+		_pt.y = 24;
+	} else if (_pt.y >= 8 && map.mazeData()._surroundingMazes._north == 0) {
+		_arrowPt.y = ((15 - _pt.y) << 3) + 13;
+		_pt.y = 8;
+	} else {
+		_arrowPt.y = 69;
+	}
+
+	windows[5].open();
+	bool drawFlag = true;
+
+	events.updateGameCounter();
+	do {
+		if (drawFlag)
+			intf.draw3d(false, true);
+		windows[5].writeString("\r");
+
+		if (map._isOutdoors)
+			drawOutdoors();
+		else
+			drawIndoors();
+
+		windows[5].frame();
+		if (!map._isOutdoors) {
+			map._tileSprites.draw(0, 52, Common::Point(76, 30));
+		} else if (_frameEndFlag) {
+			_globalSprites.draw(0, party._mazeDirection + 1,
+				Common::Point(_arrowPt.x + 76, _arrowPt.y + 25));
+		}
+
+		if (events.timeElapsed() > 5) {
+			// Set the flag to make the basic arrow blinking effect
+			_frameEndFlag = !_frameEndFlag;
+			events.updateGameCounter();
+		}
+
+		windows[5].writeString(Common::String::format(Res.MAP_TEXT,
+			map._mazeName.c_str(), party._mazePosition.x,
+			party._mazePosition.y, Res.DIRECTION_TEXT[party._mazeDirection]));
+		windows[5].update();
+		windows[3].update();
+
+		events.pollEvents();
+		drawFlag = false;
+	} while (!_vm->shouldQuit() && !events.isKeyMousePressed());
+
+	events.clearEvents();
+	windows[5].close();
+}
+
+void MapDialog::drawOutdoors() {
+	Map &map = *g_vm->_map;
+	int v;
+
+	// Draw outdoors map
+	for (int yp = 38, yDiff = _pt.y + 7; yp < 166; --yDiff, yp += 8) {
+		for (int xp = 80, xDiff = _pt.x - 7; xp < 240; xp += 10, ++xDiff) {
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 0);
+
+			if (map._currentSteppedOn) {
+				map._tileSprites.draw(0, map.mazeDataCurrent()._surfaceTypes[v],
+					Common::Point(xp, yp));
+			}
+		}
+	}
+
+	for (int yp = 38, yDiff = _pt.y + 7; yp < 166; --yDiff, yp += 8) {
+		for (int xp = 80, xDiff = _pt.x - 7; xp < 240; xp += 10, ++xDiff) {
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 4);
+			int wallType = map.mazeDataCurrent()._wallTypes[v];
+
+			if (wallType && map._currentSteppedOn)
+				map._tileSprites.draw(0, wallType, Common::Point(xp, yp));
+		}
+	}
+
+	for (int yp = 38, yDiff = _pt.y + 7; yp < 166; yp += 8, --yDiff) {
+		for (int xp = 80, xDiff = -7; xp < 240; xp += 10, ++xDiff) {
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 8);
+
+			if (v && map._currentSteppedOn)
+				map._tileSprites.draw(0, 1, Common::Point(xp, yp));
+		}
+	}
+}
+
+void MapDialog::drawIndoors() {
+	Map &map = *g_vm->_map;
+	Party &party = *g_vm->_party;
+	int v, frame;
+	int frame2 = _animFrame;
+	_animFrame = (_animFrame + 2) % 8;
+
+	// Draw indoors map
+	frame2 = (frame2 + 2) % 8;
+
+	// Draw default ground for all the valid explored areas
+	for (int yp = 38, yDiff = _pt.y + 7; yp < 166; yp += 8, --yDiff) {
+		for (int xp = 80, xDiff = _pt.x - 7; xp < 240; xp += 10, ++xDiff) {
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 0, 0xffff);
+
+			if (v != INVALID_CELL && map._currentSteppedOn)
+				map._tileSprites.draw(0, 0, Common::Point(xp, yp));
+		}
+	}
+
+	// Draw thinner ground tiles on the left edge of the map
+	for (int yp = 43, yDiff = _pt.y + 7; yp < 171; yp += 8, --yDiff) {
+		v = map.mazeLookup(Common::Point(_pt.x - 8, yDiff), 0, 0xffff);
+
+		if (v != INVALID_CELL && map._currentSurfaceId != 0 && map._currentSteppedOn)
+			map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
+				map._currentSurfaceId], Common::Point(75, yp));
+	}
+
+	// Draw thin tile portion on top-left corner of map
+	v = map.mazeLookup(Common::Point(_pt.x - 8, _pt.y + 8), 0, 0xffff);
+	if (v != INVALID_CELL && map._currentSurfaceId != 0 && map._currentSteppedOn)
+		map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
+			map._currentSurfaceId], Common::Point(75, 35));
+
+	// Draw any thin tiles at the very top of the map
+	for (int xp = 85, xDiff = _pt.x - 7; xp < 245; xp += 10, ++xDiff) {
+		v = map.mazeLookup(Common::Point(xDiff, _pt.y + 8), 0, 0xffff);
+
+		if (v != INVALID_CELL && map._currentSurfaceId != 0 && map._currentSteppedOn)
+			map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
+				map._currentSurfaceId], Common::Point(xp, 35));
+	}
+
+	// Draw the default ground tiles
+	for (int yp = 43, yDiff = _pt.y + 7; yp < 171; yp += 8, --yDiff) {
+		for (int xp = 85, xDiff = _pt.x - 7; xp < 245; xp += 10, ++xDiff) {
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 0, 0xffff);
+
+			if (v != INVALID_CELL && map._currentSurfaceId && map._currentSteppedOn)
+				map._tileSprites.draw(0, 36 + map.mazeData()._surfaceTypes[
+					map._currentSurfaceId], Common::Point(xp, yp));
+		}
+	}
+
+	// Draw walls on left and top edges of map
+	for (int xp = 80, yp = 158, xDiff = _pt.x - 7, yDiff = _pt.y - 8; xp < 250;
+	xp += 10, yp -= 8, ++xDiff, ++yDiff) {
+		// Draw walls on left edge of map
+		v = map.mazeLookup(Common::Point(_pt.x - 8, yDiff), 12);
+
+		switch (v) {
+		case SURFTYPE_DIRT:
+			frame = 18;
+			break;
+		case SURFTYPE_SNOW:
+			frame = 22;
+			break;
+		case SURFTYPE_SWAMP:
+		case SURFTYPE_CLOUD:
+			frame = 16;
+			break;
+		case SURFTYPE_LAVA:
+		case SURFTYPE_DWATER:
+			frame = 2;
+			break;
+		case SURFTYPE_DESERT:
+			frame = 30;
+			break;
+		case SURFTYPE_ROAD:
+			frame = 32;
+			break;
+		case SURFTYPE_TFLR:
+			frame = 20;
+			break;
+		case SURFTYPE_SKY:
+			frame = 28;
+			break;
+		case SURFTYPE_CROAD:
+			frame = 14;
+			break;
+		case SURFTYPE_SEWER:
+			frame = frame2 + 4;
+			break;
+		case SURFTYPE_SCORCH:
+			frame = 24;
+			break;
+		case SURFTYPE_SPACE:
+			frame = 26;
+			break;
+		default:
+			frame = -1;
+			break;
+		}
+
+		if (frame != -1 && map._currentSteppedOn)
+			map._tileSprites.draw(0, frame, Common::Point(70, yp));
+
+		// Draw walls on top edge of map
+		v = map.mazeLookup(Common::Point(xDiff, _pt.y + 8), 0);
+
+		switch (v) {
+		case SURFTYPE_DIRT:
+			frame = 19;
+			break;
+		case SURFTYPE_GRASS:
+			frame = 35;
+			break;
+		case SURFTYPE_SNOW:
+			frame = 23;
+			break;
+		case SURFTYPE_SWAMP:
+		case SURFTYPE_CLOUD:
+			frame = 17;
+			break;
+		case SURFTYPE_LAVA:
+		case SURFTYPE_DWATER:
+			frame = 3;
+			break;
+		case SURFTYPE_DESERT:
+			frame = 31;
+			break;
+		case SURFTYPE_ROAD:
+			frame = 33;
+			break;
+		case SURFTYPE_TFLR:
+			frame = 21;
+			break;
+		case SURFTYPE_SKY:
+			frame = 29;
+			break;
+		case SURFTYPE_CROAD:
+			frame = 15;
+			break;
+		case SURFTYPE_SEWER:
+			frame = frame2 + 5;
+			break;
+		case SURFTYPE_SCORCH:
+			frame = 25;
+			break;
+		case SURFTYPE_SPACE:
+			frame = 27;
+			break;
+		default:
+			frame = -1;
+			break;
+		}
+
+		if (frame != -1 && map._currentSteppedOn)
+			map._tileSprites.draw(0, frame, Common::Point(xp, 30));
+	}
+
+	// Draw the walls for the remaining cells of the minimap
+	for (int yCtr = 0, yp = 38, yDiff = _pt.y + 7; yCtr < 16; ++yCtr, yp += 8, --yDiff) {
+		for (int xCtr = 0, xp = 80, xDiff = _pt.x - 7; xCtr < 16; ++xCtr, xp += 10, ++xDiff) {
+			// Draw the arrow if at the correct position
+			if ((_arrowPt.x / 10) == xCtr && (14 - (_arrowPt.y / 10)) == yCtr && _frameEndFlag) {
+				_globalSprites.draw(0, party._mazeDirection + 1,
+					Common::Point(_arrowPt.x + 81, _arrowPt.y + 29));
+			}
+
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 12);
+			switch (v) {
+			case SURFTYPE_DIRT:
+				frame = 18;
+				break;
+			case SURFTYPE_GRASS:
+				frame = 34;
+				break;
+			case SURFTYPE_SNOW:
+				frame = 22;
+				break;
+			case SURFTYPE_SWAMP:
+			case SURFTYPE_CLOUD:
+				frame = 16;
+				break;
+			case SURFTYPE_LAVA:
+			case SURFTYPE_DWATER:
+				frame = 2;
+				break;
+			case SURFTYPE_DESERT:
+				frame = 30;
+				break;
+			case SURFTYPE_ROAD:
+				frame = 32;
+				break;
+			case SURFTYPE_TFLR:
+				frame = 20;
+				break;
+			case SURFTYPE_SKY:
+				frame = 28;
+				break;
+			case SURFTYPE_CROAD:
+				frame = 14;
+				break;
+			case SURFTYPE_SEWER:
+				frame = frame2 + 4;
+				break;
+			case SURFTYPE_SCORCH:
+				frame = 24;
+				break;
+			case SURFTYPE_SPACE:
+				frame = 26;
+				break;
+			default:
+				frame = -1;
+				break;
+			}
+
+			if (frame != -1 && map._currentSteppedOn)
+				map._tileSprites.draw(0, frame, Common::Point(xp, yp));
+
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 0);
+			switch (v) {
+			case SURFTYPE_DIRT:
+				frame = 19;
+				break;
+			case SURFTYPE_GRASS:
+				frame = 35;
+				break;
+			case SURFTYPE_SNOW:
+				frame = 23;
+				break;
+			case SURFTYPE_SWAMP:
+			case SURFTYPE_CLOUD:
+				frame = 17;
+				break;
+			case SURFTYPE_LAVA:
+			case SURFTYPE_DWATER:
+				frame = 3;
+				break;
+			case SURFTYPE_DESERT:
+				frame = 31;
+				break;
+			case SURFTYPE_ROAD:
+				frame = 33;
+				break;
+			case SURFTYPE_TFLR:
+				frame = 21;
+				break;
+			case SURFTYPE_SKY:
+				frame = 29;
+				break;
+			case SURFTYPE_CROAD:
+				frame = 15;
+				break;
+			case SURFTYPE_SEWER:
+				frame = frame2 + 5;
+				break;
+			case SURFTYPE_SCORCH:
+				frame = 25;
+				break;
+			case SURFTYPE_SPACE:
+				frame = 27;
+				break;
+			default:
+				frame = -1;
+				break;
+			}
+
+			if (frame != -1 && map._currentSteppedOn)
+				map._tileSprites.draw(0, frame, Common::Point(xp, yp));
+		}
+	}
+
+	// Draw overlay on cells that haven't been stepped on yet
+	for (int yDiff = _pt.y + 7, yp = 38; yp < 166; --yDiff, yp += 8) {
+		for (int xp = 80, xDiff = _pt.x - 7; xp < 240; xp += 10, ++xDiff) {
+			v = map.mazeLookup(Common::Point(xDiff, yDiff), 0, 0xffff);
+
+			if (v == INVALID_CELL || !map._currentSteppedOn)
+				map._tileSprites.draw(0, 1, Common::Point(xp, yp));
+		}
+	}
+}
+
+} // End of namespace Xeen
diff --git a/engines/xeen/dialogs_automap.h b/engines/xeen/dialogs_map.h
index 239a73a932..8ae24eebac 100644
--- a/engines/xeen/dialogs_automap.h
+++ b/engines/xeen/dialogs_map.h
@@ -20,8 +20,8 @@
  *
  */
 
-#ifndef XEEN_DIALOGS_AUTOMAP_H
-#define XEEN_DIALOGS_AUTOMAP_H
+#ifndef XEEN_DIALOGS_MAP_H
+#define XEEN_DIALOGS_MAP_H
 
 #include "xeen/dialogs.h"
 
@@ -29,10 +29,28 @@ namespace Xeen {
 
 class XeenEngine;
 
-class AutoMapDialog: public ButtonContainer {
+class MapDialog: public ButtonContainer {
 private:
-	AutoMapDialog(XeenEngine *vm) : ButtonContainer(vm) {}
+	int _animFrame;
+	SpriteResource _globalSprites;
+	Common::Point _pt, _arrowPt;
+	bool _frameEndFlag;
+private:
+	MapDialog(XeenEngine *vm) : ButtonContainer(vm), _animFrame(0) {}
+
+	/**
+	 * Draws the map contents when outdoors
+	 */
+	void drawOutdoors();
+
+	/**
+	 * Draws the map contents when indoors
+	 */
+	void drawIndoors();
 
+	/**
+	 * Handles the display of the dialog
+	 */
 	void execute();
 public:
 	static void show(XeenEngine *vm);
diff --git a/engines/xeen/interface.cpp b/engines/xeen/interface.cpp
index af555c8bc2..b3df1f68c4 100644
--- a/engines/xeen/interface.cpp
+++ b/engines/xeen/interface.cpp
@@ -21,13 +21,13 @@
  */
 
 #include "xeen/interface.h"
-#include "xeen/dialogs_automap.h"
 #include "xeen/dialogs_char_info.h"
 #include "xeen/dialogs_control_panel.h"
 #include "xeen/dialogs_error.h"
 #include "xeen/dialogs_fight_options.h"
 #include "xeen/dialogs_info.h"
 #include "xeen/dialogs_items.h"
+#include "xeen/dialogs_map.h"
 #include "xeen/dialogs_query.h"
 #include "xeen/dialogs_quests.h"
 #include "xeen/dialogs_quick_ref.h"
@@ -558,7 +558,7 @@ void Interface::perform() {
 
 	case Common::KEYCODE_m:
 		// Show map dialog
-		AutoMapDialog::show(_vm);
+		MapDialog::show(_vm);
 		break;
 
 	case Common::KEYCODE_q:
diff --git a/engines/xeen/interface_minimap.cpp b/engines/xeen/interface_minimap.cpp
index e2a787ea70..ef45d57408 100644
--- a/engines/xeen/interface_minimap.cpp
+++ b/engines/xeen/interface_minimap.cpp
@@ -110,7 +110,6 @@ void InterfaceMinimap::drawIndoorsMinimap() {
 	Party &party = *g_vm->_party;
 	Resources &res = *g_vm->_resources;
 	int v, frame;
-
 	int frame2 = _animFrame;
 	_animFrame = (_animFrame + 2) % 8;
 
@@ -143,7 +142,7 @@ void InterfaceMinimap::drawIndoorsMinimap() {
 	}
 
 	// Draw thin tile portion on top-left corner of map
-	v = map.mazeLookup(Common::Point(party._mazePosition.x - 4, party._mazePosition.y + 4), 0xffff, 0);
+	v = map.mazeLookup(Common::Point(party._mazePosition.x - 4, party._mazePosition.y + 4), 0, 0xffff);
 	if (v != INVALID_CELL && map._currentSurfaceId &&
 		(map._currentSteppedOn || party._wizardEyeActive)) {
 		map._tileSprites.draw(1,
@@ -182,6 +181,7 @@ void InterfaceMinimap::drawIndoorsMinimap() {
 	// Draw walls on left and top edges of map
 	for (int idx = 0, xp = 237, yp = 60, xDiff = -3; idx < MINIMAP_SIZE;
 		++idx, ++xDiff, xp += 10, yp -= 8) {
+		// Left column
 		v = map.mazeLookup(
 			Common::Point(party._mazePosition.x - 4, party._mazePosition.y - 3 + idx),
 			12, 0xffff);
@@ -233,6 +233,7 @@ void InterfaceMinimap::drawIndoorsMinimap() {
 		if (frame != -1 && (map._currentSteppedOn || party._wizardEyeActive))
 			map._tileSprites.draw(1, frame, Common::Point(222, yp));
 
+		// Top row
 		v = map.mazeLookup(
 			Common::Point(party._mazePosition.x - 3 + idx, party._mazePosition.y + 4),
 			0);
@@ -285,10 +286,10 @@ void InterfaceMinimap::drawIndoorsMinimap() {
 		}
 
 		if (frame != -1 && (map._currentSteppedOn || party._wizardEyeActive))
-			map._tileSprites.draw(1, frame, Common::Point(xp, yp));
+			map._tileSprites.draw(1, frame, Common::Point(xp, 4));
 	}
 
-	// Draw the front/back walls of cells in the minimap
+	// Draw the walls for the remaining cells of the minimap
 	for (int rowNum = 0, yp = 12, yDiff = 3; rowNum < MINIMAP_SIZE;
 		++rowNum, --yDiff, yp += 8) {
 		for (int colNum = 0, xp = 237, xDiff = -3; colNum < MINIMAP_SIZE;
@@ -353,7 +354,7 @@ void InterfaceMinimap::drawIndoorsMinimap() {
 			}
 
 			v = map.mazeLookup(Common::Point(party._mazePosition.x + xDiff,
-				party._mazePosition.y + yDiff), 12, 0xffff);
+				party._mazePosition.y + yDiff), 0);
 			switch (v) {
 			case SURFTYPE_DIRT:
 				frame = 19;
diff --git a/engines/xeen/module.mk b/engines/xeen/module.mk
index 9890744806..7a374474d3 100644
--- a/engines/xeen/module.mk
+++ b/engines/xeen/module.mk
@@ -12,7 +12,6 @@ MODULE_OBJS := \
 	debugger.o \
 	detection.o \
 	dialogs.o \
-	dialogs_automap.o \
 	dialogs_char_info.o \
 	dialogs_control_panel.o \
 	dialogs_dismiss.o \
@@ -22,6 +21,7 @@ MODULE_OBJS := \
 	dialogs_info.o \
 	dialogs_input.o \
 	dialogs_items.o \
+	dialogs_map.o \
 	dialogs_party.o \
 	dialogs_query.o \
 	dialogs_quests.o \