Initial commit

engines/ultima/shared/maps/creature.cpp

@@ -0,0 +1,55 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "ultima/shared/maps/creature.h"
+#include "ultima/shared/early/game.h"
+
+namespace Ultima {
+namespace Shared {
+namespace Maps {
+
+void Creature::synchronize(Common::Serializer &s) {
+	s.syncAsSint32LE(_hitPoints);
+}
+
+void Creature::update(bool isPreUpdate) {
+	if (isPreUpdate) {
+		// Check whether creature can attack
+		movement();
+		_isAttacking = attackDistance() != 0;
+	} else if (_isAttacking && !_gameRef->_party->isDead()) {
+		attackParty();
+	}
+}
+
+bool Creature::subtractHitPoints(uint amount) {
+	if ((int)amount >= _hitPoints) {
+		_hitPoints = 0;
+		return true;
+	} else {
+		_hitPoints -= amount;
+		return false;
+	}
+}
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima

engines/ultima/shared/maps/creature.h

@@ -0,0 +1,105 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ULTIMA_SHARED_WIDGETS_CREATURE_H
+#define ULTIMA_SHARED_WIDGETS_CREATURE_H
+
+#include "ultima/shared/maps/map_widget.h"
+#include "ultima/shared/maps/map.h"
+#include "common/serializer.h"
+
+namespace Ultima {
+namespace Shared {
+
+class Game;
+class Map;
+
+namespace Maps {
+
+/**
+ * Base class for creatures that can be killed
+ */
+class Creature {
+private:
+	Game *_gameRef;
+//	MapBase *_mapRef;
+protected:
+	int _hitPoints;
+	bool _isAttacking;
+protected:
+	/**
+	 * Returns either the maximum attack distance for a monster, or 0 if the monster is beyond
+	 * that distance from the player
+	 */
+	virtual uint attackDistance() const { return 0; }
+
+	/**
+	 * Handles moving creatures
+	 */
+	virtual void movement() {}
+
+	/**
+	 * Handles attacking the player
+	 */
+	virtual void attackParty() {}
+public:
+	/**
+	 * Constructor
+	 */
+	Creature(Game *game, MapBase *) : _gameRef(game), _hitPoints(0), _isAttacking(false) {}
+	Creature(Game *game, MapBase *, int hitPoints) : _gameRef(game),
+		_hitPoints(hitPoints), _isAttacking(false) {}
+
+	/**
+	 * Destructor
+	 */
+	virtual ~Creature() {}
+
+	/**
+	 * Handles loading and saving games
+	 */
+	void synchronize(Common::Serializer &s);
+
+	/**
+	 * Called to update the widget at the end of a turn
+	 * @param isPreUpdate		Update is called twice in succession during the end of turn update.
+	 *		Once with true for all widgets, then with it false
+	 */
+	virtual void update(bool isPreUpdate);
+
+	/**
+	 * True true if the creature is dead
+	 */
+	bool isDead() const { return _hitPoints <= 0; }
+
+	/**
+	 * Removes hit points from a creature
+	 * @param amount		Amount to remove
+	 * @returns				Returns true if kills the creature
+	 */
+	virtual bool subtractHitPoints(uint amount);
+};
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif

engines/ultima/shared/maps/dungeon_creature.h

@@ -0,0 +1,66 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ULTIMA_SHARED_MAPS_DUNGEON_CREATURE_H
+#define ULTIMA_SHARED_MAPS_DUNGEON_CREATURE_H
+
+#include "ultima/shared/maps/creature.h"
+
+namespace Ultima {
+namespace Shared {
+
+class Game;
+class Map;
+
+namespace Maps {
+
+/**
+ * Stub class for dungeon creatures
+ */
+class DungeonCreature : public Creature {
+public:
+	/**
+	 * Constructor
+	 */
+	DungeonCreature(Game *game, MapBase *map) : Creature(game, map) {}
+	DungeonCreature(Game *game, MapBase *map, int hitPoints) : Creature(game, map, hitPoints) {}
+
+	/**
+	 * Destructor
+	 */
+	~DungeonCreature() override {}
+
+	/**
+	 * Returns true if a monster blocks the background behind him
+	 */
+	virtual bool isBlockingView() const = 0;
+
+	/**
+	 * Draw a monster
+	 */
+	virtual void draw(DungeonSurface &s, uint distance) = 0;
+};
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif

engines/ultima/shared/maps/dungeon_widget.h

@@ -0,0 +1,67 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ULTIMA_SHARED_MAPS_DUNGEON_WIDGET_H
+#define ULTIMA_SHARED_MAPS_DUNGEON_WIDGET_H
+
+#include "ultima/shared/maps/map_widget.h"
+#include "ultima/shared/maps/map.h"
+#include "ultima/shared/gfx/dungeon_surface.h"
+#include "common/serializer.h"
+#include "common/str.h"
+
+namespace Ultima {
+namespace Shared {
+
+class Game;
+class Map;
+
+namespace Maps {
+
+/**
+ * Base class for things that appear within the dungeons
+ */
+class DungeonWidget : public MapWidget {
+public:
+	/**
+	 * Constructor
+	 */
+	DungeonWidget(Game *game, Maps::MapBase *map) : MapWidget(game, map) {}
+	DungeonWidget(Game *game, Maps::MapBase *map, const Point &pt, Direction dir = DIR_NONE) : MapWidget(game, map, pt, dir) {}
+	DungeonWidget(Game *game, Maps::MapBase *map, const Common::String &name, const Point &pt, Direction dir = DIR_NONE) :
+		MapWidget(game, map, name, pt, dir) {}
+
+	/**
+	 * Destructor
+	 */
+	~DungeonWidget() override {}
+
+	/**
+	 * Draws an item
+	 */
+	virtual void draw(DungeonSurface &s, uint distance) = 0;
+};
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif

engines/ultima/shared/maps/map.cpp

@@ -0,0 +1,58 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "ultima/shared/maps/map.h"
+#include "ultima/shared/early/game.h"
+#include "ultima/shared/gfx/visual_item.h"
+
+namespace Ultima {
+namespace Shared {
+namespace Maps {
+
+void Map::clear() {
+	if (_mapArea)
+		_mapArea->clear();
+	_mapArea = nullptr;
+}
+
+void Map::load(MapId mapId) {
+	_mapArea = nullptr;
+}
+
+void Map::synchronize(Common::Serializer &s) {
+	int mapId;
+
+	if (s.isSaving()) {
+		// Saving
+		mapId = _mapArea->getMapId();
+		s.syncAsUint16LE(mapId);
+	} else {
+		// Loading
+		s.syncAsUint16LE(mapId);
+		load(mapId);
+	}
+
+	_mapArea->synchronize(s);
+}
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima

engines/ultima/shared/maps/map.h

@@ -0,0 +1,250 @@
+/* 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  n redistribute it and/or
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ULTIMA_SHARED_MAPS_MAP_H
+#define ULTIMA_SHARED_MAPS_MAP_H
+
+#include "common/array.h"
+#include "common/serializer.h"
+#include "ultima/shared/core/rect.h"
+#include "ultima/shared/maps/map_base.h"
+#include "ultima/shared/maps/map_widget.h"
+#include "ultima/shared/maps/map_tile.h"
+
+
+namespace Ultima {
+namespace Shared {
+
+class Game;
+
+namespace Maps {
+
+#define REGISTER_WIDGET(NAME) if (name == #NAME) return new Widgets::NAME(_game, this)
+#define DECLARE_WIDGET(NAME) const char *getClassName() const override { return #NAME; }
+
+/**
+ * Base class for managing maps within the game
+ */
+class Map {
+protected:
+	MapBase *_mapArea;
+public:
+	/**
+	 * Constructor
+	 */
+	Map() : _mapArea(nullptr) {}
+
+	/**
+	 * Destructor
+	 */
+	virtual ~Map() {}
+
+	/**
+	 * Load a given map
+	 */
+	virtual void load(MapId mapId);
+
+	/**
+	 * Clears all map data
+	 */
+	virtual void clear();
+
+	/**
+	 * Handles loading and saving the map's data
+	 */
+	virtual void synchronize(Common::Serializer &s);
+
+	/**
+	 * Instantiates a widget type by name
+	 */
+	MapWidget *createWidget(const Common::String &name) {
+		assert(_mapArea);
+		return _mapArea->createWidget(name);
+	}
+
+	/**
+	 * Gets a tile at a given position
+	 */
+	void getTileAt(const Point &pt, MapTile *tile, bool includePlayer = true) {
+		assert(_mapArea);
+		return _mapArea->getTileAt(pt, tile, includePlayer);
+	}
+
+	/**
+	 * Sets a tile at a given position
+	 */
+	void setTileAt(const Point &pt, uint tileId) {
+		assert(_mapArea);
+		return _mapArea->setTileAt(pt, tileId);
+	}
+
+	/**
+	 * Get the viewport position
+	 */
+	Point getViewportPosition(const Point &viewportSize) {
+		assert(_mapArea);
+		return _mapArea->getViewportPosition(viewportSize);
+	}
+
+	/**
+	 * Return the width of the map
+	 */
+	size_t width() const {
+		assert(_mapArea);
+		return _mapArea->width();
+	}
+
+	/**
+	 * Return the height of the map
+	 */
+	size_t height() const {
+		assert(_mapArea);
+		return _mapArea->height();
+	}
+
+	/**
+	 * Return the current position
+	 */
+	Point getPosition() const {
+		assert(_mapArea);
+		return _mapArea->getPosition();
+	}
+
+	/**
+	 * Set the position
+	 */
+	void setPosition(const Point &pt) {
+		assert(_mapArea);
+		_mapArea->setPosition(pt);
+	}
+
+	/**
+	 * Get the current direction
+	 */
+	Direction getDirection() const {
+		assert(_mapArea);
+		return _mapArea->getDirection();
+	}
+
+	/**
+	 * Set the current direction
+	 */
+	void setDirection(Direction dir) {
+		assert(_mapArea);
+		_mapArea->setDirection(dir);
+	}
+
+	/**
+	 * Returns a delta for the cell in front of the player based on the direction they're facing
+	 */
+	Point getDirectionDelta() const {
+		assert(_mapArea);
+		return _mapArea->getDirectionDelta();
+	}
+
+	/**
+	 * Gets a point relative to the current position
+	 */
+	Point getDeltaPosition(const Point &delta) {
+		assert(_mapArea);
+		return _mapArea->getDeltaPosition(delta);
+	}
+
+	/**
+	 * Shifts the viewport by a given delta
+	 */
+	void shiftViewport(const Point &delta) {
+		assert(_mapArea);
+		_mapArea->shiftViewport(delta);
+	}
+
+	/**
+	 * Returns the number of tiles in the map there are for each tile in the original game.
+	 * This allows for more detailed maps in the enhanced game modes
+	 */
+	Point getTilesPerOrigTile() const {
+		assert(_mapArea);
+		return _mapArea->_tilesPerOrigTile;
+	}
+
+	/**
+	 * Return the name of the map
+	 */
+	Common::String getName() const {
+		assert(_mapArea);
+		return _mapArea->_name;
+	}
+
+	/**
+	 * Returns the currently active widget that the player is controlling
+	 */
+	MapWidget *getPlayerWidget() const {
+		assert(_mapArea);
+		return _mapArea->_playerWidget;
+	}
+
+	/**
+	 * @param delta		Delta to change dungeon level by
+	 * @returns			False if dungeon left, true if still within dungeon
+	 */
+	bool changeLevel(int delta) {
+		assert(_mapArea);
+		return _mapArea->changeLevel(delta);
+	}
+
+	/**
+	 * Get the current map level
+	 */
+	uint getLevel() const {
+		assert(_mapArea);
+		return _mapArea->getLevel();
+	}
+
+	/**
+	 * Returns whether the map wraps around to the other side at it's edges (i.e. the overworld)
+	 */
+	bool isMapWrapped() const {
+		assert(_mapArea);
+		return _mapArea->isMapWrapped();
+	}
+
+	/**
+	 * Updates the map at the end of a turn
+	 */
+	void update() {
+		assert(_mapArea);
+		return _mapArea->update();
+	}
+
+	/**
+	 * Cast a specific spell
+	 */
+	void castSpell(uint spellId) {
+		assert(_mapArea);
+		_mapArea->castSpell(spellId);
+	}
+};
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif

engines/ultima/shared/maps/map_base.cpp

@@ -0,0 +1,236 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "ultima/shared/maps/map_base.h"
+#include "ultima/shared/maps/map_widget.h"
+#include "ultima/shared/maps/map.h"
+#include "ultima/shared/early/game.h"
+#include "ultima/shared/gfx/visual_item.h"
+
+namespace Ultima {
+namespace Shared {
+namespace Maps {
+
+MapWidget *MapBase::WidgetsArray::findByClass(const ClassDef &classDef) const {
+	for (uint idx = 0; idx < size(); ++idx) {
+		MapWidget *w = (*this)[idx].get();
+		if (w->isInstanceOf(classDef))
+			return w;
+	}
+
+	return nullptr;
+}
+
+/*-------------------------------------------------------------------*/
+
+void MapBase::clear() {
+	_mapId = 0;
+	_data.clear();
+	_widgets.clear();
+}
+
+void MapBase::load(MapId mapId) {
+	_mapId = mapId;
+}
+
+void MapBase::synchronize(Common::Serializer &s) {
+	_viewportPos.synchronize(s);
+	uint size;
+	int transportIndex = -1;
+	Common::String name;
+
+	// If the map is modified in any way, it gets synchronized as well
+	s.syncAsByte(_mapModified);
+	if (_mapModified) {
+		for (uint y = 0; y < height(); ++y) {
+			for (uint x = 0; x < width(); ++x)
+				s.syncAsByte(_data[y][x]);
+		}
+	}
+
+	if (s.isSaving()) {
+		// Save widgets
+		size = 0;
+		for (uint idx = 0; idx < _widgets.size(); ++idx) {
+			if (_widgets[idx]->getClassName())
+				++size;
+			if (_playerWidget == _widgets[idx].get())
+				transportIndex = (int)idx;
+		}
+		assert(transportIndex >= 0);
+
+		s.syncAsUint16LE(size);
+		for (uint idx = 0; idx < _widgets.size(); ++idx) {
+			name = _widgets[idx]->getClassName();
+			if (!name.empty()) {
+				s.syncString(name);
+				_widgets[idx]->synchronize(s);
+			}
+		}
+		s.syncAsUint16LE(transportIndex);
+
+	} else {
+		// Load widgets
+		s.syncAsUint16LE(size);
+		_widgets.clear();
+		for (uint idx = 0; idx < size; ++idx) {
+			s.syncString(name);
+
+			MapWidget *w = createWidget(name);
+			w->synchronize(s);
+			addWidget(w);
+		}
+
+		s.syncAsUint16LE(transportIndex);
+		_playerWidget = _widgets[transportIndex].get();
+	}
+}
+
+void MapBase::setDimensions(const Point &size) {
+	_data.resize(size.y);
+	for (int y = 0; y < size.y; ++y)
+		_data[y].resize(size.x);
+	_size = size;
+}
+
+Point MapBase::getDirectionDelta() const {
+	switch (_playerWidget->_direction) {
+	case DIR_LEFT:
+		return Point(-1, 0);
+	case DIR_RIGHT:
+		return Point(1, 0);
+	case DIR_UP:
+		return Point(0, -1);
+	default:
+		return Point(0, 1);
+	}
+}
+
+Point MapBase::getDeltaPosition(const Point &delta) {
+	return _playerWidget->_position + delta;
+}
+
+void MapBase::resetViewport() {
+	// Reset the viewport, so it's position will get recalculated
+	_viewportPos.reset();
+}
+
+Point MapBase::getViewportPosition(const Point &viewportSize) {
+	Point &topLeft = _viewportPos._topLeft;
+
+	if (!_viewportPos.isValid() || _viewportPos._size != viewportSize) {
+		// Calculate the new position
+		topLeft.x = _playerWidget->_position.x - (viewportSize.x - 1) / 2;
+		topLeft.y = _playerWidget->_position.y - (viewportSize.y - 1) / 2;
+
+		// Fixed maps, so constrain top left corner so the map fills the viewport.
+		// This will accommodate future renderings with more tiles, or greater tile size
+		topLeft.x = CLIP((int)topLeft.x, 0, (int)(width() - viewportSize.x));
+		topLeft.y = CLIP((int)topLeft.y, 0, (int)(height() - viewportSize.y));
+	}
+
+	return topLeft;
+}
+
+void MapBase::shiftViewport(const Point &delta) {
+	Point &topLeft = _viewportPos._topLeft;
+	topLeft += delta;
+
+	// Shift the viewport, but constraining the map to fill up the screen
+	topLeft.x = CLIP(topLeft.x, (int16)0, (int16)(width() - _viewportPos._size.x));
+	topLeft.y = CLIP(topLeft.y, (int16)0, (int16)(height() - _viewportPos._size.y));
+}
+
+void MapBase::addWidget(MapWidget *widget) {
+	_widgets.push_back(MapWidgetPtr(widget));
+}
+
+void MapBase::removeWidget(MapWidget *widget) {
+	for (uint idx = 0; idx < _widgets.size(); ++idx) {
+		if (_widgets[idx].get() == widget) {
+			_widgets.remove_at(idx);
+			break;
+		}
+	}
+}
+
+void MapBase::getTileAt(const Point &pt, MapTile *tile, bool includePlayer) {
+	tile->clear();
+
+	// Get the base tile
+	tile->_tileDisplayNum = tile->_tileId = _data[pt.y][pt.x];
+
+	// Check for any widgets on that map tile
+	tile->_widgets.clear();
+	tile->_widget = nullptr;
+	tile->_widgetNum = -1;
+
+	for (int idx = (int)_widgets.size() - 1; idx >= 0; --idx) {
+		MapWidget *widget = _widgets[idx].get();
+		if (widget->_position == pt && (includePlayer || widget != _playerWidget)) {
+			tile->_widgets.push_back(widget);
+
+			if (!tile->_widget) {
+				tile->_widgetNum = idx;
+				tile->_widget = widget;
+			}
+		}
+	}
+}
+
+void MapBase::setTileAt(const Point &pt, uint tileId) {
+	_data[pt.y][pt.x] = tileId;
+}
+
+void MapBase::update() {
+	// Call the update method of each widget, to allow for things like npc movement, etc.
+	for (uint idx = 0; idx < _widgets.size(); ++idx)
+		_widgets[idx].get()->update(true);
+
+	// Call the update method of each widget, to allow for things like npc movement, etc.
+	for (uint idx = 0; idx < _widgets.size(); ++idx)
+		_widgets[idx].get()->update(false);
+}
+
+Point MapBase::getPosition() const {
+	return _playerWidget->_position;
+}
+
+void MapBase::setPosition(const Point &pt) {
+	_playerWidget->_position = pt;
+}
+
+Direction MapBase::getDirection() const {
+	return _playerWidget->_direction;
+}
+
+void MapBase::setDirection(Direction dir) {
+	_playerWidget->_direction = dir;
+}
+
+void MapBase::addInfoMsg(const Common::String &text, bool newLine, bool replaceLine) {
+	CInfoMsg msg(text, newLine, replaceLine);
+	msg.execute(_game->getView());
+}
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima

engines/ultima/shared/maps/map_base.h

@@ -0,0 +1,291 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ULTIMA_SHARED_MAPS_MAP_BASE_H
+#define ULTIMA_SHARED_MAPS_MAP_BASE_H
+
+#include "common/array.h"
+#include "common/serializer.h"
+#include "ultima/shared/core/base_object.h"
+#include "ultima/shared/core/rect.h"
+#include "ultima/shared/maps/map_widget.h"
+
+namespace Ultima {
+namespace Shared {
+
+class Game;
+
+namespace Maps {
+
+typedef int MapId;
+typedef byte MapCell;
+
+class Map;
+class MapTile;
+
+/**
+ * Base class for specific map types
+ */
+class MapBase {
+	/**
+	 * Widgets array
+	 */
+	class WidgetsArray : public Common::Array<MapWidgetPtr> {
+	public:
+		/**
+		 * Finds a widget by class
+		 */
+		MapWidget *findByClass(const ClassDef &classDef) const;
+	};
+
+	/**
+	 * Internal class used for storing the data for a row
+	 */
+	struct MapCellsRow {
+	private:
+		Common::Array<MapCell> _data;
+	public:
+		byte &operator[](int idx) { return _data[idx]; }
+		byte operator[](int idx) const { return _data[idx]; }
+
+		/**
+		 * Resize the row
+		 */
+		void resize(size_t newSize) { _data.resize(newSize); }
+	};
+
+	/**
+	 * Stores state about the current viewport being displayed. It's kept as part of the Map class
+	 * as a convenience to be alongside the current party position
+	 */
+	struct ViewportPosition {
+		Point _topLeft;					// Top, left tile position for viewport
+		Point _size;					// Size of the viewport. Just in case we ever allow it to change
+		MapId _mapId;					// Maze the viewport is for. Used to detect when the map changes
+
+		/**
+		 * Constructor
+		 */
+		ViewportPosition() : _topLeft(-1, -1), _mapId(-1) {}
+
+		/**
+		 * Returns true if the viewport is in a valid state
+		 */
+		bool isValid() const { return _mapId != -1; }
+
+		/**
+		 * Handles loading and saving viewport
+		 */
+		void synchronize(Common::Serializer &s) {
+			s.syncAsUint16LE(_topLeft.x);
+			s.syncAsUint16LE(_topLeft.y);
+		}
+
+		/**
+		 * Resets the viewport position, so it'll get recalculated the next call to getViewportPosition
+		 */
+		void reset() { _mapId = -1; }
+	};
+
+private:
+//	Map *_map;							// Map manager reference
+	Game *_game;						// Game reference
+	bool _mapModified;					// Tiles have been dynamically changed
+protected:
+	MapId _mapId;						// The map Id
+	uint _mapIndex;						// Index of map within the group of same maps
+	uint _mapStyle;						// Map style category for towns & castles
+	ViewportPosition _viewportPos;		// Viewport position
+	Common::Array<MapCellsRow> _data;	// Data for the map
+protected:
+	/**
+	 * Set the size of the map
+	 */
+	void setDimensions(const Point &size);
+
+	/**
+	 * Adds a text string to the info area
+	 * @param text			Text to add
+	 * @param newLine		Whether to apply a newline at the end
+	 * @param replaceLine	If true, replaces the current last line
+	 */
+	void addInfoMsg(const Common::String &text, bool newLine = true, bool replaceLine = false);
+public:
+	Point _size;						// X, Y size of the map
+	Point _tilesPerOrigTile;			// For enhanced modes, number of tiles per original game tile
+	Common::String _name;				// Name of map, if applicable
+	MapWidget *_playerWidget;			// Current means of transport, even if on foot
+	WidgetsArray _widgets;				// Party, monsteres, transports, etc.
+public:
+	/**
+	 * Constructor
+	 */
+	MapBase(Game *game, Map *) : _game(game),_playerWidget(nullptr),
+		_mapModified(false), _mapId(0), _mapIndex(0), _mapStyle(0) {}
+
+	/**
+	 * Destructor
+	 */
+	virtual ~MapBase() {}
+
+	/**
+	 * Handles loading and saving the map's data
+	 */
+	virtual void synchronize(Common::Serializer &s);
+
+	/**
+	 * Adds a widget to the map
+	 */
+	void addWidget(MapWidget *widget);
+
+	/**
+	 * Removes a widget from the map
+	 */
+	void removeWidget(MapWidget *widget);
+
+	/**
+	 * Clears all map data
+	 */
+	virtual void clear();
+
+	/**
+	 * Gets a tile at a given position
+	 */
+	virtual void getTileAt(const Point &pt, MapTile *tile, bool includePlayer = true);
+
+	/**
+	 * Sets a tile at a given position
+	 */
+	virtual void setTileAt(const Point &pt, uint tileId);
+
+	/**
+	 * Resets the viewport when the viewport changes
+	 */
+	void resetViewport();
+
+	/**
+	 * Get the viewport position
+	 */
+	virtual Point getViewportPosition(const Point &viewportSize);
+
+	/**
+	 * Load the map
+	 */
+	virtual void load(MapId mapId);
+
+	/**
+	 * Changes the level. Only applicable to dungeon maps which have levels
+	 * @param delta		Delta to change dungeon level by
+	 * @returns			False if dungeon left, true if still within dungeon
+	 */
+	virtual bool changeLevel(int delta) { return true; }
+
+	/**
+	 * Get the current map level
+	 */
+	virtual uint getLevel() const { return 0; }
+
+	/**
+	 * Returns whether the map wraps around to the other side at it's edges (i.e. the overworld)
+	 */
+	virtual bool isMapWrapped() const { return false; }
+
+	/**
+	 * Instantiates a widget type by name
+	 */
+	virtual MapWidget *createWidget(const Common::String &name) = 0;
+
+	/**
+	 * Returns the width of the map
+	 */
+	size_t width() const { return _size.x; }
+
+	/**
+	 * Returns the height of the map
+	 */
+	size_t height() const { return _size.y; }
+
+	/**
+	 * Get the current position
+	 */
+	Point getPosition() const;
+
+	/**
+	 * Set the current position
+	 */
+	void setPosition(const Point &pt);
+
+	/**
+	 * Get the current direction
+	 */
+	Direction getDirection() const;
+
+	/**
+	 * Set the current direction
+	 */
+	void setDirection(Direction dir);
+
+	/**
+	 * Returns a delta for the cell in front of the player based on the direction they're facing
+	 */
+	Point getDirectionDelta() const;
+
+	/**
+	 * Gets a point relative to the current position
+	 */
+	virtual Point getDeltaPosition(const Point &delta);
+
+	/**
+	 * Returns the map Id
+	 */
+	MapId getMapId() const { return _mapId; }
+
+	/**
+	 * Gets the map Index
+	 */
+	uint getMapIndex() const { return _mapIndex; }
+
+	/**
+	 * Gets the map style
+	 */
+	uint getMapStyle() const { return _mapStyle; }
+
+	/**
+	 * Shifts the viewport by a given delta
+	 */
+	virtual void shiftViewport(const Point &delta);
+
+	/**
+	 * Updates the map at the end of a turn
+	 */
+	virtual void update();
+
+	/**
+	 * Cast a specific spell
+	 */
+	virtual void castSpell(uint spell) = 0;
+};
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif

engines/ultima/shared/maps/map_tile.cpp

@@ -0,0 +1,41 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "ultima/shared/maps/map_tile.h"
+#include "ultima/shared/maps/map_widget.h"
+
+namespace Ultima {
+namespace Shared {
+namespace Maps {
+
+void MapTile::clear() {
+	_tileId = _tileDisplayNum = -1;
+	_widgets.clear();
+	_widgetNum = -1;
+	_widget = nullptr;
+	_isDoor = _isSecretDoor = false;
+	_isLadderUp = _isLadderDown = false;
+	_isWall = _isHallway = _isBeams = false;
+}
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima

engines/ultima/shared/maps/map_tile.h

@@ -0,0 +1,91 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ULTIMA_SHARED_MAPS_MAP_TILE_H
+#define ULTIMA_SHARED_MAPS_MAP_TILE_H
+
+#include "common/array.h"
+
+namespace Ultima {
+namespace Shared {
+namespace Maps {
+
+class MapWidget;
+
+/**
+ * Contains data about a given position within the map
+ */
+class MapTile {
+public:
+	int _tileId;							// Original tile Id
+	int _tileDisplayNum;					// Tile number to display. Can differ from tileId, such as tiles in the
+											// city for talking/stealing to merchants showing as ground
+	Common::Array<MapWidget *> _widgets;	// Widgets on the tile, if any
+	int _widgetNum;							// Widget number of first widget, if any
+	MapWidget *_widget;						// Pointer tofirst widget on tile, if any
+	// Dungeon tile flags
+	bool _isDoor, _isSecretDoor;
+	bool _isLadderUp, _isLadderDown;
+	bool _isWall, _isHallway, _isBeams;
+public:
+	/**
+	 * Constructor
+	 */
+	MapTile() : _tileDisplayNum(-1), _tileId(-1), _widgetNum(-1), _widget(0),
+		_isDoor(false), _isSecretDoor(false), _isLadderUp(false), _isLadderDown(false), _isWall(false),
+		_isHallway(false), _isBeams(false) {}
+
+	/**
+	 * Destructor
+	 */
+	virtual ~MapTile() {}
+
+	/**
+	 * Clears the map tile information
+	 */
+	virtual void clear();
+
+	/**
+	 * Returns true if the tile is a door in a dungeon
+	 */
+	bool isDoor() const { return _isDoor; }
+
+	/**
+	 * Returns true if the tile is a wall or secret door in a dungeon
+	 */
+	bool isWallOrSecretDoor() const { return _isWall || _isSecretDoor; }
+
+	/**
+	 * Returns true if the tile in a dungeon is a type that has walls on it: walls, doors, or secret doors
+	 */
+	bool isWallOrDoorway() const { return _isWall || _isDoor || _isSecretDoor; }
+
+	/**
+	 * Returns true if a tile is a solid type within a dungeon
+	 */
+	bool isSolid() const { return !(_isHallway || _isLadderUp || _isLadderDown || _isBeams); }
+};
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif

engines/ultima/shared/maps/map_widget.cpp

@@ -0,0 +1,117 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "ultima/shared/maps/map_widget.h"
+#include "ultima/shared/maps/map_base.h"
+#include "ultima/shared/maps/map_tile.h"
+#include "ultima/shared/early/game.h"
+#include "ultima/shared/gfx/visual_item.h"
+
+namespace Ultima {
+namespace Shared {
+namespace Maps {
+
+EMPTY_MESSAGE_MAP(MapWidget, MessageTarget);
+
+Direction MapWidget::directionFromKey(Common::KeyCode keycode) {
+	switch (keycode) {
+	case Common::KEYCODE_LEFT:
+	case Common::KEYCODE_KP4:
+		return DIR_WEST;
+
+	case Common::KEYCODE_RIGHT:
+	case Common::KEYCODE_KP6:
+		return DIR_EAST;
+
+	case Common::KEYCODE_UP:
+	case Common::KEYCODE_KP8:
+		return DIR_NORTH;
+
+	case Common::KEYCODE_DOWN:
+	case Common::KEYCODE_KP2:
+		return DIR_SOUTH;
+
+	default:
+		return DIR_NONE;
+	}
+}
+
+void MapWidget::synchronize(Common::Serializer &s) {
+	s.syncAsUint16LE(_position.x);
+	s.syncAsSint16LE(_position.y);
+	s.syncAsByte(_direction);
+	s.syncString(_name);
+}
+
+void MapWidget::addInfoMsg(const Common::String &text, bool newLine, bool replaceLine) {
+	CInfoMsg msg(text, newLine, replaceLine);
+	msg.execute(_game->getView());
+}
+
+MapWidget::CanMove MapWidget::canMoveTo(const Point &destPos) {
+	if (destPos.x < 0 || destPos.y < 0 || destPos.x >= (int)_map->width() || destPos.y >= (int)_map->height()) {
+		// If the map is fixed, allow moving beyond it's edges so it can be left
+		if (!_map->isMapWrapped())
+			return YES;
+	}
+
+	// Get the details of the position
+	MapTile destTile;
+	_map->getTileAt(destPos, &destTile);
+
+	// If there's a widget blocking the tile, return false
+	if (destTile._widget && destTile._widget->isBlocking())
+		return NO;
+
+	return UNSET;
+}
+
+void MapWidget::moveTo(const Point &destPos, Direction dir) {
+	// If no direction is specified, we'll need to figure it out relative to the old position
+	if (dir == DIR_NONE) {
+		Point delta = destPos - _position;
+		if (ABS(delta.x) > ABS(delta.y))
+			_direction = delta.x > 0 ? DIR_EAST : DIR_WEST;
+		else if (delta.y != 0)
+			_direction = delta.y > 0 ? DIR_SOUTH : DIR_NORTH;
+	} else {
+		_direction = dir;
+	}
+
+	// Set new location
+	_position = destPos;
+
+	// Handle wrap around if need be on maps that wrap
+	if (_map->isMapWrapped()) {
+		if (_position.x < 0)
+			_position.x += _map->width();
+		else if (_position.x >= (int)_map->width())
+			_position.x -= _map->width();
+		if (_position.y < 0)
+			_position.y += _map->height();
+		else if (_position.y >= (int)_map->height())
+			_position.y -= _map->height();
+	}
+}
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima

engines/ultima/shared/maps/map_widget.h

@@ -0,0 +1,137 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ULTIMA_SHARED_MAPS_MAP_WIDGET_H
+#define ULTIMA_SHARED_MAPS_MAP_WIDGET_H
+
+#include "common/events.h"
+#include "common/ptr.h"
+#include "common/serializer.h"
+#include "common/str.h"
+#include "ultima/shared/core/message_target.h"
+#include "ultima/shared/core/rect.h"
+
+namespace Ultima {
+namespace Shared {
+
+class Game;
+
+namespace Maps {
+
+enum Direction {
+	DIR_NONE = 0,
+	DIR_LEFT = 1, DIR_RIGHT = 2, DIR_UP = 3, DIR_DOWN = 4,
+	DIR_WEST = 1, DIR_EAST = 2, DIR_NORTH = 3, DIR_SOUTH = 4
+};
+
+class MapBase;
+
+/**
+ * Base class for things that appear within a map, such as monsters, transports, or people
+ */
+class MapWidget : public MessageTarget {
+	DECLARE_MESSAGE_MAP;
+protected:
+	Game *_game;						// Game reference
+	MapBase *_map;						// Map reference
+public:
+	Point _position;					// Position within the map
+	Direction _direction;				// Direction
+	Common::String _name;				// Name of widget
+public:
+	/**
+	 * Support method to get a direction from a keycode
+	 */
+	static Direction directionFromKey(Common::KeyCode keycode);
+public:
+	CLASSDEF;
+
+	/**
+	 * Constructor
+	 */
+	MapWidget(Game *game, MapBase *map) : _game(game), _map(map), _direction(DIR_NONE) {}
+	MapWidget(Game *game, MapBase *map, const Point &pt, Direction dir = DIR_NONE) : _game(game), _map(map), _position(pt), _direction(dir) {}
+	MapWidget(Game *game, MapBase *map, const Common::String &name, const Point &pt, Direction dir = DIR_NONE) :
+		_game(game), _map(map), _name(name), _position(pt), _direction(dir) {}
+
+	/**
+	 * Destructor
+	 */
+	~MapWidget() override {}
+
+	/**
+	 * Return a name for a widget class if it can be synchronized to savegames
+	 */
+	virtual const char *getClassName() const { return nullptr; }
+
+	/**
+	 * Handles loading and saving game data
+	 */
+	virtual void synchronize(Common::Serializer &s);
+
+	/**
+	 * Adds a text string to the info area
+	 * @param text			Text to add
+	 * @param newLine		Whether to apply a newline at the end
+	 * @param replaceLine	If true, replaces the current last line
+	 */
+	void addInfoMsg(const Common::String &text, bool newLine = true, bool replaceLine = false);
+
+	/**
+	 * Get the tile for the widget
+	 */
+	virtual uint getTileNum() const { return 0; }
+
+	/**
+	 * Returns true if the player can move onto a tile the widget occupies
+	 */
+	virtual bool isBlocking() const { return true; }
+
+	/**
+	 * Called to update the widget at the end of a turn
+	 * @param isPreUpdate		Update is called twice in succession during the end of turn update.
+	 *		Once with true for all widgets, then with it false
+	 */
+	virtual void update(bool isPreUpdate) {}
+
+	enum CanMove { UNSET = 0, YES = 1, NO = 2 };
+
+	/**
+	 * Returns true if the given widget can move to a given position on the map
+	 */
+	virtual CanMove canMoveTo(const Point &destPos);
+
+	/**
+	 * Moves the widget to a given position
+	 * @param destPos		Specified new position
+	 * @param dir			Optional explicit direction to set. If not specified,
+	 *		the direction will be set relative to the position moved from
+	 */
+	virtual void moveTo(const Point &destPos, Direction dir = DIR_NONE);
+};
+
+typedef Common::SharedPtr<MapWidget> MapWidgetPtr;
+
+} // End of namespace Maps
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif