summaryrefslogtreecommitdiff
path: root/src/resources/map/map.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/resources/map/map.h')
-rw-r--r--src/resources/map/map.h540
1 files changed, 540 insertions, 0 deletions
diff --git a/src/resources/map/map.h b/src/resources/map/map.h
new file mode 100644
index 000000000..f0712be76
--- /dev/null
+++ b/src/resources/map/map.h
@@ -0,0 +1,540 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2004-2009 The Mana World Development Team
+ * Copyright (C) 2009-2010 The Mana Developers
+ * Copyright (C) 2011-2014 The ManaPlus Developers
+ *
+ * This file is part of The ManaPlus Client.
+ *
+ * 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
+ * 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 RESOURCES_MAP_MAP_H
+#define RESOURCES_MAP_MAP_H
+
+#include "position.h"
+
+#include "being/actor.h"
+
+#include "resources/map/properties.h"
+
+#include "listeners/configlistener.h"
+
+#include "render/renderers.h"
+
+#include <string>
+#include <vector>
+
+class Animation;
+class AmbientLayer;
+class Image;
+class MapHeights;
+class MapItem;
+class MapLayer;
+class ObjectsLayer;
+class Particle;
+class Resource;
+class SimpleAnimation;
+class SpecialLayer;
+class Tileset;
+class WalkLayer;
+
+typedef std::vector<Tileset*> Tilesets;
+typedef std::vector<MapLayer*> Layers;
+typedef Layers::const_iterator LayersCIter;
+
+typedef std::vector<std::pair<MapLayer*, int> > TilePairVector;
+typedef TilePairVector::const_iterator TilePairVectorCIter;
+
+typedef std::vector<AmbientLayer*> AmbientLayerVector;
+typedef AmbientLayerVector::const_iterator AmbientLayerVectorCIter;
+typedef AmbientLayerVector::iterator AmbientLayerVectorIter;
+
+static const int mapTileSize = 32;
+
+/**
+ * A meta tile stores additional information about a location on a tile map.
+ * This is information that doesn't need to be repeated for each tile in each
+ * layer of the map.
+ */
+struct MetaTile final
+{
+ /**
+ * Constructor.
+ */
+ MetaTile() : Fcost(0), Gcost(0), Hcost(0), whichList(0),
+ parentX(0), parentY(0), blockmask(0)
+ {}
+
+ A_DELETE_COPY(MetaTile)
+
+ // Pathfinding members
+ int Fcost; /**< Estimation of total path cost */
+ int Gcost; /**< Cost from start to this location */
+ int Hcost; /**< Estimated cost to goal */
+ unsigned whichList; /**< No list, open list or closed list */
+ int parentX; /**< X coordinate of parent tile */
+ int parentY; /**< Y coordinate of parent tile */
+ unsigned char blockmask; /**< Blocking properties of this tile */
+};
+
+/**
+ * Animation cycle of a tile image which changes the map accordingly.
+ */
+class TileAnimation final
+{
+ public:
+ explicit TileAnimation(Animation *const ani);
+
+ ~TileAnimation();
+
+ A_DELETE_COPY(TileAnimation)
+
+ bool update(const int ticks = 1);
+
+ void addAffectedTile(MapLayer *const layer, const int index)
+ { mAffected.push_back(std::make_pair(layer, index)); }
+
+ private:
+ TilePairVector mAffected;
+ SimpleAnimation *mAnimation;
+ Image *mLastImage;
+};
+
+typedef std::map<int, TileAnimation*> TileAnimationMap;
+typedef TileAnimationMap::const_iterator TileAnimationMapCIter;
+
+/**
+ * A tile map.
+ */
+class Map final : public Properties, public ConfigListener
+{
+ public:
+ enum BlockType
+ {
+ BLOCKTYPE_NONE = -1,
+ BLOCKTYPE_WALL,
+ BLOCKTYPE_CHARACTER,
+ BLOCKTYPE_MONSTER,
+ BLOCKTYPE_AIR,
+ BLOCKTYPE_WATER,
+ BLOCKTYPE_GROUND,
+ BLOCKTYPE_GROUNDTOP,
+ NB_BLOCKTYPES
+ };
+
+ enum CollisionTypes
+ {
+ COLLISION_EMPTY = 0, // no collision
+ COLLISION_WALL = 1, // full collison
+ COLLISION_AIR = 2, // air units can walk
+ COLLISION_WATER = 3, // water units can walk
+ COLLISION_GROUNDTOP = 4, // no collision (chair, bed, etc)
+ COLLISION_MAX = 5 // count index
+ };
+
+ enum BlockMask
+ {
+ BLOCKMASK_WALL = 0x80, // 1000 0000
+ BLOCKMASK_CHARACTER = 0x01, // 0000 0001
+ BLOCKMASK_MONSTER = 0x02, // 0000 0010
+ BLOCKMASK_AIR = 0x04, // 0000 0100
+ BLOCKMASK_WATER = 0x08, // 0000 1000
+ BLOCKMASK_GROUND = 0x10, // 0001 0000
+ BLOCKMASK_GROUNDTOP = 0x20 // 0010 0000
+ };
+
+ enum DebugType
+ {
+ MAP_NORMAL = 0,
+ MAP_DEBUG = 1,
+ MAP_SPECIAL = 2,
+ MAP_SPECIAL2 = 3,
+ MAP_SPECIAL3 = 4,
+ MAP_BLACKWHITE = 5
+ };
+
+ /**
+ * Constructor, taking map and tile size as parameters.
+ */
+ Map(const int width, const int height,
+ const int tileWidth, const int tileHeight);
+
+ A_DELETE_COPY(Map)
+
+ /**
+ * Destructor.
+ */
+ ~Map();
+
+ /**
+ * Initialize ambient layers. Has to be called after all the properties
+ * are set.
+ */
+ void initializeAmbientLayers();
+
+ /**
+ * Updates animations. Called as needed.
+ */
+ void update(const int ticks = 1);
+
+ /**
+ * Draws the map to the given graphics output. This method draws all
+ * layers, actors and overlay effects.
+ *
+ * TODO: For efficiency reasons, this method could take into account
+ * the clipping rectangle set on the Graphics object. However,
+ * currently the map is always drawn full-screen.
+ */
+ void draw(Graphics *const graphics, int scrollX, int scrollY);
+
+ /**
+ * Visualizes collision layer for debugging
+ */
+ void drawCollision(Graphics *const graphics,
+ const int scrollX, const int scrollY,
+ const int debugFlags) const;
+
+ /**
+ * Adds a layer to this map. The map takes ownership of the layer.
+ */
+ void addLayer(MapLayer *const layer);
+
+ /**
+ * Adds a tileset to this map. The map takes ownership of the tileset.
+ */
+ void addTileset(Tileset *const tileset);
+
+ /**
+ * Finds the tile set that a tile with the given global id is part of.
+ */
+ const Tileset *getTilesetWithGid(const int gid) const A_WARN_UNUSED;
+
+ /**
+ * Get tile reference.
+ */
+ const MetaTile *getMetaTile(const int x,
+ const int y) const A_WARN_UNUSED;
+
+ /**
+ * Marks a tile as occupied.
+ */
+ void blockTile(const int x, const int y, const BlockType type);
+
+ /**
+ * Gets walkability for a tile with a blocking bitmask. When called
+ * without walkmask, only blocks against colliding tiles.
+ */
+ bool getWalk(const int x, const int y,
+ const unsigned char walkmask = BLOCKMASK_WALL
+ | BLOCKMASK_AIR | BLOCKMASK_WATER) const A_WARN_UNUSED;
+
+ void setWalk(const int x, const int y, const bool walkable);
+
+ unsigned char getBlockMask(const int x, const int y) const;
+
+ /**
+ * Returns the width of this map in tiles.
+ */
+ int getWidth() const A_WARN_UNUSED
+ { return mWidth; }
+
+ /**
+ * Returns the height of this map in tiles.
+ */
+ int getHeight() const A_WARN_UNUSED
+ { return mHeight; }
+
+ /**
+ * Returns the tile width of this map.
+ */
+ int getTileWidth() const A_WARN_UNUSED
+ { return mTileWidth; }
+
+ /**
+ * Returns the tile height used by this map.
+ */
+ int getTileHeight() const A_WARN_UNUSED
+ { return mTileHeight; }
+
+ const std::string getMusicFile() const A_WARN_UNUSED;
+
+ void setMusicFile(const std::string &file);
+
+ const std::string getName() const A_WARN_UNUSED;
+
+ /**
+ * Gives the map id based on filepath (ex: 009-1)
+ */
+ const std::string getFilename() const A_WARN_UNUSED;
+
+ /**
+ * Find a path from one location to the next.
+ */
+ Path findPath(const int startX, const int startY,
+ const int destX, const int destY,
+ const unsigned char walkmask,
+ const int maxCost = 20) A_WARN_UNUSED;
+
+ /**
+ * Adds a particle effect
+ */
+ void addParticleEffect(const std::string &effectFile,
+ const int x, const int y,
+ const int w = 0, const int h = 0);
+
+ /**
+ * Initializes all added particle effects
+ */
+ void initializeParticleEffects(Particle *const particleEngine);
+
+ /**
+ * Adds a tile animation to the map
+ */
+ void addAnimation(const int gid, TileAnimation *const animation)
+ { mTileAnimations[gid] = animation; }
+
+ void setDebugFlags(const int n)
+ { mDebugFlags = n; }
+
+ int getDebugFlags() const A_WARN_UNUSED
+ { return mDebugFlags; }
+
+ void addExtraLayer();
+
+ void saveExtraLayer() const;
+
+ SpecialLayer *getTempLayer() const A_WARN_UNUSED
+ { return mTempLayer; }
+
+ SpecialLayer *getSpecialLayer() const A_WARN_UNUSED
+ { return mSpecialLayer; }
+
+ void setHasWarps(const bool n)
+ { mHasWarps = n; }
+
+ bool getHasWarps() const A_WARN_UNUSED
+ { return mHasWarps; }
+
+ std::string getUserMapDirectory() const A_WARN_UNUSED;
+
+ void addPortal(const std::string &name, const int type,
+ const int x, const int y, const int dx, const int dy);
+
+ void addRange(const std::string &name, const int type,
+ const int x, const int y, const int dx, const int dy);
+
+ void addPortalTile(const std::string &name, const int type,
+ const int x, const int y);
+
+ void updatePortalTile(const std::string &name, const int type,
+ const int x, const int y,
+ const bool addNew = true);
+
+ const std::vector<MapItem*> &getPortals() const A_WARN_UNUSED
+ { return mMapPortals; }
+
+ /**
+ * Gets the tile animation for a specific gid
+ */
+ const TileAnimation *getAnimationForGid(const int gid)
+ const A_WARN_UNUSED;
+
+ void optionChanged(const std::string &value) override final;
+
+ MapItem *findPortalXY(const int x, const int y) const A_WARN_UNUSED;
+
+ int getActorsCount() const A_WARN_UNUSED
+ { return static_cast<int>(mActors.size()); }
+
+ void setPvpMode(const int mode);
+
+ const ObjectsLayer* getObjectsLayer() const A_WARN_UNUSED
+ { return mObjects; }
+
+ std::string getObjectData(const unsigned x, const unsigned y,
+ const int type) const A_WARN_UNUSED;
+
+ void indexTilesets();
+
+ void clearIndexedTilesets();
+
+ void setActorsFix(const int x, const int y)
+ { mActorFixX = x; mActorFixY = y; }
+
+ int getVersion() const A_WARN_UNUSED
+ { return mVersion; }
+
+ void setVersion(const int n)
+ { mVersion = n; }
+
+ void reduce();
+
+ void redrawMap();
+
+ bool empty() const A_WARN_UNUSED
+ { return mLayers.empty(); }
+
+ void setCustom(const bool b)
+ { mCustom = b; }
+
+ bool isCustom() const A_WARN_UNUSED
+ { return mCustom; }
+
+ const std::map<int, TileAnimation*> &getTileAnimations()
+ const A_WARN_UNUSED
+ { return mTileAnimations; }
+
+ void setAtlas(Resource *const atlas)
+ { mAtlas = atlas; }
+
+ const MetaTile *getMetaTiles() const
+ { return mMetaTiles; }
+
+ WalkLayer *getWalkLayer()
+ { return mWalkLayer; }
+
+ void setWalkLayer(WalkLayer *const layer)
+ { mWalkLayer = layer; }
+
+ void addHeights(MapHeights *const heights);
+
+ uint8_t getHeightOffset(const int x, const int y) const;
+
+ void setMask(const int mask);
+
+ protected:
+ friend class Actor;
+ friend class Minimap;
+
+ /**
+ * Adds an actor to the map.
+ */
+ Actors::iterator addActor(Actor *const actor);
+
+ /**
+ * Removes an actor from the map.
+ */
+ void removeActor(const Actors::iterator &iterator);
+
+ private:
+ enum LayerType
+ {
+ FOREGROUND_LAYERS = 0,
+ BACKGROUND_LAYERS
+ };
+
+ /**
+ * Updates scrolling of ambient layers. Has to be called each game tick.
+ */
+ void updateAmbientLayers(const float scrollX, const float scrollY);
+
+ /**
+ * Draws the foreground or background layers to the given graphics output.
+ */
+ void drawAmbientLayers(Graphics *const graphics, const LayerType type,
+ const int detail);
+
+ /**
+ * Tells whether the given coordinates fall within the map boundaries.
+ */
+ bool contains(const int x, const int y) const A_WARN_UNUSED;
+
+ /**
+ * Blockmasks for different entities
+ */
+ unsigned *mOccupation[NB_BLOCKTYPES];
+
+ int mWidth;
+ int mHeight;
+ int mTileWidth, mTileHeight;
+ int mMaxTileHeight;
+ MetaTile *mMetaTiles;
+ WalkLayer *mWalkLayer;
+ Layers mLayers;
+ Tilesets mTilesets;
+ Actors mActors;
+ bool mHasWarps;
+
+ // debug flags
+ int mDebugFlags;
+
+ // Pathfinding members
+ unsigned int mOnClosedList;
+ unsigned int mOnOpenList;
+
+ // Overlay data
+ AmbientLayerVector mBackgrounds;
+ AmbientLayerVector mForegrounds;
+ float mLastAScrollX;
+ float mLastAScrollY;
+
+ // Particle effect data
+ struct ParticleEffectData
+ {
+ ParticleEffectData() :
+ file(),
+ x(0),
+ y(0),
+ w(0),
+ h(0)
+ {
+ }
+
+ std::string file;
+ int x;
+ int y;
+ int w;
+ int h;
+ };
+ std::vector<ParticleEffectData> mParticleEffects;
+
+ std::vector<MapItem*> mMapPortals;
+
+ std::map<int, TileAnimation*> mTileAnimations;
+
+ int mOverlayDetail;
+ float mOpacity;
+ RenderType mOpenGL;
+ int mPvp;
+ bool mTilesetsIndexed;
+ Tileset** mIndexedTilesets;
+ int mIndexedTilesetsSize;
+ int mActorFixX;
+ int mActorFixY;
+ int mVersion;
+
+ SpecialLayer *mSpecialLayer;
+ SpecialLayer *mTempLayer;
+ ObjectsLayer *mObjects;
+ MapLayer *mFringeLayer;
+
+ int mLastX;
+ int mLastY;
+ int mLastScrollX;
+ int mLastScrollY;
+
+ int mDrawX;
+ int mDrawY;
+ int mDrawScrollX;
+ int mDrawScrollY;
+ int mMask;
+ Resource *mAtlas;
+ MapHeights *mHeights;
+ bool mRedrawMap;
+ bool mBeingOpacity;
+ bool mCustom;
+};
+
+#endif // RESOURCES_MAP_MAP_H