Hosting courtesy of Sourceforge

               

---

Tile.cpp

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.
//

#include "Tile.h"
#include "../Util/STL_Helper.h"

using namespace Game;

MovementEffect::MovementEffect(Sint16 x_, Sint16 y_, bool relMotion) :
x(x_),
y(y_),
motionIsRelative(relMotion)
{ }

Sint16 MovementEffect::getXchange() const {
        return x;
}

Sint16 MovementEffect::getYchange() const {
        return y;
}

bool MovementEffect::isRelative() const{
        return motionIsRelative;
}

SingleImageTile::SingleImageTile() :
img(NULL)
{}

SingleImageTile::SingleImageTile(Graphics::AbstractImage * image) {
        setImage(image);
}

SingleImageTile::~SingleImageTile() {
        delete img;
        img = NULL;
}

void SingleImageTile::drawAt(SDL_Surface * screen, SDL_Rect *loc) {
        img->drawAt(screen,loc);
}

AbstractTile::AbstractTile() :
currentlyOccupied(false)
{ }

AbstractTile::~AbstractTile() { }

void AbstractTile::deOccupy() {
        currentlyOccupied = false;
}

void AbstractTile::occupy() {
        currentlyOccupied = true;
}

bool AbstractTile::isOccupied() const {
        return currentlyOccupied;
}

AbstractTile* IndestructibleTile::dynCopy() const {
        IndestructibleTile* newTile = new IndestructibleTile;
        newTile->img=img->dynCopyImage();

        return newTile;
}

AbstractTile* PassableTile::dynCopy() const {
        PassableTile* newTile = new PassableTile;
        newTile->img=img->dynCopyImage();
        return newTile;
}
        
Parse::Parser* SingleImageTile::makeParserToParseMe(std::istream &input) {
        Parse::SimpleParser* parser = new Parse::SimpleParser(input);
        parser->addAction("image", new Graphics::ReadImage(img));
        return parser;
}

void SingleImageTile::setImage(Graphics::AbstractImage *image) {
        delete img;
        img = image;
}

bool IndestructibleTile::isPassable() const{
        return false; // by definition
}

bool PassableTile::isPassable() const{
        if (isOccupied()) return false;
        return true; 
}

ExplodableTile::ExplodableTile() :
hasExploded(false),
bombedImage(NULL),
unbombedImage(NULL)
{}

AbstractTile* ExplodableTile::dynCopy() const {
        ExplodableTile* newTile = new ExplodableTile;
        newTile->bombedImage = bombedImage->dynCopyImage();
        newTile->unbombedImage = unbombedImage->dynCopyImage();
        return newTile;
}

void ExplodableTile::drawAt(SDL_Surface *screen, SDL_Rect *loc) {
        if (hasExploded) bombedImage->drawAt(screen, loc);
        else                     unbombedImage->drawAt(screen,loc);
}

Parse::Parser* ExplodableTile::makeParserToParseMe(std::istream &input) {
        Parse::SimpleParser* parser = new Parse::SimpleParser(input);
        parser->addAction("BombedImage",        new Graphics::ReadImage(bombedImage));
        parser->addAction("UnbombedImage",      new Graphics::ReadImage(unbombedImage));
        return parser;
}

bool ExplodableTile::isPassable() const {
        if (isOccupied()) return false;
        return hasExploded; // it is passable if its been bombed
}

void ExplodableTile::hitWithExplosion() {
        hasExploded = true;
        // cout << "ExplodableTile::hitWithExplosion()" << endl;
}

ExplodableTile::~ExplodableTile() {
        delete unbombedImage;
        delete bombedImage;
}

ConveyorTile::ConveyorTile() :
img(NULL),
xSpeed(0),
ySpeed(0)
{ }

ConveyorTile::~ConveyorTile() {
        delete img;
}

bool ConveyorTile::isPassable() const {
        return (!isOccupied());
}

MovementEffect ConveyorTile::effect(MoveableItem& m) {
        return MovementEffect(xSpeed, ySpeed, true);
}

