source: orxonox.OLD/branches/network/src/story_entities/campaign.cc @ 6374

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   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, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Patrick Boenzli
*/


#include "campaign.h"

#include "factory.h"
#include "load_param.h"


using namespace std;


/**
 *  the constructor
 * @param root the XML root element
 *
 * this constructor is always called in a XML context (loading procedure)
 */
Campaign::Campaign ( TiXmlElement* root)
{
  this->setClassID(CL_CAMPAIGN, "Campaign");
  this->isInit = false;

  PRINTF(4)("Loading Campaign...\n");
  assert( root != NULL);

  this->loadParams(root);
}


/**
 * the campaign destructor
 */
Campaign::~Campaign ()
{}


/**
 *  initializes the class
 */
ErrorMessage Campaign::init()
{
  this->isInit = true;
}


/**
 *  loads the Parameters of a Campaign
 * @param root: The XML-element to load from
 */
void Campaign::loadParams(const TiXmlElement* root)
{
  static_cast<BaseObject*>(this)->loadParams(root);

  LoadParam(root, "identifier", this, Campaign, setStoryID)
  .describe("A Unique Identifier for this Campaign");

  LoadParamXML(root, "WorldList", this, Campaign, loadWorldListParams)
  .describe("A List of Worlds to be loaded in this Campaign");
}


/**
 *  loads a WorldList
 * @param root: the XML-element to load from
 */
void Campaign::loadWorldListParams(const TiXmlElement* root)
{
  if( root == NULL)
    return;

  LOAD_PARAM_START_CYCLE(root, element);
  {
    StoryEntity* created = (StoryEntity*) Factory::fabricate(element);
    if( created != NULL)
      this->addEntity( created);
    PRINTF(3)("Campaign: Constructor: adding a world with name \"%s\" and id %i\n",
              created->getName(), created->getStoryID());
  }
  LOAD_PARAM_END_CYCLE(element);

}


/**
 *  starts the campaing
 */
ErrorMessage Campaign::start()
{
  this->start(0);
}


/**
 *  starts the campaing with a specific ID
 * @param storyID the id of the StoryEntity
 */
ErrorMessage Campaign::start(int storyID = 0)
{
  ErrorMessage errorCode;
  if( !this->isInit) return errorCode;
  if( storyID == WORLD_ID_GAMEEND) return errorCode;
  this->running = true;
  StoryEntity* se = this->getStoryEntity(storyID);
  this->currentEntity = se;
  while( se != NULL && this->running)
  {
    PRINTF(0)("Campaign is starting StoryEntity nr:%i\n", se->getStoryID());

    se->init();
    se->loadData();

    se->preStart();
    se->start();


    int nextWorldID = se->getNextStoryID();

    this->entities.remove(se);
    delete se;

    se = this->getStoryEntity(nextWorldID);
    this->currentEntity = se;
    if( ( nextWorldID == WORLD_ID_GAMEEND) || ( se == NULL) )
    {
      PRINTF(4)("Quitting campaing story loop\n");
      if(se != NULL)
        delete se;
      return errorCode;
    }
  }

  /* clean up all world that have not been loaded and therefore are still in the world list  -
     this probably does not belong into the start function. remove this later
  */
  list<StoryEntity*>::iterator it;
  for(it = this->entities.begin(); it != entities.end(); it++)
  {
    delete (*it);
  }

  PRINTF(2)("There is no StoryEnity left to play, quitting\n");
}


/**
 *  pauses the campaing
 */
ErrorMessage Campaign::pause()
{
  if(this->currentEntity != NULL)
    this->isPaused = true;
}


ErrorMessage Campaign::resume()
{
  if(this->currentEntity != NULL)
    this->isPaused = false;
}


ErrorMessage Campaign::stop()
{
  this->running = false;
  if(this->currentEntity != NULL)
  {
    this->currentEntity->stop();
  }
}

/*
ErrorMessage Campaign::destroy()
{
  if(this->currentEntity != NULL)
    {
      this->currentEntity->destroy();
      delete this->currentEntity;
      this->currentEntity = NULL;
    }
}*/


/**
  *  adds an game stroy entity to the campaign

  * @param se: The entity
  * @param storyID: The number that identifies the entity in the campaign. Each ID only used once in a Campaign

    An entity can be a world (playable), a cinematic, a shop, sounds, whatever you
    want to queue up in the campaign.
*/
void Campaign::addEntity(StoryEntity* se, int storyID)
{
  se->setStoryID(storyID);
  this->addEntity(se);
}

void Campaign::addEntity(StoryEntity* se)
{
  this->entities.push_back(se);
}


void Campaign::removeEntity(int storyID)
{
  this->removeEntity(this->getStoryEntity(storyID));

}


void Campaign::removeEntity(StoryEntity* se)
{
  this->entities.remove(se);
}


/*
  \brief this changes to the next level
*/
void Campaign::nextLevel()
{
  PRINTF(4)("Campaign:nextLevel()\n");
  this->currentEntity->stop();
}

/*
  \brief change to the previous level - not implemented

  this propably useless
*/
void Campaign::previousLevel()
{}


/*
  \brief lookup a entity with a given id
* @param story id to be lookuped
  @returns the entity found or NULL if search ended without match
*/
StoryEntity* Campaign::getStoryEntity(int storyID)
{
  if( storyID == WORLD_ID_GAMEEND)
    return NULL;

  int id;
  list<StoryEntity*>::iterator it;
  for( it = this->entities.begin(); it != this->entities.end(); it++)
  {
    id = (*it)->getStoryID();
    if( id == storyID)
      return (*it);
  }

  return NULL;
}