Hosting courtesy of Sourceforge

               

---

Tile.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 TILE_H_
#define TILE_H_

#include "../Config.h"
#include "GameDebug.h"
#include "Moveable.h"
#include "../Graphics/draw.h"
#include "../Parse/ListParser.h"

#include <vector>
#include <fstream>

namespace Game {

        class MovementEffect {
        public:
                MovementEffect(Sint16 x, Sint16 y, bool relative=true);

                Sint16 getXchange() const;
                Sint16 getYchange() const;      

                bool isRelative() const;
        private:
                Sint16 x;
                Sint16 y;
                bool motionIsRelative;
        };

        class AbstractTile : public Graphics::DrawableAt, public Parse::Parseable {
        public:
                AbstractTile();
                virtual bool isPassable() const=0;

                virtual void hitWithExplosion() { }

                virtual MovementEffect AbstractTile::effect(MoveableItem& item);

                void occupy();
                void deOccupy();

                bool isOccupied() const;

                virtual ~AbstractTile();

                virtual AbstractTile* dynCopy() const=0;
        private:
                bool currentlyOccupied;
        };

        class SingleImageTile : public AbstractTile {
        public:
                SingleImageTile();

                SingleImageTile(Graphics::AbstractImage* image);
                virtual ~SingleImageTile();

                Parse::Parser* makeParserToParseMe(istream &inputFile);
                void drawAt(SDL_Surface *screen, SDL_Rect *loc);

                void setImage(Graphics::AbstractImage* image);
        protected:
                Graphics::AbstractImage* img;
        };
        
        class IndestructibleTile : public SingleImageTile       { 
        public:
                virtual ~IndestructibleTile() {  }

                bool isPassable() const;
                AbstractTile* dynCopy() const;
        };

        class PassableTile: public SingleImageTile {
        public:
                virtual ~PassableTile() {  }

                AbstractTile* dynCopy() const;
                bool isPassable() const;
        };

        class ExplodableTile: public AbstractTile {
        public:
                ExplodableTile();
                ~ExplodableTile();

                bool isPassable() const;
                void hitWithExplosion();

                Parse::Parser* makeParserToParseMe(std::istream &input);

                void drawAt(SDL_Surface * screen, SDL_Rect * loc);
                
                AbstractTile* dynCopy() const;
        private:
                bool hasExploded;
                Graphics::AbstractImage* bombedImage;
                Graphics::AbstractImage* unbombedImage;
        };

        class ConveyorTile: public AbstractTile {
        public:
                ConveyorTile();
                ~ConveyorTile();
        
                bool isPassable() const;
        
                Parse::Parser* makeParserToParseMe(std::istream& input);

                virtual MovementEffect effect(MoveableItem& m);
        
                void drawAt(SDL_Surface* surf, SDL_Rect* loc);

                AbstractTile* dynCopy() const;
        private:
                Graphics::AbstractImage* img;
                Sint16 xSpeed;
                Sint16 ySpeed;
        };

        class SlipperyTile: public AbstractTile {
        public:
                SlipperyTile();
                ~SlipperyTile();

                MovementEffect effect(MoveableItem& p);

                bool isPassable() const;

                AbstractTile* dynCopy() const;
                void drawAt(SDL_Surface* surf, SDL_Rect* loc);

                Parse::Parser* makeParserToParseMe(std::istream& in);
        private:
                Graphics::AbstractImage* front;
                Graphics::AbstractImage* back;
        };              

        class TileSetReader : public Parse::Parseable {
        public:
                TileSetReader();
                ~TileSetReader();
                Game::AbstractTile* copyTile(int index) const;
                Game::AbstractTile* getTile(int index);
        //      friend std::ostream& operator << (std::ostream& o, const TileSet& ts);
                int numTiles() const;
                Parse::Parser* makeParserToParseMe(std::istream&);
        private:
                // throws if index is invalid
                void validateIndex(int index) const;
                std::vector<AbstractTile*> tileVec;
        };      
        
}; // namespace Game

//std::ostream& operator << (std::ostream& o, const TileSet &ts);

#endif // ifndef TILE_H_

---