D:/Development/Projects/X-Clone/X-Clone/trunk/Unit.cpp

Go to the documentation of this file.

#include "Unit.h"
#include "Display.h"

#define UNIT_IMAGE "images/unit.png"
#define UNIT_PATH_IMAGE "images/unit_path.png"
#define UNIT_PATH_END_IMAGE "images/unit_path_end.png"
#define UNIT_ACTIVE_IMAGE "images/unit_active.png"
#define UNIT_SELECTED_IMAGE "images/unit_selected.png"

SDL_Surface* Unit::_image = NULL;
SDL_Surface* Unit::_pathImage = NULL;
SDL_Surface* Unit::_pathEndImage = NULL;
SDL_Surface* Unit::_selectedImage = NULL;
SDL_Surface* Unit::_activeImage = NULL;

int Unit::_maxActionPoints = 50;
spUnit Unit::_activeUnit;
spUnit Unit::_selectedUnit;

//Unit::Unit(int playerID)
//{
//   Unit(playerID);
//}

spUnit Unit::makeUnit(int playerID)
{
   return makeUnit(playerID, spMapTile());
}

spUnit Unit::makeUnit(int playerID, spMapTile tile)
{
   if (tile->isPassable())
   {
      spUnit unit = spUnit(new Unit(playerID, tile));
      unit->_weak = unit;
      unit->_tile->addUnit(unit);
      return unit;
   }
   return spUnit();
}

Unit::Unit(int playerID, spMapTile tile) :
   _playerID(playerID),
   _actionPoints(_maxActionPoints),
   _regenRate(10)
{
   static bool mapped = false;
   if (!mapped) 
   {
      _image = Display::instance().loadImage(UNIT_IMAGE);
      _pathImage = Display::instance().loadImage(UNIT_PATH_IMAGE);
      _pathEndImage = Display::instance().loadImage(UNIT_PATH_END_IMAGE);
      _selectedImage = Display::instance().loadImage(UNIT_SELECTED_IMAGE);
      _activeImage = Display::instance().loadImage(UNIT_ACTIVE_IMAGE);

      mapped = true;
   }
   _tile = tile;
}

Unit::~Unit()
{
}

int Unit::getPlayerID() const
{
   return _playerID;
}

int Unit::getX() const
{
   return _tile->getX();
}

int Unit::getY() const
{
   return _tile->getY();
}

void Unit::draw(Point position, Point dimensions) const
{
   Display& d = Display::instance();
   if (this == _selectedUnit.get())
   {
      d.draw(position.x + dimensions.x/2 -_selectedImage->w/2,
             position.y + dimensions.y/2 - _selectedImage->h/2, 
             _selectedImage);

      ostringstream stream;
      stream << "Action Points: " << _actionPoints;
      d.draw(d.getScreenWidth() - 150, 5, stream.str());

   }
   if (this == _activeUnit.get())
   {
      d.draw(position.x + dimensions.x/2 -_activeImage->w/2,
             position.y + dimensions.y/2 - _activeImage->h/2, 
             _activeImage);
   }

   d.draw(position.x + dimensions.x/2 - _image->w/2,
          position.y + dimensions.y/2 - _image->h + 5, 
          _image);
}

bool Unit::isPassable() const
{
   return false;
}

void Unit::wait()
{
   _actionPoints = max(_actionPoints - 50, 0);
}

void Unit::move(Direction dir)
{
   if (canMoveInDirection(dir))
   {
      move(_tile->getTileInDirection(dir));
   }
}

void Unit::move(spMapTile tile)
{
   if (tile->isPassable())
   {
      _tile->removeUnit();
      _tile = tile;
      _tile->addUnit(spUnit(_weak));
      updatePossibleMoves();
   }  
}

bool Unit::canMoveInDirection( Direction dir )
{
   return canMoveInDirection(_tile, dir, _actionPoints);
}

