map_base.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_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;

class MapBase {
    class WidgetsArray : public Common::Array<MapWidgetPtr> {
    public:
        MapWidget *findByClass(const ClassDef &classDef) const;
    };

    struct MapCellsRow {
    private:
        Common::Array<MapCell> _data;
    public:
        byte &operator[](int idx) { return _data[idx]; }
        byte operator[](int idx) const { return _data[idx]; }

        void resize(size_t newSize) { _data.resize(newSize); }
    };

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

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:
    void setDimensions(const Point &size);

    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:
    MapBase(Game *game, Map *) : _game(game),_playerWidget(nullptr),
        _mapModified(false), _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, bool includePlayer = true);

    virtual void setTileAt(const Point &pt, uint tileId);

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

    virtual MapWidget *createWidget(const Common::String &name) = 0;

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

    uint getMapStyle() const { return _mapStyle; }

    virtual void shiftViewport(const Point &delta);

    virtual void update();

    virtual void castSpell(uint spell) = 0;
};

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

#endif