Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/story_entities/game_world.cc @ 6988

Last change on this file since 6988 was 6988, checked in by bensch, 18 years ago

orxonox/trunk: soundEngine works again

File size: 12.1 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: Patrick Boenzli
13   co-programmer: Christian Meyer
14   co-programmer: Benjamin Grauer
15*/
16
17#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD
18
19#include "game_world.h"
20#include "game_world_data.h"
21
22#include "resource_manager.h"
23#include "state.h"
24#include "class_list.h"
25#include "substring.h"
26
27#include "game_loader.h"
28
29#include "p_node.h"
30#include "world_entity.h"
31#include "player.h"
32#include "camera.h"
33#include "environment.h"
34#include "terrain.h"
35#include "test_entity.h"
36#include "terrain.h"
37#include "md2Model.h"
38#include "world_entities/projectiles/projectile.h"
39#include "npcs/npc_test1.h"
40#include "playable.h"
41
42#include "light.h"
43
44#include "factory.h"
45#include "fast_factory.h"
46#include "load_param.h"
47#include "shell_command.h"
48
49#include "graphics_engine.h"
50#include "event_handler.h"
51#include "sound_engine.h"
52#include "cd_engine.h"
53#include "network_manager.h"
54#include "physics_engine.h"
55#include "fields.h"
56
57#include "glmenu_imagescreen.h"
58#include "shell.h"
59
60#include "animation_player.h"
61#include "animation3d.h"
62
63#include "ogg_player.h"
64#include "shader.h"
65
66
67using namespace std;
68
69
70SHELL_COMMAND(speed, GameWorld, setSpeed);
71SHELL_COMMAND(togglePNodeVisibility, GameWorld, togglePNodeVisibility);
72SHELL_COMMAND(toggleBVVisibility, GameWorld, toggleBVVisibility);
73
74
75
76GameWorld::GameWorld(const TiXmlElement* root)
77    : StoryEntity()
78{
79  this->setClassID(CL_GAME_WORLD, "GameWorld");
80  this->setName("Preloaded World - no name yet");
81
82  this->gameTime = 0.0f;
83  this->setSpeed(1.0f);
84  this->shell = NULL;
85
86  this->showPNodes = false;
87  this->showBV = false;
88
89  this->dataXML = NULL;
90  this->path = NULL;
91}
92
93/**
94 *  remove the GameWorld from memory
95 *
96 *  delete everything explicitly, that isn't contained in the parenting tree!
97 *  things contained in the tree are deleted automaticaly
98 */
99GameWorld::~GameWorld ()
100{
101  PRINTF(4)("Deleted GameWorld\n");
102}
103
104
105
106/**
107 * loads the parameters of a GameWorld from an XML-element
108 * @param root the XML-element to load from
109 */
110void GameWorld::loadParams(const TiXmlElement* root)
111{
112  StoryEntity::loadParams(root);
113
114  LoadParam(root, "path", this, GameWorld, setPath)
115      .describe("The Filename of this GameWorld (relative from the data-dir)");
116
117  PRINTF(4)("Loaded GameWorld specific stuff\n");
118}
119
120
121/**
122 * this is executed just before load
123 *
124 * since the load function sometimes needs data, that has been initialized
125 * before the load and after the proceeding storyentity has finished
126*/
127ErrorMessage GameWorld::init()
128{
129  this->cycle = 0;
130  /* init the world interface */
131  this->shell = new Shell();
132
133  State::setCurrentStoryEntity(dynamic_cast<StoryEntity*>(this));
134  this->dataTank->init();
135}
136
137
138/**
139 *  loads the GameWorld by initializing all resources, and set their default values.
140 */
141ErrorMessage GameWorld::loadData()
142{
143  this->displayLoadScreen();
144
145  PRINTF(0)("Loading the GameWorld\n");
146
147  PRINTF(3)("> Loading world: '%s'\n", getPath());
148  TiXmlElement* element;
149  GameLoader* loader = GameLoader::getInstance();
150
151  if( getPath() == NULL)
152  {
153    PRINTF(1)("GameWorld has no path specified for loading\n");
154    return (ErrorMessage){213,"Path not specified","GameWorld::load()"};
155  }
156
157  TiXmlDocument* XMLDoc = new TiXmlDocument( getPath());
158  // load the xml world file for further loading
159  if( !XMLDoc->LoadFile())
160  {
161    PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc->ErrorDesc(), this->getPath(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
162    delete XMLDoc;
163    return (ErrorMessage){213,"XML File parsing error","GameWorld::load()"};
164  }
165  // check basic validity
166  TiXmlElement* root = XMLDoc->RootElement();
167  assert( root != NULL);
168  if( root == NULL || root->Value() == NULL || strcmp( root->Value(), "WorldDataFile"))
169  {
170    // report an error
171    PRINTF(1)("Specified XML File is not an orxonox world data file (WorldDataFile element missing)\n");
172    delete XMLDoc;
173    return (ErrorMessage){213,"Path not a WorldDataFile","GameWorld::load()"};
174  }
175  /* the whole loading process for the GameWorld */
176  this->dataTank->loadData(root);
177  this->dataXML = (TiXmlElement*)root->Clone();
178
179  delete XMLDoc;
180  this->releaseLoadScreen();
181}
182
183
184/**
185 *  unload the data of this GameWorld
186 */
187ErrorMessage GameWorld::unloadData()
188{
189  delete this->shell;
190  PRINTF(3)("GameWorld::~GameWorld() - unloading the current GameWorld\n");
191
192  this->dataTank->unloadData();
193
194  State::setCurrentStoryEntity(NULL);
195  if (this->dataXML)
196    delete this->dataXML;
197
198}
199
200
201/**
202 *  starts the GameWorld
203 */
204bool GameWorld::start()
205{
206  this->isPaused = false;
207  this->isRunning = true;
208
209  this->run();
210}
211
212
213/**
214 *  stops the world.
215 */
216bool GameWorld::stop()
217{
218  PRINTF(3)("GameWorld::stop() - got stop signal\n");
219  this->isRunning = false;
220}
221
222
223/**
224 *  pauses the game
225 */
226bool GameWorld::pause()
227{
228  this->isPaused = true;
229}
230
231
232/**
233 *  ends the pause Phase
234 */
235bool GameWorld::resume()
236{
237  this->isPaused = false;
238}
239
240
241/**
242 *  main loop of the world: executing all world relevant function
243 *
244 * in this loop we synchronize (if networked), handle input events, give the heart-beat to
245 * all other member-entities of the world (tick to player, enemies etc.), checking for
246 * collisions drawing everything to the screen.
247 */
248void GameWorld::run()
249{
250  /* start the music */
251  if(this->dataTank->music != NULL)
252    this->dataTank->music->playback();
253
254  this->lastFrame = SDL_GetTicks ();
255  PRINTF(3)("GameWorld::mainLoop() - Entering main loop\n");
256
257  while( this->isRunning) /* @todo implement pause */
258  {
259    ++this->cycle;
260    /* process intput */
261    this->handleInput ();
262    if( !this->isRunning)
263      break;
264
265    /* network synchronisation */
266    this->synchronize ();
267    /* process time */
268    this->tick ();
269    /* process collision */
270    this->collide ();
271    /* update the state */
272    this->update ();
273    /* draw everything */
274    this->display ();
275  }
276
277  PRINTF(3)("GameWorld::mainLoop() - Exiting the main loop\n");
278}
279
280
281/**
282 *  synchronize local data with remote data
283*/
284void GameWorld::synchronize ()
285{}
286
287
288/**
289 *  run all input processing
290
291   the command node is the central input event dispatcher. the node uses the even-queue from
292   sdl and has its own event-passing-queue.
293*/
294void GameWorld::handleInput ()
295{
296  EventHandler::getInstance()->process();
297}
298
299
300/**
301 *  ticks a WorldEntity list
302 * @param entityList list of the WorldEntities
303 * @param dt time passed since last frame
304 */
305void GameWorld::tick(std::list<WorldEntity*> entityList, float dt)
306{
307  std::list<WorldEntity*>::iterator entity, next;
308  next = entityList.begin();
309  while (next != entityList.end())
310  {
311    entity = next++;
312    (*entity)->tick(dt);
313  }
314}
315
316/**
317 *  advance the timeline
318 *
319 * this calculates the time used to process one frame (with all input handling, drawing, etc)
320 * the time is mesured in ms and passed to all world-entities and other classes that need
321 * a heart-beat.
322 */
323void GameWorld::tick ()
324{
325  Uint32 currentFrame = SDL_GetTicks();
326
327  if( !this->isPaused)
328  {
329    this->dt = currentFrame - this->lastFrame;
330
331    /* limit the the frame rate to 100 frames per second (fps) */
332    if( this->dt < 10)
333    {
334      /* the frame-rate is limited to 100 frames per second, all other things are for nothing. */
335      //PRINTF(0)("fps = 1000 - frame rate is adjusted\n");
336      SDL_Delay(10 - dt);
337      this->dt = 10;
338    }
339
340    this->dtS = (float)this->dt / 1000.0f * this->speed;
341    this->gameTime += this->dtS;
342
343    this->tick(this->dataTank->objectManager->getObjectList(OM_DEAD_TICK), this->dtS);
344    this->tick(this->dataTank->objectManager->getObjectList(OM_ENVIRON), this->dtS);
345    this->tick(this->dataTank->objectManager->getObjectList(OM_COMMON), this->dtS);
346    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_00), this->dtS);
347    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_00_PROJ), this->dtS);
348    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_01), this->dtS);
349    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_01_PROJ), this->dtS);
350
351    /* update tick the rest */
352    this->dataTank->localCamera->tick(this->dtS);
353    AnimationPlayer::getInstance()->tick(this->dtS);
354    PhysicsEngine::getInstance()->tick(this->dtS);
355
356    GraphicsEngine::getInstance()->tick(this->dtS);
357  }
358  this->lastFrame = currentFrame;
359}
360
361
362/**
363 *  this function gives the world a consistant state
364 *
365 * after ticking (updating the world state) this will give a constistant
366 * state to the whole system.
367 */
368void GameWorld::update()
369{
370  GraphicsEngine::getInstance()->update(this->dtS);
371  PNode::getNullParent()->updateNode (this->dtS);
372  SoundEngine::getInstance()->update();
373
374  if (this->dataTank->music != NULL)
375    this->dataTank->music->update();
376}
377
378
379/**
380 * kicks the CDEngine to detect the collisions between the object groups in the world
381 */
382void GameWorld::collide()
383{
384  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
385  this->dataTank->objectManager->getObjectList(OM_GROUP_01_PROJ));
386  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_01),
387  this->dataTank->objectManager->getObjectList(OM_GROUP_00_PROJ));
388
389  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_01),
390      this->dataTank->objectManager->getObjectList(OM_COMMON));
391}
392
393/**
394 *  render the current frame
395 *
396 * clear all buffers and draw the world
397 */
398void GameWorld::display ()
399{
400  // clear buffer
401  glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
402  // draw world
403  this->draw();
404  // flip buffers
405  GraphicsEngine::swapBuffers();
406}
407
408
409/**
410 *  runs through all entities calling their draw() methods
411 */
412void GameWorld::draw ()
413{
414  GraphicsEngine* engine = GraphicsEngine::getInstance();
415
416  // set camera
417  this->dataTank->localCamera->apply ();
418
419  /* draw all WorldEntiy groups */
420  engine->draw(State::getObjectManager()->getObjectList(OM_ENVIRON_NOTICK));
421  engine->draw(State::getObjectManager()->getObjectList(OM_ENVIRON));
422  engine->draw(State::getObjectManager()->getObjectList(OM_COMMON));
423  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_00));
424  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_00_PROJ));
425  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_01));
426  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_01_PROJ));
427
428
429  if( unlikely( this->showBV))
430  {
431    CDEngine* engine = CDEngine::getInstance();
432    engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON_NOTICK));
433    engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON));
434    engine->drawBV(State::getObjectManager()->getObjectList(OM_COMMON));
435    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_00));
436    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01));
437    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01_PROJ));
438  }
439
440  if( unlikely(this->showPNodes))
441    PNode::getNullParent()->debugDraw(0);
442
443  engine->draw();
444}
445
446
447/**
448 *  sets the track path of this world
449 * @param name the name of the path
450 */
451void GameWorld::setPath( const char* name)
452{
453  if (this->path)
454    delete this->path;
455  if (ResourceManager::isFile(name))
456  {
457    this->path = new char[strlen(name)+1];
458    strcpy(this->path, name);
459  }
460  else
461  {
462    this->path = new char[strlen(ResourceManager::getInstance()->getDataDir()) + strlen(name) +1];
463    sprintf(this->path, "%s%s", ResourceManager::getInstance()->getDataDir(), name);
464  }
465}
466
467
468/**
469 *  shows the loading screen
470 */
471void GameWorld::displayLoadScreen ()
472{
473  PRINTF(3)("GameWorld::displayLoadScreen - start\n");
474  this->dataTank->glmis = new GLMenuImageScreen();
475  this->dataTank->glmis->setMaximum(8);
476  PRINTF(3)("GameWorld::displayLoadScreen - end\n");
477}
478
479
480/**
481 *  removes the loadscreen, and changes over to the game
482 */
483void GameWorld::releaseLoadScreen ()
484{
485  PRINTF(3)("GameWorld::releaseLoadScreen - start\n");
486  this->dataTank->glmis->setValue(this->dataTank->glmis->getMaximum());
487  PRINTF(3)("GameWorld::releaseLoadScreen - end\n");
488}
489
Note: See TracBrowser for help on using the repository browser.