Hosting courtesy of Sourceforge

               

---

Player.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 "Player.h"

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

using namespace Game;

Direction Game::getDirectionFromMovement(PlayerAction pa) {
        switch (pa) {
        case Constants::MOVE_RIGHT: return RIGHT;
        case Constants::MOVE_LEFT: return LEFT;
        case Constants::MOVE_DOWN: return DOWN;
        case Constants::MOVE_UP: return UP;
        default: return NO_DIRECTION;
        }
}

PlayerAction Game::getMovementFromDirection(Direction d) {
        switch (d) {
        case RIGHT: return Constants::MOVE_RIGHT;
        case LEFT: return Constants::MOVE_LEFT;
        case DOWN: return Constants::MOVE_DOWN;
        case UP: return Constants::MOVE_UP;
        }
        return Constants::NO_ACTION;
}

AbstractPlayer::AbstractPlayer(Sint16 startX, Sint16 startY) :
MoveableItem(startX, startY, Constants::PLAYER_STARTING_MOVE_SPEED),
movingImages(4, (Graphics::AbstractImage*) 0),
idleImages(4, (Graphics::AbstractImage*) 0),
bombRadius(Constants::DEFAULT_START_BOMB_RADIUS),
bombsLeft(Constants::DEFAULT_START_NUM_BOMBS),
framesTilNextBomb(0)
{

}

void AbstractPlayer::draw(SDL_Surface* screen) {
        (*activeImage)->drawAt(screen, &picPosition);
}

void AbstractPlayer::setDirection(Direction newState) {
        if (newState == NO_DIRECTION && dir == NO_DIRECTION) return;
        if (newState == NO_DIRECTION)   activeImage=&idleImages[dir];
        else                                            activeImage=&movingImages[newState];
        dir = newState;
}

void AbstractPlayer::increaseBombsLeft() {
        bombsLeft++;
}

void AbstractPlayer::decreaseBombsLeft() {
        bombsLeft--;
}

int AbstractPlayer::getBombRadius() {
        return bombRadius;
}

void AbstractPlayer::setBombRadius(int newRad) {
        bombRadius=newRad;
}

Parse::Parser* AbstractPlayer::makeParserToParseMe(std::istream& input) {
        Parse::Parser* parser = new Parse::SimpleParser(input);
        
        parser->addAction("movingdown"  , new Graphics::ReadImage(movingImages[DOWN]));
        parser->addAction("movingright" , new Graphics::ReadImage(movingImages[RIGHT]));
        parser->addAction("movingup"    , new Graphics::ReadImage(movingImages[UP]));
        parser->addAction("movingleft"  , new Graphics::ReadImage(movingImages[LEFT]));
        
        parser->addAction("facingdown"  , new Graphics::ReadImage(idleImages[DOWN]));
        parser->addAction("facingright" , new Graphics::ReadImage(idleImages[RIGHT]));
        parser->addAction("facingleft"  , new Graphics::ReadImage(idleImages[LEFT]));
        parser->addAction("facingup"    , new Graphics::ReadImage(idleImages[UP]));
        
        parser->addAction("AfterParseValidator", new PlayerAfterParseValidator(*this));
        
        return parser;
}

AbstractPlayer::~AbstractPlayer() {
        Util::freeDynamicContainer(movingImages);
        Util::freeDynamicContainer(idleImages);
}


AbstractPlayer::PlayerAfterParseValidator::PlayerAfterParseValidator(AbstractPlayer& p) :
playerRef(p)
{ }

void AbstractPlayer::PlayerAfterParseValidator::finishingAction() {
        for (size_t i = 0; i < 4 /* all cardinal directions */; i++) {
                if (playerRef.movingImages[i] == NULL) throw Util::GeneralException("Player image not defined", __FILE__, __LINE__);
                if (playerRef.idleImages[i] == NULL) {
                        playerRef.idleImages[i] = playerRef.movingImages[i]->dynCopyImage();
                }
                playerRef.idleImages[i]->setTransparency(SDL_SRCCOLORKEY);
                playerRef.movingImages[i]->setTransparency(SDL_SRCCOLORKEY);
        }
        // make player face down but not move
        playerRef.setDirection(Game::DOWN);
        playerRef.setDirection(Game::NO_DIRECTION);
}

void AbstractPlayer::PlayerAfterParseValidator::getValue(std::istream& input) {
        // nothing... this shouldn't get called
}

Parse::Parser* LocalPlayer::makeParserToParseMe(std::istream& input) {
        Parse::Parser* parser= AbstractPlayer::makeParserToParseMe(input);
        
        parser->addAction("keyboard", new Parse::NaturalParser<PlayerController, KeyboardController>(controller));
        parser->addAction("joystick", new Parse::NaturalParser<PlayerController, JoystickController>(controller));

        return parser;
}

LocalPlayer::LocalPlayer(Sint16 startX, Sint16 startY) :
AbstractPlayer(startX, startY),
controller(NULL)
{
        
}

LocalPlayer::~LocalPlayer() {
        delete controller;
}

PlayerAction LocalPlayer::getInput() {
#ifdef DEBUG_GAME_PLAYER
        debugOut << "LocalPlayer::getInput()" << endl;
#endif
        framesTilNextBomb--;
        PlayerAction actions=Constants::NO_ACTION;

        if (controller->actionIsEnabled(Constants::DROP_BOMB) && bombsLeft && framesTilNextBomb <= 0) {
                framesTilNextBomb= Constants::BOMB_DROP_REFRESH_INTERVAL;
                actions |= Constants::DROP_BOMB;
        }
        if (!dirIsLocked) {
                if (controller->actionIsEnabled(Constants::MOVE_RIGHT))         actions |= Constants::MOVE_RIGHT;
                if (controller->actionIsEnabled(Constants::MOVE_DOWN))          actions |= Constants::MOVE_DOWN;
                if (controller->actionIsEnabled(Constants::MOVE_LEFT))          actions |= Constants::MOVE_LEFT;
                if (controller->actionIsEnabled(Constants::MOVE_UP))            actions |= Constants::MOVE_UP;
        } else {  // direction is locked, keep moving in the current direction
                actions |= getMovementFromDirection(getDirection());
        }
        return actions;
}

---