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