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

Go to the documentation of this file.
00001 #include "MainGameState.h"
00002 #include "ConfigOptions.h"
00003 #include "Unit.h"
00004 #include "Display.h"
00005 #include "Input.h"
00006 #include "Chat.h"
00007 
00008 MainGameState::MainGameState(Application* app) :
00009   GameState(app),
00010   _map()
00011 {
00012 
00013 }
00014 
00015 
00016 MainGameState::~MainGameState()
00017 {
00018 
00019 }
00020 
00021 
00022 void MainGameState::deinit()
00023 {
00024 
00025 }
00026 
00027 void MainGameState::init()
00028 {
00029    _map = spMap(new Map());
00030    //loadMap(ConfigOptions::instance().get<string>(MAP));
00031    loadMap("maps/test.xcm");
00032    _camera.setBorders( 
00033        _map->getTile(_map->getHeight() - 1, 0)->getScreenX(),
00034        _map->getTile(0, _map->getWidth() - 1)->getScreenX() + MapTile::getWidth(),
00035        _map->getTile(0, 0)->getScreenY(),
00036        _map->getTile(_map->getHeight() - 1, _map->getWidth() - 1)->getScreenY() + MapTile::getHeight() );
00037    _players.push_back(Player(1));
00038    spUnit u = createUnit(1, 0, 0);
00039    u->markActive();
00040    u->markSelected();
00041    u->updatePossibleMoves();
00042    focusOnUnit(u);
00043 }
00044 
00045 void MainGameState::update(unsigned int deltaTime)
00046 {
00047    _camera.update(deltaTime);
00048    Point offset = _camera.getPosition();
00049 
00050    _map->drawTerrainLayer(offset);
00051 
00052    map<spMapTile, int> moveTiles = Unit::getSelectedUnit()->getPossibleMoves();
00053    map<spMapTile, int>::iterator iter2;
00054    for (iter2 = moveTiles.begin(); iter2 != moveTiles.end(); ++iter2)
00055    {
00056       (*iter2).first->highlightMoveable(offset);
00057       ostringstream stream;
00058       stream << (*iter2).second;
00059       Display::instance().draw((*iter2).first->getCenterX()-offset.x, (*iter2).first->getCenterY()-offset.y, stream.str());
00060    }
00061 
00062    _map->highlightMouseOverTile(offset);
00063    _map->drawObjectLayer(offset);
00064    spUnit u = getActiveUnit();
00065    u->drawMovePath(offset);
00066 
00067    list<spUnit>::iterator iter;
00068    //for_each(_unitQueue.begin(), _unitQueue.end(), &Unit::draw);
00069    //Point dim(0, 0);
00070    
00071    /*for (iter = _unitQueue.begin(); iter != _unitQueue.end(); ++iter)
00072    {
00073       (*iter)->draw(offset, dim, (*iter) == u);
00074    }*/
00075   
00076    //ostringstream stream;
00077    //stream << "Mouse Position: " << p.x << ", " << p.y;
00078 
00079    //Display::instance().draw(5, 5, stream.str());
00080    _map->drawMinimap();
00081    Chat::instance().draw();
00082 }
00083 
00084 bool MainGameState::loadMap(string fileName)
00085 {
00086    ifstream file(fileName.c_str());
00087    return _map->load(file);
00088 }
00089 
00090 spUnit MainGameState::createUnit(int playerID, int x, int y)
00091 {
00092    spUnit u = Unit::makeUnit(playerID, _map->getTile(x, y));
00093    vector<Player>::iterator iter;
00094 
00095    for (iter = _players.begin(); iter != _players.end(); ++iter)
00096    {
00097       if ((*iter).getID() == playerID)  
00098       {
00099          (*iter).addUnit(u);
00100          break;
00101       }
00102    }
00103 
00104    _unitQueue.push_back(u);
00105    if (getActiveUnit().get())
00106    {
00107       getActiveUnit()->updatePossibleMoves();
00108    }
00109    return u;
00110 }
00111 
00112 spUnit MainGameState::getActiveUnit()
00113 {
00114     // returns the unit to act next
00115    return (!_unitQueue.empty()) ? _unitQueue.front() : spUnit();
00116 }
00117 
00118 void MainGameState::processSDLEvent(SDL_Event& event) 
00119 {
00120    if ( event.type == SDL_KEYDOWN )
00121    {
00122       switch ( event.key.keysym.sym )
00123       {
00124          case SDLK_n:
00125             if (_map->getTile(0, 0)->isPassable())
00126             {
00127                spUnit u = createUnit(1,0,0);
00128             }
00129             break;
00130          case SDLK_SPACE:
00131             endActiveUnitTurn();
00132             break;
00133          default:
00134             break;
00135       }
00136       spUnit u = getActiveUnit();
00137       if (u == Unit::getSelectedUnit())
00138       {
00139          switch ( event.key.keysym.sym )
00140          {
00141             case SDLK_KP1:
00142               u->move(Direction::SW);
00143                break;
00144             case SDLK_KP2:
00145                u->move(Direction::S);
00146                break;
00147             case SDLK_KP3:
00148                u->move(Direction::SE);
00149                break;
00150             case SDLK_KP4:
00151                u->move(Direction::W);
00152                break;
00153             case SDLK_KP6:
00154                u->move(Direction::E);
00155                break;
00156             case SDLK_KP7:
00157                u->move(Direction::NW);
00158                break;
00159             case SDLK_KP8:
00160                u->move(Direction::N);
00161                break;
00162             case SDLK_KP9:
00163                u->move(Direction::NE);
00164                break;
00165             case SDLK_m:
00166                if (u->hasMovePath())
00167                {
00168                   u->moveAlongPath();
00169                }
00170                break;
00171             default:
00172                break;
00173          }
00174       }
00175    }
00176    else if ( event.type == SDL_MOUSEMOTION )
00177    {
00178       _map->updateMouseOverTile(_camera.getPosition());
00179    }
00180    else if ( event.type == SDL_MOUSEBUTTONDOWN )
00181    {
00182       spUnit u = getActiveUnit();
00183       spMapTile t = _map->getMouseOverTile();
00184       if (t.get() && t->hasUnit())
00185       {
00186          selectUnit(t->getUnit());
00187       }
00188       else if (u->hasMovePath() && t == u->getDestination())
00189       {
00190          u->moveAlongPath(true);
00191       }
00192       else
00193       {
00194          if (u == Unit::getSelectedUnit())
00195          {
00196             u->computeMovePath(_map->getMouseOverTile());
00197          }
00198       }
00199    }
00200 }
00201 
00202 void MainGameState::endActiveUnitTurn()
00203 {
00204    spUnit u = getActiveUnit();
00205    u->clearMovePath();
00206    if (u->hasMaxActionPoints())
00207    {
00208       u->wait();
00209    }
00210    _unitQueue.pop_front();
00211    _unitQueue.push_back(u);
00212    
00213    _unitQueue.sort(boost::mem_fn(&Unit::hasTurnBefore));
00214    while(!_unitQueue.front()->hasMaxActionPoints())
00215    {
00216       for_each(_unitQueue.begin(), _unitQueue.end(), boost::mem_fn(&Unit::regenActionPoints));
00217    }
00218 
00219    getActiveUnit()->markActive();
00220    getActiveUnit()->markSelected();
00221    focusOnUnit(getActiveUnit());
00222 }
00223 
00224 void MainGameState::selectUnit( spUnit u )
00225 {
00226    u->markSelected();
00227    u->updatePossibleMoves();
00228    
00229    spUnit active = getActiveUnit();
00230 
00231    active->clearMovePath();
00232          
00233    if (active->hasMaxActionPoints() && u->hasMaxActionPoints())
00234    {
00235       // current unit hasn't moved yet, so allow switching
00236       _unitQueue.remove(u);
00237       _unitQueue.push_front(u);
00238       u->markActive();
00239    }
00240 }
00241 
00242 void MainGameState::focusOnUnit( spUnit u )
00243 {
00244    spMapTile tile = _map->getTile(u->getX(), u->getY());
00245    _camera.setPosition(-Display::instance().getScreenWidth()/2 + tile->getCenterX(), 
00246                        -Display::instance().getScreenHeight()/2 + tile->getCenterY());
00247    u->updatePossibleMoves();
00248    Point offset = _camera.getPosition();
00249    _map->updateMouseOverTile(offset);
00250 }
00251 

Generated on Fri Sep 22 06:00:26 2006 for X-CLONE by  doxygen 1.4.7