map.h

/* 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_CORE_MAP_H
#define ULTIMA_SHARED_CORE_MAP_H

#include "common/array.h"
#include "common/ptr.h"
#include "common/serializer.h"
#include "ultima/shared/core/rect.h"
#include "ultima/shared/gfx/dungeon_surface.h"

namespace Ultima {
namespace Shared {

#define REGISTER_WIDGET(NAME) if (name == #NAME) return new Widgets::NAME(_game, (Ultima1Map::MapBase *)map)
#define DECLARE_WIDGET(NAME) const char *getClassName() const override { return #NAME; }

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
};

typedef byte MapCell;
typedef int MapId;

class Game;
class MapWidget;

typedef Common::SharedPtr<MapWidget> MapWidgetPtr;

class MapTile {
public:
    int _tileId;                            // Tile Id
    int _tileNum;                           // Tile number to display. Normally equals Tile Id, but can differ in rare cases
    int _widgetNum;                         // Widget number, if any
    MapWidget *_widget;                     // Widget pointer
    int _itemNum;                           // Item number, if any
    // Dungeon tile flags
    bool _isDoor, _isSecretDoor;
    bool _isLadderUp, _isLadderDown;
    bool _isWall, _isHallway, _isBeams;
public:
    MapTile() : _tileNum(-1), _tileId(-1), _widgetNum(-1), _widget(nullptr), _itemNum(-1),
        _isDoor(false), _isSecretDoor(false), _isLadderUp(false), _isLadderDown(false), _isWall(false),
        _isHallway(false), _isBeams(false) {}

    virtual ~MapTile() {}

    virtual void clear();

    bool isDoor() const { return _isDoor; }

    bool isWallOrSecretDoor() const { return _isWall || _isSecretDoor; }

    bool isWallOrDoorway() const { return _isWall || _isDoor || _isSecretDoor; }

    bool isSolid() const { return !(_isHallway || _isLadderUp || _isLadderDown || _isBeams); }
};

class Map {
    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

        ViewportPosition() : _topLeft(-1, -1), _mapId(-1) {}

        bool isValid() const { return _mapId != -1; }

        void synchronize(Common::Serializer &s) {
            s.syncAsUint16LE(_topLeft.x);
            s.syncAsUint16LE(_topLeft.y);
        }

        void reset() { _mapId = -1; }
    };

    struct MapCellsRow {
    public:
        Common::Array<MapCell> _data;
    public:
        byte &operator[](int idx) { return _data[idx]; }
        byte operator[](int idx) const { return _data[idx]; }
    };
public:
    class MapBase {
    private:
        Map *_map;                          // Map manager reference
    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
    protected:
        void setDimensions(const Point &size);
    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
        Common::Array<MapWidgetPtr> _widgets;   // Party, monsteres, transports, etc.
        Common::Array<MapCellsRow> _data;   // Data for the map
    public:
        MapBase(Game *game, Map *map) : _map(map), _playerWidget(nullptr), _mapId(0), _mapIndex(0),
            _mapStyle(0) {}

        virtual ~MapBase() {}

        virtual void synchronize(Common::Serializer &s);

        void addWidget(MapWidget *widget);

        void removeWidget(MapWidget *widget);

        virtual void clear();

        virtual void getTileAt(const Point &pt, MapTile *tile);

        void resetViewport();

        virtual Point getViewportPosition(const Point &viewportSize);

        virtual void load(MapId mapId);

        virtual bool changeLevel(int delta) { return true; }

        virtual uint getLevel() const { return 0; }

        virtual bool isMapWrapped() const { return false; }

        size_t width() const { return _size.x; }

        size_t height() const { return _size.y; }

        Point getPosition() const;

        void setPosition(const Point &pt);

        Direction getDirection() const;

        void setDirection(Direction dir);

        Point getDirectionDelta() const;

        virtual Point getDeltaPosition(const Point &delta);

        MapId getMapId() const { return _mapId; }

        uint getMapIndex() const { return _mapIndex; }

        virtual void shiftViewport(const Point &delta);

        virtual void update();
    };
protected:
    MapBase *_mapArea;
public:
    Map() : _mapArea(nullptr) {}

    virtual ~Map() {}

    virtual void load(MapId mapId);

    virtual void clear();

    virtual void synchronize(Common::Serializer &s);

    virtual MapWidget *createWidget(Map::MapBase *map, const Common::String &name) = 0;

    void getTileAt(const Point &pt, MapTile *tile) {
        assert(_mapArea);
        return _mapArea->getTileAt(pt, tile);
    }

    Point getViewportPosition(const Point &viewportSize) {
        assert(_mapArea);
        return _mapArea->getViewportPosition(viewportSize);
    }

    size_t width() const {
        assert(_mapArea);
        return _mapArea->width();
    }

    size_t height() const {
        assert(_mapArea);
        return _mapArea->height();
    }

    Point getPosition() const {
        assert(_mapArea);
        return _mapArea->getPosition();
    }

    void setPosition(const Point &pt) {
        assert(_mapArea);
        _mapArea->setPosition(pt);
    }

    Direction getDirection() const {
        assert(_mapArea);
        return _mapArea->getDirection();
    }

    void setDirection(Direction dir) {
        assert(_mapArea);
        _mapArea->setDirection(dir);
    }

    Point getDirectionDelta() const {
        assert(_mapArea);
        return _mapArea->getDirectionDelta();
    }

    Point getDeltaPosition(const Point &delta) {
        assert(_mapArea);
        return _mapArea->getDeltaPosition(delta);
    }

    void shiftViewport(const Point &delta) {
        assert(_mapArea);
        _mapArea->shiftViewport(delta);
    }

    Point getTilesPerOrigTile() const {
        assert(_mapArea);
        return _mapArea->_tilesPerOrigTile;
    }

    Common::String getName() const {
        assert(_mapArea);
        return _mapArea->_name;
    }

    MapWidget *getPlayerWidget() const {
        assert(_mapArea);
        return _mapArea->_playerWidget;
    }

    bool changeLevel(int delta) {
        assert(_mapArea);
        return _mapArea->changeLevel(delta);
    }

    uint getLevel() const {
        assert(_mapArea);
        return _mapArea->getLevel();
    }

    bool isMapWrapped() const {
        assert(_mapArea);
        return _mapArea->isMapWrapped();
    }

    void update() {
        assert(_mapArea);
        return _mapArea->update();
    }
};

class MapWidget {
protected:
    Game *_game;                        // Game reference
    Map::MapBase *_map;                 // Map reference
public:
    Point _position;                    // Position within the map
    Direction _direction;               // Direction
    Common::String _name;               // Name of widget
public:
    MapWidget(Game *game, Map::MapBase *map) : _game(game), _map(map) {}
    MapWidget(Game *game, Map::MapBase *map, const Point &pt, Direction dir = DIR_NONE) : _game(game), _map(map), _position(pt), _direction(dir) {}
    MapWidget(Game *game, Map::MapBase *map, const Common::String &name, const Point &pt, Direction dir = DIR_NONE) :
        _game(game), _map(map), _name(name), _position(pt), _direction(dir) {}

    virtual ~MapWidget() {}

    virtual const char *getClassName() const { return nullptr; }

    virtual void synchronize(Common::Serializer &s);

    void addInfoMsg(const Common::String &text, bool newLine = true);

    virtual uint getTileNum() const { return 0; }

    virtual bool isBlocking() const { return false; }

    virtual void update(bool isPreUpdate) {}

    enum CanMove { UNSET = 0, YES = 1, NO = 2 };

    virtual CanMove canMoveTo(const Point &destPos);

    virtual void moveTo(const Point &destPos, Direction dir = DIR_NONE);
};

} // End of namespace Shared
} // End of namespace Ultima

#endif