void ConveyorTile::drawAt(SDL_Surface* surf, SDL_Rect* loc) {
        img->drawAt(surf, loc);
}

AbstractTile* ConveyorTile::dynCopy() const {
        ConveyorTile* tile = new ConveyorTile(*this);
        tile->img = img->dynCopyImage();
        return tile;
}

Parse::Parser* ConveyorTile::makeParserToParseMe(std::istream& in) {
        Parse::Parser* parser = new Parse::SimpleParser(in);
        
        parser->addAction("image", new Graphics::ReadImage(img));
        parser->addAction("xspeed", new Parse::StdRead<Sint16>(xSpeed));
        parser->addAction("yspeed", new Parse::StdRead<Sint16>(ySpeed));
        
        return parser;
}
        
SlipperyTile::SlipperyTile() :
front(NULL),
back(NULL)
{ }

SlipperyTile::~SlipperyTile() {
        delete front;
        delete back;
}

Parse::Parser* SlipperyTile::makeParserToParseMe(std::istream& in) {
        Parse::SimpleParser* p= new Parse::SimpleParser(in);
        p->addAction("front", new Graphics::ReadImage(front));
        p->addAction("back", new Graphics::ReadImage(back));
        return p;
}

void SlipperyTile::drawAt(SDL_Surface* surf,  SDL_Rect* loc) {
        if (back != NULL) back->drawAt(surf, loc);
        front->drawAt(surf, loc);
}

MovementEffect SlipperyTile::effect(MoveableItem& m) {
        if (m.getDirection() != Game::NO_DIRECTION) m.lockMovement();
        return MovementEffect(0,0);
}

bool SlipperyTile::isPassable() const {
        return !isOccupied();
}

AbstractTile* SlipperyTile::dynCopy() const {
        SlipperyTile* n = new SlipperyTile();
        n->front = front->dynCopyImage();
        n->back = back->dynCopyImage();
        return n;
}

TileSetReader::TileSetReader()
// :
//tileVec(0,NULL)
 { }

TileSetReader::~TileSetReader() {
        Util::freeDynamicContainer(tileVec);
}

int TileSetReader::numTiles() const {
    return (int) tileVec.size();
}

MovementEffect AbstractTile::effect(MoveableItem& item) {
        item.unlockMovement();
        return MovementEffect(0,0, false);
}

Game::AbstractTile* TileSetReader::copyTile(int index) const {
        validateIndex(index);
        return tileVec[index]->dynCopy();
}

Game::AbstractTile* TileSetReader::getTile(int index) {
        validateIndex(index);
        return tileVec[index];
}

void TileSetReader::validateIndex(int index) const {
    if ((index >= (int) tileVec.size() || index < 0)) {
                throw Util::GeneralException("Tile index " + Util::toString(index) + " out of range ", __FILE__, __LINE__);
        } else if (tileVec[index] == NULL) {
                throw Util::GeneralException("Tile index " + Util::toString(index)
                 + " has no actual corresponding tile ", __FILE__, __LINE__);
        }
}

Parse::Parser* TileSetReader::makeParserToParseMe(std::istream& in) {
        Parse::SimpleParser *parser = new Parse::SimpleParser(in);

        parser->addAction("BombableTile",
                new Parse::NaturalVectorParser<AbstractTile, ExplodableTile>(tileVec));
        parser->addAction("Conveyor",
                new Parse::NaturalVectorParser<AbstractTile, ConveyorTile>(tileVec));
        parser->addAction("PassableTile",
                new Parse::NaturalVectorParser<AbstractTile, PassableTile>(tileVec));
        parser->addAction("SlipperyTile",
                new Parse::NaturalVectorParser<AbstractTile, SlipperyTile>(tileVec));
        parser->addAction("UnbombableTile",
                new Parse::NaturalVectorParser<AbstractTile, IndestructibleTile>(tileVec));     

        return parser;
}

---