bool Unit::canMoveInDirection( spMapTile tile, Direction dir, int points )
{
   static map<Direction, Direction*> clockwise;
   static map<Direction, Direction*> counterClockwise;

   if (clockwise.empty())
   {
      clockwise[Direction::N]  = &Direction::NE;
      clockwise[Direction::NE] = &Direction::E;
      clockwise[Direction::E]  = &Direction::SE;
      clockwise[Direction::SE] = &Direction::S;
      clockwise[Direction::S]  = &Direction::SW;
      clockwise[Direction::SW] = &Direction::W;
      clockwise[Direction::W]  = &Direction::NW;
      clockwise[Direction::NW] = &Direction::N;
   }

   if (counterClockwise.empty())
   {
      counterClockwise[Direction::N]  = &Direction::NW;
      counterClockwise[Direction::NE] = &Direction::N;
      counterClockwise[Direction::E]  = &Direction::NE;
      counterClockwise[Direction::SE] = &Direction::E;
      counterClockwise[Direction::S]  = &Direction::SE;
      counterClockwise[Direction::SW] = &Direction::S;
      counterClockwise[Direction::W]  = &Direction::SW;
      counterClockwise[Direction::NW] = &Direction::W;
   }

   int x = getX() + dir.offset().x;
   int y = getY() + dir.offset().y;

   spMapTile t = tile->getTileInDirection(dir);

   // true if it's the current tile
   // the actual map tile will say it's impassable
   // used for pathfinding
   if (_tile == t)
   {
      return true;
   }

   if ( !t.get() )
       return false;

   if ( tile->getY() == t->getY() ) // same row
   {
       if ( tile->getX() < t->getX() )
        {
            if ( !tile->isPassable(Direction::SW) )
                return false;
        }
       else if ( !tile->isPassable(Direction::NE) )
           return false;
   }
   if ( tile->getX() == t->getX() ) // same col
   {
       if ( tile->getY() < t->getY() )
        {
            if ( !tile->isPassable(Direction::SE) )
                return false;
        }
       else if ( !tile->isPassable(Direction::NW) )
           return false;
   }
   if ( tile->getX() < t->getX() && tile->getY() < t->getY() ) // north
   {
       if ( !tile->isPassable(Direction::NE) || !tile->isPassable(Direction::NW) || !t->isPassable(Direction::SE) || !t->isPassable(Direction::SW) )
           return false;
   }
   if ( tile->getX() > t->getX() && tile->getY() > t->getY() ) // south
   {
       if ( !tile->isPassable(Direction::SE) || !tile->isPassable(Direction::SW) || !t->isPassable(Direction::NE) || !t->isPassable(Direction::NW) )
           return false;
   }
   if ( tile->getX() > t->getX() && tile->getY() < t->getY() ) // west
   {
       if ( !tile->isPassable(Direction::NW) || !tile->isPassable(Direction::SW) || !t->isPassable(Direction::NE) || !t->isPassable(Direction::SE) )
           return false;
   }
   if ( tile->getX() < t->getX() && tile->getY() > t->getY() ) // east
   {
       if ( !tile->isPassable(Direction::NE) || !tile->isPassable(Direction::SE) || !t->isPassable(Direction::NW) || !t->isPassable(Direction::SW) )
           return false;
   }

   bool ok = false;
   if (t.get() && t->isPassable() && points >= tile->getMoveCost(dir))
   {
      if (dir.isCardinal()) 
      {
         // this assumes that maps are square - so there will always be adjacent tiles
         if (tile->getTileInDirection(*(clockwise[dir]))->isPassable() && 
             tile->getTileInDirection(*(counterClockwise[dir]))->isPassable())
         {
            ok = true;
         }
      }
      else
      {
         ok = true;
      }
   }
   return ok;
}

map<spMapTile, int> Unit::getPossibleMoves()
{
   return _possibleMoves;
}

void Unit::updatePossibleMoves()
{
   //map<spMapTile, int> final;
   //_possibleMoves.clear();
   map<spMapTile, int> temp;
   queue<spMapTile> waiting;

   waiting.push(_tile);
   temp[_tile] = 0;

   while (!waiting.empty())
   {
      spMapTile tile = waiting.front();
      int cost = temp[tile];
      int remaining = _actionPoints - cost;
      
      //_possibleMoves[tile] = cost;
      waiting.pop();

      vector<const Direction*> dirs = Direction::getAllDirections();
      vector<const Direction*>::const_iterator iter;
      for(iter = dirs.begin(); iter != dirs.end(); ++iter)
      {
         if (canMoveInDirection(tile, **iter, remaining))
         {
            spMapTile nextTile = tile->getTileInDirection(**iter);
            int nextCost = tile->getMoveCost(**iter) + cost;
            if (temp.count(nextTile) == 0)
            {
               waiting.push(nextTile);
               temp[nextTile] = nextCost;
            }
            else if (temp[nextTile] > nextCost)
            {
               temp[nextTile] = nextCost;
            }
            
            //tiles.push_back(_tile->getTileInDirection(**iter));
         }
      }
   }

   _possibleMoves = temp;
}

