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

Go to the documentation of this file.

#include "MainGameState.h"
#include "ConfigOptions.h"
#include "Unit.h"
#include "Display.h"
#include "Input.h"
#include "Chat.h"

MainGameState::MainGameState(Application* app) :
  GameState(app),
  _map()
{

}


MainGameState::~MainGameState()
{

}


void MainGameState::deinit()
{

}

void MainGameState::init()
{
   _map = spMap(new Map());
   //loadMap(ConfigOptions::instance().get<string>(MAP));
   loadMap("maps/test.xcm");
   _camera.setBorders( 
       _map->getTile(_map->getHeight() - 1, 0)->getScreenX(),
       _map->getTile(0, _map->getWidth() - 1)->getScreenX() + MapTile::getWidth(),
       _map->getTile(0, 0)->getScreenY(),
       _map->getTile(_map->getHeight() - 1, _map->getWidth() - 1)->getScreenY() + MapTile::getHeight() );
   _players.push_back(Player(1));
   spUnit u = createUnit(1, 0, 0);
   u->markActive();
   u->markSelected();
   u->updatePossibleMoves();
   focusOnUnit(u);
}

void MainGameState::update(unsigned int deltaTime)
{
   _camera.update(deltaTime);
   Point offset = _camera.getPosition();

   _map->drawTerrainLayer(offset);

   map<spMapTile, int> moveTiles = Unit::getSelectedUnit()->getPossibleMoves();
   map<spMapTile, int>::iterator iter2;
   for (iter2 = moveTiles.begin(); iter2 != moveTiles.end(); ++iter2)
   {
      (*iter2).first->highlightMoveable(offset);
      ostringstream stream;
      stream << (*iter2).second;
      Display::instance().draw((*iter2).first->getCenterX()-offset.x, (*iter2).first->getCenterY()-offset.y, stream.str());
   }

   _map->highlightMouseOverTile(offset);
   _map->drawObjectLayer(offset);
   spUnit u = getActiveUnit();
   u->drawMovePath(offset);

   list<spUnit>::iterator iter;
   //for_each(_unitQueue.begin(), _unitQueue.end(), &Unit::draw);
   //Point dim(0, 0);
   
   /*for (iter = _unitQueue.begin(); iter != _unitQueue.end(); ++iter)
   {
      (*iter)->draw(offset, dim, (*iter) == u);
   }*/
  
   //ostringstream stream;
   //stream << "Mouse Position: " << p.x << ", " << p.y;

   //Display::instance().draw(5, 5, stream.str());
   _map->drawMinimap();
   Chat::instance().draw();
}

bool MainGameState::loadMap(string fileName)
{
   ifstream file(fileName.c_str());
   return _map->load(file);
}

spUnit MainGameState::createUnit(int playerID, int x, int y)
{
   spUnit u = Unit::makeUnit(playerID, _map->getTile(x, y));
   vector<Player>::iterator iter;

   for (iter = _players.begin(); iter != _players.end(); ++iter)
   {
      if ((*iter).getID() == playerID)  
      {
         (*iter).addUnit(u);
         break;
      }
   }

   _unitQueue.push_back(u);
   if (getActiveUnit().get())
   {
      getActiveUnit()->updatePossibleMoves();
   }
   return u;
}

spUnit MainGameState::getActiveUnit()
{
    // returns the unit to act next
   return (!_unitQueue.empty()) ? _unitQueue.front() : spUnit();
}

void MainGameState::processSDLEvent(SDL_Event& event) 
{
   if ( event.type == SDL_KEYDOWN )
   {
      switch ( event.key.keysym.sym )
      {
         case SDLK_n:
            if (_map->getTile(0, 0)->isPassable())
            {
               spUnit u = createUnit(1,0,0);
            }
            break;
         case SDLK_SPACE:
            endActiveUnitTurn();
            break;
         default:
            break;
      }
      spUnit u = getActiveUnit();
      if (u == Unit::getSelectedUnit())
      {
         switch ( event.key.keysym.sym )
         {
            case SDLK_KP1:
              u->move(Direction::SW);
               break;
            case SDLK_KP2:
               u->move(Direction::S);
               break;
            case SDLK_KP3:
               u->move(Direction::SE);
               break;
            case SDLK_KP4:
               u->move(Direction::W);
               break;
            case SDLK_KP6:
               u->move(Direction::E);
               break;
            case SDLK_KP7:
               u->move(Direction::NW);
               break;
            case SDLK_KP8:
               u->move(Direction::N);
               break;
            case SDLK_KP9:
               u->move(Direction::NE);
               break;
            case SDLK_m:
               if (u->hasMovePath())
               {
                  u->moveAlongPath();
               }
               break;
            default:
               break;
         }
      }
   }
   else if ( event.type == SDL_MOUSEMOTION )
   {
      _map->updateMouseOverTile(_camera.getPosition());
   }
   else if ( event.type == SDL_MOUSEBUTTONDOWN )
   {
      spUnit u = getActiveUnit();
      spMapTile t = _map->getMouseOverTile();
      if (t.get() && t->hasUnit())
      {
         selectUnit(t->getUnit());
      }
      else if (u->hasMovePath() && t == u->getDestination())
      {
         u->moveAlongPath(true);
      }
      else
      {
         if (u == Unit::getSelectedUnit())
         {
            u->computeMovePath(_map->getMouseOverTile());
         }
      }
   }
}

void MainGameState::endActiveUnitTurn()
{
   spUnit u = getActiveUnit();
   u->clearMovePath();
   if (u->hasMaxActionPoints())
   {
      u->wait();
   }
   _unitQueue.pop_front();
   _unitQueue.push_back(u);
   
   _unitQueue.sort(boost::mem_fn(&Unit::hasTurnBefore));
   while(!_unitQueue.front()->hasMaxActionPoints())
   {
      for_each(_unitQueue.begin(), _unitQueue.end(), boost::mem_fn(&Unit::regenActionPoints));
   }

   getActiveUnit()->markActive();
   getActiveUnit()->markSelected();
   focusOnUnit(getActiveUnit());
}

void MainGameState::selectUnit( spUnit u )
{
   u->markSelected();
   u->updatePossibleMoves();
   
   spUnit active = getActiveUnit();

   active->clearMovePath();
         
   if (active->hasMaxActionPoints() && u->hasMaxActionPoints())
   {
      // current unit hasn't moved yet, so allow switching
      _unitQueue.remove(u);
      _unitQueue.push_front(u);
      u->markActive();
   }
}

void MainGameState::focusOnUnit( spUnit u )
{
   spMapTile tile = _map->getTile(u->getX(), u->getY());
   _camera.setPosition(-Display::instance().getScreenWidth()/2 + tile->getCenterX(), 
                       -Display::instance().getScreenHeight()/2 + tile->getCenterY());
   u->updatePossibleMoves();
   Point offset = _camera.getPosition();
   _map->updateMouseOverTile(offset);
}

---