Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 7868 in orxonox.OLD for trunk/src/lib/util/loading


Ignore:
Timestamp:
May 26, 2006, 1:21:32 PM (19 years ago)
Author:
bensch
Message:

trunk: merge Check in the Event-changes:
r7867 | bensch | 2006-05-26 13:19:46 +0200 (Fri, 26 May 2006) | 1 line

Events better subscribed

r7866 | bensch | 2006-05-26 13:11:10 +0200 (Fri, 26 May 2006) | 1 line

Events are subscribed at the EventListener, and not the EventHandler

Location:
trunk/src/lib/util/loading
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/util/loading/game_loader.cc

    r7374 r7868  
    2626#include "util/loading/resource_manager.h"
    2727
    28 #include "event_handler.h"
    29 
    30 
    31 namespace OrxShell
    32 {
    33 
    34   SHELL_COMMAND(quit, GameLoader, stop)
    35   ->describe("quits the game")
    36   ->setAlias("orxoquit");
    37 
    38 
    39   GameLoader* GameLoader::singletonRef = NULL;
    40 
    41 
    42   /**
    43    *  simple constructor
    44    */
    45   GameLoader::GameLoader ()
    46   {
    47     this->setClassID(CL_GAME_LOADER, "GameLoader");
    48     this->setName("GameLoader");
    49     this->bRun = true;
    50   }
    51 
    52 
    53   /**
    54    *  simple deconstructor
    55    */
    56   GameLoader::~GameLoader ()
    57   {
    58     if( this->currentCampaign)
    59       delete this->currentCampaign;
    60     this->currentCampaign = NULL;
    61   }
    62 
    63 
    64   /**
    65    *  initializes the GameLoader
    66    */
    67   ErrorMessage GameLoader::init()
    68   {
    69     if(this->currentCampaign != NULL)
    70       this->currentCampaign->init();
    71 
    72     this->eventHandler = EventHandler::getInstance();
    73     this->eventHandler->subscribe(this, ES_GAME, KeyMapper::PEV_PAUSE);
    74     this->eventHandler->subscribe(this, ES_ALL, EV_MAIN_QUIT);          //< External Quit Event
    75     this->eventHandler->subscribe(this, ES_GAME, KeyMapper::PEV_QUIT);
    76     this->eventHandler->subscribe(this, ES_GAME, KeyMapper::PEV_NEXT_WORLD);
    77     this->eventHandler->subscribe(this, ES_GAME, KeyMapper::PEV_PREVIOUS_WORLD);
    78   }
    79 
    80 
    81   /**
    82    *  reads a campaign definition file into a campaign class
    83    * @param fileName to be loaded
    84    * @returns the loaded campaign
    85    *
    86    * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
    87    */
    88   ErrorMessage GameLoader::loadCampaign(const std::string& fileName)
    89   {
    90     ErrorMessage errorCode;
    91     std::string campaignName = ResourceManager::getFullName(fileName);
    92     if (!campaignName.empty())
     28#include "key_mapper.h"
     29
     30
     31
     32SHELL_COMMAND(quit, GameLoader, stop)
     33->describe("quits the game")
     34->setAlias("orxoquit");
     35
     36
     37GameLoader* GameLoader::singletonRef = NULL;
     38
     39
     40/**
     41 *  simple constructor
     42 */
     43GameLoader::GameLoader ()
     44{
     45  this->setClassID(CL_GAME_LOADER, "GameLoader");
     46  this->setName("GameLoader");
     47  this->bRun = true;
     48}
     49
     50
     51/**
     52 *  simple deconstructor
     53 */
     54GameLoader::~GameLoader ()
     55{
     56  if( this->currentCampaign)
     57    delete this->currentCampaign;
     58  this->currentCampaign = NULL;
     59}
     60
     61
     62/**
     63 *  initializes the GameLoader
     64 */
     65ErrorMessage GameLoader::init()
     66{
     67  if(this->currentCampaign != NULL)
     68    this->currentCampaign->init();
     69
     70  this->subscribeEvent(ES_GAME, KeyMapper::PEV_PAUSE);
     71  this->subscribeEvent(ES_ALL, EV_MAIN_QUIT);          //< External Quit Event
     72  this->subscribeEvent(ES_GAME, KeyMapper::PEV_QUIT);
     73  this->subscribeEvent(ES_GAME, KeyMapper::PEV_NEXT_WORLD);
     74  this->subscribeEvent(ES_GAME, KeyMapper::PEV_PREVIOUS_WORLD);
     75}
     76
     77
     78/**
     79 *  reads a campaign definition file into a campaign class
     80 * @param fileName to be loaded
     81 * @returns the loaded campaign
     82 *
     83 * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
     84 */
     85ErrorMessage GameLoader::loadCampaign(const std::string& fileName)
     86{
     87  ErrorMessage errorCode;
     88  std::string campaignName = ResourceManager::getFullName(fileName);
     89  if (!campaignName.empty())
     90  {
     91    this->currentCampaign = this->fileToCampaign(campaignName);
     92  }
     93}
     94
     95
     96/**
     97 *  reads a campaign definition file into a campaign class
     98 * @param fileName to be loaded
     99 * @returns the loaded campaign
     100 *
     101 * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
     102 */
     103ErrorMessage GameLoader::loadNetworkCampaign(const std::string& fileName)
     104{
     105  ErrorMessage errorCode;
     106  std::string campaignName = ResourceManager::getFullName(fileName);
     107  if (!campaignName.empty())
     108  {
     109    this->currentCampaign = this->fileToCampaign(campaignName);
     110  }
     111}
     112
     113
     114/**
     115 *  loads a debug campaign for test purposes only.
     116 * @param campaignID the identifier of the campaign.
     117 * @returns error message if not able to do so.
     118 */
     119ErrorMessage GameLoader::loadDebugCampaign(Uint32 campaignID)
     120{
     121  switch(campaignID)
     122  {
     123      /*
     124         Debug Level 0: Debug level used to test the base frame work.
     125         As you can see, all storyentity data is allocated before game
     126         start. the storyentity will load themselfs shortly before start
     127         through the StoryEntity::init() funtion.
     128      */
     129    case DEBUG_CAMPAIGN_0:
     130      {
     131        /*        Campaign* debugCampaign = new Campaign();
     132
     133                World* world0 = new World(DEBUG_WORLD_0);
     134                world0->setNextStoryID(WORLD_ID_1);
     135                debugCampaign->addEntity(world0, WORLD_ID_0);
     136
     137                World* world1 = new World(DEBUG_WORLD_1);
     138                world1->setNextStoryID(WORLD_ID_2);
     139                debugCampaign->addEntity(world1, WORLD_ID_1);
     140
     141                World* world2 = new World(DEBUG_WORLD_2);
     142                world2->setNextStoryID(WORLD_ID_GAMEEND);
     143                debugCampaign->addEntity(world2, WORLD_ID_2);
     144
     145                this->currentCampaign = debugCampaign;
     146                break;*/
     147      }
     148  }
     149}
     150
     151
     152/**
     153 *  starts the current entity
     154 * @returns error code if this action has caused a error
     155 */
     156ErrorMessage GameLoader::start()
     157{
     158  if(this->currentCampaign != NULL)
     159  {
     160    this->currentCampaign->start();
     161  }
     162}
     163
     164
     165/**
     166 *  stops the current entity
     167 * @returns error code if this action has caused a error
     168 *
     169 *  ATTENTION: this function shouldn't call other functions, or if so, they must return
     170 *  after finishing. If you ignore or forget to do so, the current entity is not able to
     171 *  terminate and it will run in the background or the ressources can't be freed or even
     172 *  worse: are freed and the program will end in a segmentation fault!
     173 *  hehehe, have ya seen it... :)
     174 */
     175void GameLoader::stop()
     176{
     177  if(this->currentCampaign != NULL)
     178    this->currentCampaign->stop();
     179}
     180
     181
     182/**
     183 *  pause the current entity
     184 * @returns error code if this action has caused a error
     185 *
     186 * this pauses the current entity or passes this call forth to the running entity.
     187 */
     188ErrorMessage GameLoader::pause()
     189{
     190  this->isPaused = true;
     191  if(this->currentCampaign != NULL)
     192    this->currentCampaign->pause();
     193}
     194
     195
     196/**
     197 *  resumes a pause
     198 * @returns error code if this action has caused a error
     199 *
     200 *  this resumess the current entity or passes this call forth to the running entity.
     201 */
     202ErrorMessage GameLoader::resume()
     203{
     204  this->isPaused = false;
     205  if(this->currentCampaign != NULL)
     206    this->currentCampaign->resume();
     207}
     208
     209
     210/**
     211 *  reads a campaign definition file into a campaign class
     212 * @param fileName to be loaded
     213 * @returns the loaded campaign
     214 *
     215 * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
     216 */
     217Campaign* GameLoader::fileToCampaign(const std::string& fileName)
     218{
     219  /* do not entirely load the campaign. just the current world
     220     before start of each world, it has to be initialized so it
     221     can load everything it needs into memory then.
     222  */
     223
     224  if( fileName.empty())
     225  {
     226    PRINTF(2)("No filename specified for loading");
     227    return NULL;
     228  }
     229
     230  TiXmlDocument XMLDoc(fileName);
     231  // load the campaign document
     232  if( !XMLDoc.LoadFile(fileName))
     233  {
     234    // report an error
     235    PRINTF(1)("Could not load XML File %s: %s @ %d:%d\n", fileName.c_str(), XMLDoc.ErrorDesc(), XMLDoc.ErrorRow(), XMLDoc.ErrorCol());
     236    return NULL;
     237  }
     238
     239  // check basic validity
     240  TiXmlElement* root = XMLDoc.RootElement();
     241  assert( root != NULL);
     242
     243  if( strcmp( root->Value(), "Campaign"))
     244  {
     245    // report an error
     246    PRINTF(2)("Specified XML File is not an orxonox campaign file (Campaign element missing)\n");
     247    return NULL;
     248  }
     249
     250  // construct campaign
     251  return new Campaign( root);
     252}
     253
     254
     255
     256/**
     257 *  handle keyboard commands
     258 * @param event the event to handle
     259 */
     260void GameLoader::process(const Event& event)
     261{
     262  if( event.type == KeyMapper::PEV_NEXT_WORLD)
     263  {
     264    if( likely(event.bPressed))
    93265    {
    94       this->currentCampaign = this->fileToCampaign(campaignName);
     266      this->switchToNextLevel();
    95267    }
    96268  }
    97 
    98 
    99   /**
    100    *  reads a campaign definition file into a campaign class
    101    * @param fileName to be loaded
    102    * @returns the loaded campaign
    103    *
    104    * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
    105    */
    106   ErrorMessage GameLoader::loadNetworkCampaign(const std::string& fileName)
    107   {
    108     ErrorMessage errorCode;
    109     std::string campaignName = ResourceManager::getFullName(fileName);
    110     if (!campaignName.empty())
     269  else if( event.type == KeyMapper::PEV_PAUSE)
     270  {
     271    if( likely(event.bPressed))
    111272    {
    112       this->currentCampaign = this->fileToCampaign(campaignName);
     273      if(this->isPaused)
     274        this->resume();
     275      else
     276        this->pause();
    113277    }
    114278  }
    115 
    116 
    117   /**
    118    *  loads a debug campaign for test purposes only.
    119    * @param campaignID the identifier of the campaign.
    120    * @returns error message if not able to do so.
    121    */
    122   ErrorMessage GameLoader::loadDebugCampaign(Uint32 campaignID)
    123   {
    124     switch(campaignID)
    125     {
    126         /*
    127            Debug Level 0: Debug level used to test the base frame work.
    128            As you can see, all storyentity data is allocated before game
    129            start. the storyentity will load themselfs shortly before start
    130            through the StoryEntity::init() funtion.
    131         */
    132       case DEBUG_CAMPAIGN_0:
    133         {
    134           /*        Campaign* debugCampaign = new Campaign();
    135 
    136                   World* world0 = new World(DEBUG_WORLD_0);
    137                   world0->setNextStoryID(WORLD_ID_1);
    138                   debugCampaign->addEntity(world0, WORLD_ID_0);
    139 
    140                   World* world1 = new World(DEBUG_WORLD_1);
    141                   world1->setNextStoryID(WORLD_ID_2);
    142                   debugCampaign->addEntity(world1, WORLD_ID_1);
    143 
    144                   World* world2 = new World(DEBUG_WORLD_2);
    145                   world2->setNextStoryID(WORLD_ID_GAMEEND);
    146                   debugCampaign->addEntity(world2, WORLD_ID_2);
    147 
    148                   this->currentCampaign = debugCampaign;
    149                   break;*/
    150         }
    151     }
    152   }
    153 
    154 
    155   /**
    156    *  starts the current entity
    157    * @returns error code if this action has caused a error
    158    */
    159   ErrorMessage GameLoader::start()
    160   {
    161     if(this->currentCampaign != NULL)
    162     {
    163       this->currentCampaign->start();
    164     }
    165   }
    166 
    167 
    168   /**
    169    *  stops the current entity
    170    * @returns error code if this action has caused a error
    171    *
    172    *  ATTENTION: this function shouldn't call other functions, or if so, they must return
    173    *  after finishing. If you ignore or forget to do so, the current entity is not able to
    174    *  terminate and it will run in the background or the ressources can't be freed or even
    175    *  worse: are freed and the program will end in a segmentation fault!
    176    *  hehehe, have ya seen it... :)
    177    */
    178   void GameLoader::stop()
    179   {
    180     if(this->currentCampaign != NULL)
    181       this->currentCampaign->stop();
    182   }
    183 
    184 
    185   /**
    186    *  pause the current entity
    187    * @returns error code if this action has caused a error
    188    *
    189    * this pauses the current entity or passes this call forth to the running entity.
    190    */
    191   ErrorMessage GameLoader::pause()
    192   {
    193     this->isPaused = true;
    194     if(this->currentCampaign != NULL)
    195       this->currentCampaign->pause();
    196   }
    197 
    198 
    199   /**
    200    *  resumes a pause
    201    * @returns error code if this action has caused a error
    202    *
    203    *  this resumess the current entity or passes this call forth to the running entity.
    204    */
    205   ErrorMessage GameLoader::resume()
    206   {
    207     this->isPaused = false;
    208     if(this->currentCampaign != NULL)
    209       this->currentCampaign->resume();
    210   }
    211 
    212 
    213   /**
    214    *  reads a campaign definition file into a campaign class
    215    * @param fileName to be loaded
    216    * @returns the loaded campaign
    217    *
    218    * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
    219    */
    220   Campaign* GameLoader::fileToCampaign(const std::string& fileName)
    221   {
    222     /* do not entirely load the campaign. just the current world
    223        before start of each world, it has to be initialized so it
    224        can load everything it needs into memory then.
    225     */
    226 
    227     if( fileName.empty())
    228     {
    229       PRINTF(2)("No filename specified for loading");
    230       return NULL;
    231     }
    232 
    233     TiXmlDocument XMLDoc(fileName);
    234     // load the campaign document
    235     if( !XMLDoc.LoadFile(fileName))
    236     {
    237       // report an error
    238       PRINTF(1)("Could not load XML File %s: %s @ %d:%d\n", fileName.c_str(), XMLDoc.ErrorDesc(), XMLDoc.ErrorRow(), XMLDoc.ErrorCol());
    239       return NULL;
    240     }
    241 
    242     // check basic validity
    243     TiXmlElement* root = XMLDoc.RootElement();
    244     assert( root != NULL);
    245 
    246     if( strcmp( root->Value(), "Campaign"))
    247     {
    248       // report an error
    249       PRINTF(2)("Specified XML File is not an orxonox campaign file (Campaign element missing)\n");
    250       return NULL;
    251     }
    252 
    253     // construct campaign
    254     return new Campaign( root);
    255   }
    256 
    257 
    258 
    259   /**
    260    *  handle keyboard commands
    261    * @param event the event to handle
    262    */
    263   void GameLoader::process(const Event& event)
    264   {
    265     if( event.type == KeyMapper::PEV_NEXT_WORLD)
    266     {
    267       if( likely(event.bPressed))
    268       {
    269         this->switchToNextLevel();
    270       }
    271     }
    272     else if( event.type == KeyMapper::PEV_PAUSE)
    273     {
    274       if( likely(event.bPressed))
    275       {
    276         if(this->isPaused)
    277           this->resume();
    278         else
    279           this->pause();
    280       }
    281     }
    282     else if( event.type == KeyMapper::PEV_QUIT)
    283     {
    284       if( event.bPressed) this->stop();
    285     }
    286     else if (event.type == EV_MAIN_QUIT)
    287       this->stop();
    288   }
    289 
    290 
    291   /**
    292    *  this changes to the next level
    293    */
    294   void GameLoader::switchToNextLevel()
    295   {
    296     if(this->currentCampaign != NULL)
    297       this->currentCampaign->switchToNextLevel();
    298   }
    299 
    300 }
     279  else if( event.type == KeyMapper::PEV_QUIT)
     280  {
     281    if( event.bPressed) this->stop();
     282  }
     283  else if (event.type == EV_MAIN_QUIT)
     284    this->stop();
     285}
     286
     287
     288/**
     289 *  this changes to the next level
     290 */
     291void GameLoader::switchToNextLevel()
     292{
     293  if(this->currentCampaign != NULL)
     294    this->currentCampaign->switchToNextLevel();
     295}
     296

  • trunk/src/lib/util/loading/game_loader.h

    r7221 r7868  
    2323class BaseObject;
    2424class Event;
    25 class EventHandler;
    2625
    2726//! The GameLoader
    … …  
    7372
    7473  Campaign*              currentCampaign;      //!< reference to the current campaign playing
    75 
    76   EventHandler*          eventHandler;         //!< reference to the eventHandler
    7774};
    7875
Note: See TracChangeset for help on using the changeset viewer.