Hosting courtesy of Sourceforge

               

---

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

using namespace Game;

int Game::getRightSlack(const SDL_Rect& picPosition)  {
        return  (Constants::TILE_WIDTH - getLeftSlack(picPosition)) % Constants::TILE_WIDTH ;
}

int Game::getLeftSlack(const SDL_Rect& picPosition) {
        return picPosition.x % Constants::TILE_WIDTH;
}

int Game::getUpSlack(const SDL_Rect& picPosition) {
        return picPosition.y % Constants::TILE_HEIGHT;
}

int Game::getDownSlack(const SDL_Rect& picPosition) {
        return (Constants::TILE_HEIGHT - getUpSlack(picPosition) ) % Constants::TILE_HEIGHT;
}

int Game::getDownSlack(Sint16 y) {
        return (Constants::TILE_HEIGHT - getUpSlack(y)) % Constants::TILE_HEIGHT;
}

int Game::getUpSlack(Sint16 y) {
        return y % Constants::TILE_HEIGHT;
}

int Game::getLeftSlack(Sint16 x) {
        return x % Constants::TILE_WIDTH;
}

int Game::getRightSlack(Sint16 x) {
        return (Constants::TILE_WIDTH - getLeftSlack(x)) % Constants::TILE_WIDTH;
}

int Game::getRightTile(Sint16 x, int offset) {
        return ((x + Constants::TILE_WIDTH - 1 + offset)/ Constants::TILE_WIDTH);
}

int Game::getLeftTile(Sint16 x, int offset) {
        return (x + offset) / Constants::TILE_WIDTH;
}

int Game::getUpTile(Sint16 y, int offset) {
        return (y + offset) / Constants::TILE_HEIGHT;
}

int Game::getDownTile(Sint16 y, int offset) {
        return (y + Constants::TILE_HEIGHT - 1 + offset) / Constants::TILE_HEIGHT;
}

Parse::Parser* MapLocation::makeParserToParseMe(std::istream &input) {
        Parse::Parser* parser= new Parse::SimpleParser(input);
        
        parser->addAction("x", new Parse::StdRead<int>(x));
        parser->addAction("y", new Parse::StdRead<int>(y));
        
        return parser;
}

int Game::getNearestHorizTile(Sint16 xPixel) {
        int xLoc = xPixel / Constants::TILE_WIDTH;
        if (getLeftSlack(xPixel) > getRightSlack(xPixel)) xLoc++;
        return xLoc;
}

int Game::getNearestVertTile(Sint16 yPixel) {
        int yLoc = yPixel / Constants::TILE_HEIGHT;
        if (getUpSlack(yPixel) > getDownSlack(yPixel)) yLoc++;
        return yLoc;
}

MapLocation Game::getLocation(const SDL_Rect& rect) {
        return MapLocation(getNearestHorizTile(rect.x), getNearestVertTile(rect.y));
}

MapLocation::MapLocation(const MapLocation &other) :
x(other.x),
y(other.y)
{ }

MapLocation::MapLocation() :
x(-1),
y(-1)
{ }

MapLocation::MapLocation(int x_, int y_) :
x(x_),
y(y_)
{ }

bool MapLocation::operator < (const MapLocation& other) const {
        if (x < other.x) return true;
        if (y < other.y) return true;
        
        return false;
}

bool MapLocation::operator ==(const MapLocation& other) const {
        return (x == other.x && y == other.y);
}

int MapLocation::getMapX() const {
        return x;
}

int MapLocation::getMapY() const {
        return y;
}

MapLocAt::MapLocAt(int xx, int yy) :
x(xx),
y(yy)
{ }

bool MapLocAt::operator()(MapLocation* m) {
        return x == m->getMapX() && y == m->getMapY();
}

---