void Unit::computeMovePath(spMapTile dest)
{
   _movementPath.clear();
   map<spMapTile, int>::iterator iter = _possibleMoves.find(dest);
   if (iter != _possibleMoves.end())
   {
      _movementPath.push_front(*iter);
      pair<spMapTile, int> next = *iter;
      while (true)
      {
         next = computeMovePathHelper(next.first);
         if (next.first == _tile)
         {
            break;
         }
         else
         {
            _movementPath.push_front(next);
         }
      }
   }
}

pair<spMapTile, int> Unit::computeMovePathHelper(spMapTile current)
{
   pair<spMapTile, int> lowest(spMapTile(), numeric_limits<int>::max());
   vector<const Direction*> dirs = Direction::getAllDirections();
   vector<const Direction*>::const_iterator iter;
   for(iter = dirs.begin(); iter != dirs.end(); ++iter)
   {
      if (canMoveInDirection(current, **iter, numeric_limits<int>::max()))
      {
         spMapTile adjacent = current->getTileInDirection(**iter);
         if (adjacent.get())
         {
            map<spMapTile, int>::iterator iter = _possibleMoves.find(adjacent);
            if (iter != _possibleMoves.end() && (*iter).second < lowest.second)
            {
               lowest = *iter;
            }
         }
      }
   }
   return lowest;
}

bool Unit::hasMovePath() const
{
   return !_movementPath.empty();
}

void Unit::moveAlongPath( bool teleport )
{
   if (!hasMovePath())
   {
      return;
   }
   
   if (teleport)
   {
      _actionPoints -= _movementPath.back().second;
      move(_movementPath.back().first);
      clearMovePath();
   }
   else
   {
      _actionPoints = _maxActionPoints - _movementPath.front().second;
      move(_movementPath.front().first);
      _movementPath.pop_front();
   }
}

void Unit::drawMovePath(Point offset) const
{
   list<pair<spMapTile, int> >::const_iterator iter;
   for (iter = _movementPath.begin(); iter != _movementPath.end(); ++iter)
   {
      SDL_Surface* img = NULL;
      if (*iter == _movementPath.back())
      {
         img = _pathEndImage;
      }
      else 
      {
         img = _pathImage;
      }

      Display::instance().draw((*iter).first->getCenterX() - img->w/2 - offset.x, 
                               (*iter).first->getCenterY() - img->h/2 - offset.y, 
                               img);
   }
}

void Unit::clearMovePath()
{
   _movementPath.clear();
}

const spMapTile Unit::getDestination() const
{
   if (hasMovePath())
   {
      return _movementPath.back().first;
   }
   else
   {
      return spMapTile();
   }
}

bool Unit::hasMaxActionPoints() const
{
   return _actionPoints == _maxActionPoints;
}

void Unit::regenActionPoints()
{
   _actionPoints = min(_actionPoints + _regenRate, _maxActionPoints);
}


// provides a strict weak ordering comparison, i.e. "less than"
// created for STL comparisons, but potentially useful elsewhere
// if they are equal, this will return false but really it's undefined
// since the order in the queue would actually take priority
bool Unit::hasTurnBefore(spUnit u) const
{
   // "_regenRate - 1" is there because this is integer math and it's flooring everything
   int thisSteps = (_maxActionPoints - _actionPoints + _regenRate - 1) / _regenRate; 
   int thatSteps = (_maxActionPoints - u->_actionPoints + u->_regenRate - 1) / u->_regenRate;

   return thisSteps < thatSteps;
}

void Unit::markActive()
{
   _activeUnit = spUnit(_weak);
}

void Unit::clearActive()
{
   _activeUnit = spUnit();
}

void Unit::markSelected()
{
   _selectedUnit = spUnit(_weak);
}

void Unit::clearSelected()
{
   _selectedUnit = spUnit();
}

spUnit Unit::getSelectedUnit()
{
   return _selectedUnit;
}

---