Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/resources/src/story_entities/game_world.cc @ 7341

Last change on this file since 7341 was 7221, checked in by bensch, 19 years ago

orxonox/trunk: merged the std-branche back, it runs on windows and Linux

svn merge https://svn.orxonox.net/orxonox/branches/std . -r7202:HEAD

File size: 13.2 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 "util/loading/resource_manager.h"
23#include "state.h"
24#include "class_list.h"
25#include "substring.h"
26
27#include "util/loading/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 "util/loading/factory.h"
45#include "fast_factory.h"
46#include "util/loading/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#include "game_rules.h"
67
68using namespace std;
69
70
71SHELL_COMMAND(speed, GameWorld, setSpeed);
72SHELL_COMMAND_STATIC(togglePNodeVisibility, GameWorld, GameWorld::togglePNodeVisibility);
73SHELL_COMMAND_STATIC(toggleBVVisibility, GameWorld, GameWorld::toggleBVVisibility);
74
75
76
77GameWorld::GameWorld()
78    : StoryEntity()
79{
80  this->setClassID(CL_GAME_WORLD, "GameWorld");
81  this->setName("Preloaded World - no name yet");
82
83  this->gameTime = 0.0f;
84  this->setSpeed(1.0f);
85  this->shell = NULL;
86
87  this->showPNodes = false;
88  this->showBV = false;
89
90  this->dataXML = 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  PRINTF(4)("Loaded GameWorld specific stuff\n");
115}
116
117
118/**
119 * this is executed just before load
120 *
121 * since the load function sometimes needs data, that has been initialized
122 * before the load and after the proceeding storyentity has finished
123*/
124ErrorMessage GameWorld::init()
125{
126  /* init the world interface */
127  this->shell = new Shell();
128
129  State::setCurrentStoryEntity(dynamic_cast<StoryEntity*>(this));
130  this->dataTank->init();
131}
132
133
134/**
135 *  loads the GameWorld by initializing all resources, and set their default values.
136 */
137ErrorMessage GameWorld::loadData()
138{
139  this->displayLoadScreen();
140
141  PRINTF(0)("Loading the GameWorld\n");
142
143  PRINTF(3)("> Loading world: '%s'\n", getLoadFile());
144  TiXmlElement* element;
145  GameLoader* loader = GameLoader::getInstance();
146
147  if( getLoadFile().empty())
148  {
149    PRINTF(1)("GameWorld has no path specified for loading\n");
150    return (ErrorMessage){213,"Path not specified","GameWorld::load()"};
151  }
152
153  TiXmlDocument* XMLDoc = new TiXmlDocument( getLoadFile());
154  // load the xml world file for further loading
155  if( !XMLDoc->LoadFile())
156  {
157    PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc->ErrorDesc(), this->getLoadFile().c_str(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
158    delete XMLDoc;
159    return (ErrorMessage){213,"XML File parsing error","GameWorld::load()"};
160  }
161  // check basic validity
162  TiXmlElement* root = XMLDoc->RootElement();
163  assert( root != NULL);
164  if( root == NULL || root->Value() == NULL || strcmp( root->Value(), "WorldDataFile"))
165  {
166    // report an error
167    PRINTF(1)("Specified XML File is not an orxonox world data file (WorldDataFile element missing)\n");
168    delete XMLDoc;
169    return (ErrorMessage){213,"Path not a WorldDataFile","GameWorld::load()"};
170  }
171  /* the whole loading process for the GameWorld */
172  this->dataTank->loadData(root);
173  this->dataXML = (TiXmlElement*)root->Clone();
174
175  delete XMLDoc;
176  this->releaseLoadScreen();
177}
178
179
180/**
181 *  unload the data of this GameWorld
182 */
183ErrorMessage GameWorld::unloadData()
184{
185  delete this->shell;
186  PRINTF(3)("GameWorld::~GameWorld() - unloading the current GameWorld\n");
187
188  this->dataTank->unloadData();
189
190  State::setCurrentStoryEntity(NULL);
191  if (this->dataXML)
192    delete this->dataXML;
193}
194
195
196/**
197 *  starts the GameWorld
198 */
199bool GameWorld::start()
200{
201  this->isPaused = false;
202  this->isRunning = true;
203
204  this->run();
205}
206
207
208/**
209 *  stops the world.
210 */
211bool GameWorld::stop()
212{
213  PRINTF(3)("GameWorld::stop() - got stop signal\n");
214  this->isRunning = false;
215}
216
217
218/**
219 *  pauses the game
220 */
221bool GameWorld::pause()
222{
223  this->isPaused = true;
224}
225
226
227/**
228 *  ends the pause Phase
229 */
230bool GameWorld::resume()
231{
232  this->isPaused = false;
233}
234
235
236/**
237 *  main loop of the world: executing all world relevant function
238 *
239 * in this loop we synchronize (if networked), handle input events, give the heart-beat to
240 * all other member-entities of the world (tick to player, enemies etc.), checking for
241 * collisions drawing everything to the screen.
242 */
243void GameWorld::run()
244{
245  /* start the music */
246  if(this->dataTank->music != NULL)
247    this->dataTank->music->playback();
248
249  PRINTF(3)("GameWorld::mainLoop() - Entering main loop\n");
250
251  // initialize Timing
252  this->cycle = 0;
253  for (unsigned int i = 0; i < TICK_SMOOTH_VALUE; i++)
254    this->frameTimes[i] = 100;
255  this->dtS = 0.0f;
256  this->lastFrame = SDL_GetTicks ();
257
258  while( this->isRunning) /* @todo implement pause */
259  {
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/**
318 *  advance the timeline
319 *
320 * this calculates the time used to process one frame (with all input handling, drawing, etc)
321 * the time is mesured in ms and passed to all world-entities and other classes that need
322 * a heart-beat.
323 */
324void GameWorld::tick ()
325{
326  Uint32 currentFrame = SDL_GetTicks();
327
328  if( !this->isPaused)
329  {
330    // CALCULATE FRAMERATE
331    Uint32 frameTimesIndex;
332    Uint32 getTicks;
333    Uint32 i;
334
335    frameTimesIndex = this->cycle % TICK_SMOOTH_VALUE;
336    getTicks = SDL_GetTicks();
337    this->frameTimes[frameTimesIndex] = getTicks - this->lastFrame;
338    this->lastFrame = getTicks;
339    ++this->cycle;
340    this->dtS = 0;
341    for (i = 0; i < TICK_SMOOTH_VALUE; i++)
342      this->dtS += this->frameTimes[i];
343    this->dtS = this->dtS / TICK_SMOOTH_VALUE / 1000.0f * speed;
344
345    // TICK everything
346    this->tick(this->dataTank->objectManager->getObjectList(OM_DEAD_TICK), this->dtS);
347    this->tick(this->dataTank->objectManager->getObjectList(OM_ENVIRON), this->dtS);
348    this->tick(this->dataTank->objectManager->getObjectList(OM_COMMON), this->dtS);
349    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_00), this->dtS);
350    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_00_PROJ), this->dtS);
351    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_01), this->dtS);
352    this->tick(this->dataTank->objectManager->getObjectList(OM_GROUP_01_PROJ), this->dtS);
353
354    /* update tick the rest */
355    this->dataTank->localCamera->tick(this->dtS);
356    AnimationPlayer::getInstance()->tick(this->dtS);
357    PhysicsEngine::getInstance()->tick(this->dtS);
358
359    GraphicsEngine::getInstance()->tick(this->dtS);
360
361    if( likely(this->dataTank->gameRule != NULL))
362      this->dataTank->gameRule->tick(this->dtS);
363  }
364  this->lastFrame = currentFrame;
365}
366
367
368/**
369 *  this function gives the world a consistant state
370 *
371 * after ticking (updating the world state) this will give a constistant
372 * state to the whole system.
373 */
374void GameWorld::update()
375{
376  GraphicsEngine::getInstance()->update(this->dtS);
377  PNode::getNullParent()->updateNode (this->dtS);
378  SoundEngine::getInstance()->update();
379
380  if (this->dataTank->music != NULL)
381    this->dataTank->music->update();
382}
383
384
385/**
386 * kicks the CDEngine to detect the collisions between the object groups in the world
387 */
388void GameWorld::collide()
389{
390  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
391      this->dataTank->objectManager->getObjectList(OM_GROUP_01_PROJ));
392  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_01),
393      this->dataTank->objectManager->getObjectList(OM_GROUP_00_PROJ));
394  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
395  this->dataTank->objectManager->getObjectList(OM_GROUP_01));
396
397  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
398      this->dataTank->objectManager->getObjectList(OM_COMMON));
399  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_01),
400      this->dataTank->objectManager->getObjectList(OM_COMMON));
401
402}
403
404/**
405 *  render the current frame
406 *
407 * clear all buffers and draw the world
408 */
409void GameWorld::display ()
410{
411  // clear buffer
412  glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
413  // draw world
414  this->draw();
415  // flip buffers
416  GraphicsEngine::swapBuffers();
417}
418
419
420/**
421 *  runs through all entities calling their draw() methods
422 */
423void GameWorld::draw ()
424{
425  GraphicsEngine* engine = GraphicsEngine::getInstance();
426
427  // set camera
428  this->dataTank->localCamera->apply ();
429  this->dataTank->localCamera->project ();
430  LightManager::getInstance()->draw();
431
432  /* draw all WorldEntiy groups */
433  engine->draw(State::getObjectManager()->getObjectList(OM_ENVIRON_NOTICK));
434  engine->draw(State::getObjectManager()->getObjectList(OM_ENVIRON));
435  engine->draw(State::getObjectManager()->getObjectList(OM_COMMON));
436  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_00));
437  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_00_PROJ));
438  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_01));
439  engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_01_PROJ));
440
441
442  if( unlikely( this->showBV))
443  {
444    CDEngine* engine = CDEngine::getInstance();
445    engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON_NOTICK));
446    engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON));
447    engine->drawBV(State::getObjectManager()->getObjectList(OM_COMMON));
448    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_00));
449    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01));
450    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01_PROJ));
451  }
452
453  if( unlikely(this->showPNodes))
454    PNode::getNullParent()->debugDraw(0);
455
456  engine->draw();
457
458
459  // draw the game ruls
460  if( likely(this->dataTank->gameRule != NULL))
461    this->dataTank->gameRule->draw();
462}
463
464/**
465 *  shows the loading screen
466 */
467void GameWorld::displayLoadScreen ()
468{
469  PRINTF(3)("GameWorld::displayLoadScreen - start\n");
470  this->dataTank->glmis = new GLMenuImageScreen();
471  this->dataTank->glmis->setMaximum(8);
472  PRINTF(3)("GameWorld::displayLoadScreen - end\n");
473}
474
475
476/**
477 *  removes the loadscreen, and changes over to the game
478 */
479void GameWorld::releaseLoadScreen ()
480{
481  PRINTF(3)("GameWorld::releaseLoadScreen - start\n");
482  this->dataTank->glmis->setValue(this->dataTank->glmis->getMaximum());
483  PRINTF(3)("GameWorld::releaseLoadScreen - end\n");
484}
485
486
487
488/**
489 * @brief toggles the PNode visibility in the world (drawn as boxes)
490 */
491void GameWorld::togglePNodeVisibility()
492{
493  if (State::getCurrentStoryEntity() != NULL &&
494      State::getCurrentStoryEntity()->isA(CL_GAME_WORLD))
495  {
496    dynamic_cast<GameWorld*>(State::getCurrentStoryEntity())->showPNodes = !dynamic_cast<GameWorld*>(State::getCurrentStoryEntity())->showPNodes;
497  }
498  else
499    PRINTF(2)("The Current Story entity is not a GameWorld\n");
500};
501
502
503/**
504 * @brief toggles the bounding volume (BV) visibility
505*/
506void GameWorld::toggleBVVisibility()
507{
508  if (State::getCurrentStoryEntity() != NULL &&
509      State::getCurrentStoryEntity()->isA(CL_GAME_WORLD))
510  {
511    dynamic_cast<GameWorld*>(State::getCurrentStoryEntity())->showBV = !dynamic_cast<GameWorld*>(State::getCurrentStoryEntity())->showBV;
512  }
513  else
514    PRINTF(2)("The Current Story entity is not a GameWorld\n");
515};
516
Note: See TracBrowser for help on using the repository browser.