Hosting courtesy of Sourceforge

               

---

GameMap.h

Go to the documentation of this file.

//
//      Copyright (C) 2002 Robert Renaud
//
//      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 (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, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//


#ifndef GAME_MAP_H_
#define GAME_MAP_H_

#include "../Config.h"

#include <vector>
#include <string>

#include "SDL.h"

#include "GameDebug.h"
#include "Bomb.h"
#include "Flame.h"
#include "MapLocation.h"
#include "Moveable.h"
#include "Player.h"
#include "Powerup.h"
#include "Tile.h"

#include "../Parse/ListParser.h"
#include "../Parse/Parse.h"
#include "../Util/Matrix.h"
#include "../Util/GeneralException.h"
#include "../Util/STL_Helper.h"

using std::vector; using std::string;
namespace Game {

        namespace Constants {
                const size_t MAP_NUM_ROWS=16;
                const size_t MAP_NUM_COLS=16;

                const bool ALLOW_BOMB_STACKING=false;
    };
        class GameMap {
        public:
                GameMap();
                ~GameMap();

                bool runGame(SDL_Surface* screen);
                void readMap(std::istream& input);

                bool tileIsPassable(int x, int y) const;                

                void explodeTile(int x, int y);

                void addPlayer(const std::string& blpFile, const std::string& cfgFile);

        private:                

                enum FlameStatus {
                        FLAME_STOP,
                        FLAME_KEEP_GOING
                };

                struct BombPlayerPair {
                        BombPlayerPair(AbstractPlayer* owner);
                        ~BombPlayerPair();
                        AbstractPlayer* owner;
                        Bomb* bomb;
                        MapLocation bombLoc;
                        bool markedForDeletion;
                        bool operator < (const BombPlayerPair& other) const;
                        bool operator == (const BombPlayerPair& other) const;
                };              

                class BombPairAtPred {                  
                        GameMap* gameMap;
                        int x, y;
                public:
                        BombPairAtPred(GameMap* map, int mapX, int mapY);
                        bool operator()(const BombPlayerPair* b);
                };
                
                friend class BombPairAtPred;

                struct MapTile {
                        MapTile();
                        ~MapTile();
                        BombPlayerPair* bombOwnerPair;
                        Powerup* powerup;
                        AbstractTile* tile;                     
                        Flame flame;
                };

                void putBomb(AbstractPlayer* player);
                void blowUpBomb(BombPlayerPair* b);             

                void occupyTile(int x, int y);          
                void deOccupyTile(int x, int y);
                bool isValidLocation(int x, int y) const;
                void removePowerupAt(int x, int y);

                bool playerHitByBomb(AbstractPlayer* p);
                
                bool moveObject(MoveableItem& m, Direction d, int speed, bool allowDirChange=true, int st = Constants::SLACK_TOLERANCE);
                bool moveHoriz(MoveableItem& m, int amount, int questionableHorizTileLoc, int slack, int st = Constants::SLACK_TOLERANCE);
                bool moveVert(MoveableItem& m, int amount, int questionableVertTileLoc, int slack, int st = Constants::SLACK_TOLERANCE);

                MapLocation getEmptyStartSpot();
                
                void deleteMarkedBombs();

                FlameStatus handleBombChain(int x, int y, FlameType dir);

                Util::Matrix<MapTile*> tileMatrix;
                std::list<AbstractPlayer*> playerList;
                std::list<MapLocation*> openStartLocations;
                std::set<BombPlayerPair*> bombPlayerSet;
                std::list<MapLocation*> tilesToExplode;
        }; // class GameMap

}; // namespace Game

#endif // ifndef GAME_MAP_H

---