tmw/src/map.h

Go to the documentation of this file.

/*
 *  The Mana World
 *  Copyright (C) 2004  The Mana World Development Team
 *
 *  This file is part of The Mana World.
 *
 *  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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef MAP_H
#define MAP_H

#include <list>
#include <vector>

#include "position.h"
#include "properties.h"

class Animation;
class AmbientOverlay;
class Graphics;
class Image;
class MapLayer;
class Particle;
class SimpleAnimation;
class Sprite;
class Tileset;

typedef std::vector<Tileset*> Tilesets;
typedef std::list<Sprite*> Sprites;
typedef Sprites::iterator SpriteIterator;
typedef std::vector<MapLayer*> Layers;

struct MetaTile
{
    MetaTile() : whichList(0), blockmask(0) {}

    // Pathfinding members
    int Fcost;               
    int Gcost;               
    int Hcost;               
    int whichList;           
    int parentX;             
    int parentY;             
    unsigned char blockmask; 
};

class TileAnimation
{
    public:
        TileAnimation(Animation *ani);
        ~TileAnimation();
        void update(int ticks = 1);
        void addAffectedTile(MapLayer *layer, int index)
        { mAffected.push_back(std::make_pair(layer, index)); }
    private:
        std::list<std::pair<MapLayer*, int> > mAffected;
        SimpleAnimation *mAnimation;
        Image *mLastImage;
};

class MapLayer
{
    public:
        MapLayer(int x, int y, int width, int height, bool isFringeLayer);

        ~MapLayer();

        void setTile(int x, int y, Image *img);

        void setTile(int index, Image *img) { mTiles[index] = img; }

        Image *getTile(int x, int y) const;

        void draw(Graphics *graphics,
                  int startX, int startY,
                  int endX, int endY,
                  int scrollX, int scrollY,
                  const Sprites &sprites) const;

    private:
        int mX, mY;
        int mWidth, mHeight;
        bool mIsFringeLayer;    
        Image **mTiles;
};

class Map : public Properties
{
    public:
        enum BlockType
        {
            BLOCKTYPE_NONE = -1,
            BLOCKTYPE_WALL,
            BLOCKTYPE_CHARACTER,
            BLOCKTYPE_MONSTER,
            NB_BLOCKTYPES
        };

        Map(int width, int height, int tileWidth, int tileHeight);

        ~Map();

        void initializeOverlays();

        void update(int ticks = 1);

        void draw(Graphics *graphics, int scrollX, int scrollY);

        void drawCollision(Graphics *graphics, int scrollX, int scrollY);

        void addLayer(MapLayer *layer);

        void addTileset(Tileset *tileset);

        Tileset* getTilesetWithGid(int gid) const;

        MetaTile *getMetaTile(int x, int y) const;

        void blockTile(int x, int y, BlockType type);

        bool getWalk(int x, int y, char walkmask = BLOCKMASK_WALL) const;

        int getWidth() const { return mWidth; }

        int getHeight() const { return mHeight; }

        int getTileWidth() const { return mTileWidth; }

        int getTileHeight() const { return mTileHeight; }

        Path findPath(int startX, int startY, int destX, int destY,
                      unsigned char walkmask, int maxCost = 20);

        SpriteIterator addSprite(Sprite *sprite);

        void removeSprite(SpriteIterator iterator);

        void addParticleEffect(const std::string &effectFile, int x, int y);

        void initializeParticleEffects(Particle* particleEngine);

        void addAnimation(int gid, TileAnimation *animation)
        { mTileAnimations[gid] = animation; }

        TileAnimation *getAnimationForGid(int gid);

    private:
        void drawOverlay(Graphics *graphics, float scrollX, float scrollY,
                         int detail);

        bool contains(int x, int y) const;

        static const unsigned char BLOCKMASK_WALL = 0x80;     // = bin 1000 0000
        static const unsigned char BLOCKMASK_CHARACTER = 0x01;// = bin 0000 0001
        static const unsigned char BLOCKMASK_MONSTER = 0x02;  // = bin 0000 0010
        int *mOccupation[NB_BLOCKTYPES];

        int mWidth, mHeight;
        int mTileWidth, mTileHeight;
        int mMaxTileHeight;
        MetaTile *mMetaTiles;
        Layers mLayers;
        Tilesets mTilesets;
        Sprites mSprites;

        // Pathfinding members
        int mOnClosedList, mOnOpenList;

        // Overlay data
        std::list<AmbientOverlay*> mOverlays;
        float mLastScrollX;
        float mLastScrollY;

        // Particle effect data
        struct ParticleEffectData
        {
            std::string file;
            int x;
            int y;
        };
        std::list<ParticleEffectData> particleEffects;

        std::map<int, TileAnimation*> mTileAnimations;
};

#endif

---