Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

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

orxonox/trunk: now the elements are draw correctly

File size: 17.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
26#include "util/loading/game_loader.h"
27#include "util/timer.h"
28
29#include "player.h"
30#include "camera.h"
31#include "environment.h"
32#include "terrain.h"
33#include "test_entity.h"
34#include "terrain.h"
35#include "playable.h"
36#include "environments/mapped_water.h"
37
38#include "light.h"
39
40#include "util/loading/factory.h"
41#include "util/loading/load_param.h"
42#include "fast_factory.h"
43#include "shell_command.h"
44
45#include "graphics_engine.h"
46#include "effects/atmospheric_engine.h"
47#include "event_handler.h"
48#include "sound_engine.h"
49#include "cd_engine.h"
50#include "network_manager.h"
51#include "physics_engine.h"
52#include "fields.h"
53
54#include "glmenu_imagescreen.h"
55#include "shell.h"
56
57#include "ogg_player.h"
58#include "shader.h"
59
60#include "animation_player.h"
61
62#include "game_rules.h"
63
64using namespace std;
65
66
67SHELL_COMMAND(speed, GameWorld, setSpeed) ->describe("set the Speed of the Level");
68SHELL_COMMAND(playmode, GameWorld, setPlaymode)
69->describe("Set the Playmode of the current Level")
70->completionPlugin(0, OrxShell::CompletorStringArray(Playable::playmodeNames, Playable::PlaymodeCount));
71
72SHELL_COMMAND(togglePNodeVisibility, GameWorld, togglePNodeVisibility);
73SHELL_COMMAND(showBVLevel, 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  this->showBVLevel = 3;
90
91  this->dataXML = NULL;
92  this->gameRules = NULL;
93}
94
95/**
96 *  remove the GameWorld from memory
97 *
98 *  delete everything explicitly, that isn't contained in the parenting tree!
99 *  things contained in the tree are deleted automaticaly
100 */
101GameWorld::~GameWorld ()
102{
103  PRINTF(4)("Deleted GameWorld\n");
104
105}
106
107
108
109/**
110 * loads the parameters of a GameWorld from an XML-element
111 * @param root the XML-element to load from
112 */
113void GameWorld::loadParams(const TiXmlElement* root)
114{
115  StoryEntity::loadParams(root);
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  /* init the world interface */
130  this->shell = new OrxShell::Shell();
131
132  State::setCurrentStoryEntity(dynamic_cast<StoryEntity*>(this));
133  this->dataTank->init();
134
135  /* initialize some engines and graphical elements */
136  AnimationPlayer::getInstance();
137  PhysicsEngine::getInstance();
138  CREngine::getInstance();
139
140  State::setScriptManager(&this->scriptManager);
141
142  return ErrorMessage();
143}
144
145/**
146 *  loads the GameWorld by initializing all resources, and set their default values.
147 */
148ErrorMessage GameWorld::loadData()
149{
150  this->displayLoadScreen();  State::setScriptManager(&this->scriptManager);
151
152
153  PRINTF(0)("Loading the GameWorld\n");
154
155  PRINTF(3)("> Loading world: '%s'\n", getLoadFile().c_str());
156//  TiXmlElement* element;
157//  GameLoader* loader = GameLoader::getInstance();
158
159  if( getLoadFile().empty())
160  {
161    PRINTF(1)("GameWorld has no path specified for loading\n");
162    return (ErrorMessage(213,"Path not specified","GameWorld::load()"));
163  }
164
165  TiXmlDocument* XMLDoc = new TiXmlDocument( getLoadFile());
166  // load the xml world file for further loading
167  if( !XMLDoc->LoadFile())
168  {
169    PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc->ErrorDesc(), this->getLoadFile().c_str(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
170    delete XMLDoc;
171    return ErrorMessage(213,"XML File parsing error","GameWorld::load()");
172  }
173  // check basic validity
174  TiXmlElement* root = XMLDoc->RootElement();
175  assert( root != NULL);
176  if( root == NULL || root->Value() == NULL || strcmp( root->Value(), "WorldDataFile"))
177  {
178    // report an error
179    PRINTF(1)("Specified XML File is not an orxonox world data file (WorldDataFile element missing)\n");
180    delete XMLDoc;
181    return ErrorMessage(213,"Path not a WorldDataFile","GameWorld::load()");
182  }
183  /* the whole loading process for the GameWorld */
184  this->dataTank->loadData(root);
185  this->dataXML = (TiXmlElement*)root->Clone();
186
187  //remove this after finished testing !!!!
188  //Object* obj= new Object();
189  //obj->setName("Obj");
190  //Account* a = new Account();
191  //a->setName("a");
192  //Account *b = new Account(30);
193  //b->setName("b");
194
195
196  LoadParamXML(root, "ScriptManager", &this->scriptManager, ScriptManager, loadParams);
197
198  delete XMLDoc;
199  this->releaseLoadScreen();
200
201  return ErrorMessage();
202}
203
204
205/**
206 *  unload the data of this GameWorld
207 */
208ErrorMessage GameWorld::unloadData()
209{
210
211  PRINTF(3)("GameWorld::~GameWorld() - unloading the current GameWorld\n");
212  this->scriptManager.flush();
213
214  delete this->shell;
215
216  this->dataTank->unloadData();
217
218  this->shell = NULL;
219  delete AnimationPlayer::getInstance();
220  delete PhysicsEngine::getInstance();
221  delete CREngine::getInstance();
222
223  State::setCurrentStoryEntity(NULL);
224  if (this->dataXML)
225    delete this->dataXML;
226
227  return ErrorMessage();
228}
229
230
231/**
232 *  starts the GameWorld
233 */
234bool GameWorld::start()
235{
236  this->bPaused = false;
237  this->bRunning = true;
238  State::setScriptManager(&this->scriptManager); //make sure we have the right script manager
239  this->run();
240
241  return true;
242}
243
244
245/**
246 *  stops the world.
247 */
248bool GameWorld::stop()
249{
250  PRINTF(3)("GameWorld::stop() - got stop signal\n");
251  State::setScriptManager(NULL);
252  return (this->bRunning = false);
253}
254
255
256/**
257 *  pauses the game
258 */
259bool GameWorld::pause()
260{
261  return (this->bPaused = true);
262}
263
264
265/**
266 *  ends the pause Phase
267 */
268bool GameWorld::resume()
269{
270  return(this->bPaused = false);
271}
272
273
274/**
275 *  main loop of the world: executing all world relevant function
276 *
277 * in this loop we synchronize (if networked), handle input events, give the heart-beat to
278 * all other member-entities of the world (tick to player, enemies etc.), checking for
279 * collisions drawing everything to the screen.
280 */
281void GameWorld::run()
282{
283  PRINTF(3)("GameWorld::mainLoop() - Entering main loop\n");
284
285  // initialize Timing
286  this->cycle = 0;
287  for (unsigned int i = 0; i < TICK_SMOOTH_VALUE; i++)
288    this->frameTimes[i] = 0.01f;
289  this->dtS = 0.0f;
290  this->lastFrame = Timer::getNow();
291
292  if (this->dataTank->music != NULL)
293    this->dataTank->music->play();
294
295  while( this->bRunning) /* @todo implement pause */
296  {
297    /* process intput */
298    this->handleInput ();
299    if( !this->bRunning)
300      break;
301
302    /* network synchronisation */
303    this->synchronize ();
304    /* process time */
305    this->tick ();
306
307
308    /* update the state */
309    //this->update (); /// LESS REDUNDANCY.
310    PNode::getNullParent()->updateNode(this->dtS);
311
312
313    /* collision detection */
314    this->collisionDetection ();
315    /* collision reaction */
316    this->collisionReaction ();
317
318    /* check the game rules */
319    this->checkGameRules();
320
321    /* update the state */
322    this->update ();
323    /* draw everything */
324    this->display ();
325
326  }
327
328  PRINTF(0)("GameWorld::mainLoop() - Exiting the main loop\n");
329}
330
331
332void GameWorld::setPlaymode(Playable::Playmode playmode)
333{
334  if (this->dataTank->localPlayer &&
335      this->dataTank->localPlayer->getPlayable() &&
336      this->dataTank->localPlayer->getPlayable()->setPlaymode(playmode))
337  {
338    PRINTF(3)("Set Playmode to %d:%s\n", playmode, Playable::playmodeToString(playmode).c_str());
339  }
340  else
341  {
342    PRINTF(1)("Unable to set Playmode %d:'%s'\n", playmode, Playable::playmodeToString(playmode).c_str());
343  }
344}
345
346void GameWorld::setPlaymode(const std::string& playmode)
347{
348  this->setPlaymode(Playable::stringToPlaymode(playmode));
349}
350
351/**
352 *  synchronize local data with remote data
353*/
354void GameWorld::synchronize ()
355{}
356
357
358/**
359 *  run all input processing
360
361   the command node is the central input event dispatcher. the node uses the even-queue from
362   sdl and has its own event-passing-queue.
363*/
364void GameWorld::handleInput ()
365{
366  EventHandler::getInstance()->process();
367}
368
369
370/**
371 * @brief ticks a WorldEntity list
372 * @param entityList list of the WorldEntities
373 * @param dt time passed since last frame
374 */
375void GameWorld::tick(ObjectManager::EntityList entityList, float dt)
376{
377  ObjectManager::EntityList::iterator entity, next;
378  next = entityList.begin();
379  while (next != entityList.end())
380  {
381    entity = next++;
382    (*entity)->tick(dt);
383  }
384}
385
386
387/**
388 *  advance the timeline
389 *
390 * this calculates the time used to process one frame (with all input handling, drawing, etc)
391 * the time is mesured in ms and passed to all world-entities and other classes that need
392 * a heart-beat.
393 */
394void GameWorld::tick ()
395{
396  if( !this->bPaused)
397  {
398    // CALCULATE FRAMERATE
399    Uint32 frameTimesIndex;
400    Uint32 i;
401    double currentFrame = Timer::getNow();
402
403    frameTimesIndex = this->cycle % TICK_SMOOTH_VALUE;
404    this->frameTimes[frameTimesIndex] = currentFrame - this->lastFrame;
405    this->lastFrame = currentFrame;
406    ++this->cycle;
407    this->dtS = 0.0;
408    for (i = 0; i < TICK_SMOOTH_VALUE; i++)
409      this->dtS += this->frameTimes[i];
410    this->dtS = this->dtS / TICK_SMOOTH_VALUE * speed;
411
412    // TICK everything
413    for (i = 0; i < this->dataTank->tickLists.size(); ++i)
414      this->tick(this->dataTank->objectManager->getObjectList(this->dataTank->tickLists[i]), this->dtS);
415
416    /* update tick the rest */
417    this->dataTank->localCamera->tick(this->dtS);
418    AnimationPlayer::getInstance()->tick(this->dtS);
419    PhysicsEngine::getInstance()->tick(this->dtS);
420
421    GraphicsEngine::getInstance()->tick(this->dtS);
422    AtmosphericEngine::getInstance()->tick(this->dtS);
423
424    if( likely(this->dataTank->gameRule != NULL))
425      this->dataTank->gameRule->tick(this->dtS);
426
427  }
428}
429
430
431/**
432 *  this function gives the world a consistant state
433 *
434 * after ticking (updating the world state) this will give a constistant
435 * state to the whole system.
436 */
437void GameWorld::update()
438{
439  PNode::getNullParent()->updateNode (this->dtS);
440  OrxSound::SoundEngine::getInstance()->update();
441
442  this->applyCameraSettings();
443  GraphicsEngine::getInstance()->update(this->dtS);
444}
445
446
447/**
448 * kicks the CDEngine to detect the collisions between the object groups in the world
449 */
450void GameWorld::collisionDetection()
451{
452  // object-object collision detection
453  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
454      this->dataTank->objectManager->getObjectList(OM_GROUP_01_PROJ));
455  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_01),
456      this->dataTank->objectManager->getObjectList(OM_GROUP_00_PROJ));
457  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
458      this->dataTank->objectManager->getObjectList(OM_GROUP_01));
459
460  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
461      this->dataTank->objectManager->getObjectList(OM_COMMON));
462  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_01),
463      this->dataTank->objectManager->getObjectList(OM_COMMON));
464
465  // ground collision detection: BSP Model
466  CDEngine::getInstance()->checkCollisionGround(this->dataTank->objectManager->getObjectList(OM_GROUP_00));
467  CDEngine::getInstance()->checkCollisionGround(this->dataTank->objectManager->getObjectList(OM_GROUP_01));
468}
469
470
471void GameWorld::collisionReaction()
472{
473  CREngine::getInstance()->handleCollisions();
474}
475
476
477/**
478 *  check the game rules: winning conditions, etc.
479 *
480 */
481void GameWorld::checkGameRules()
482{
483  if( this->gameRules)
484    this->gameRules->tick(this->dtS);
485}
486
487
488/**
489 *  render the current frame
490 *
491 * clear all buffers and draw the world
492 */
493void GameWorld::display ()
494{
495  // render the reflection texture
496  this->renderPassReflection();
497  // redner the refraction texture
498  this->renderPassRefraction();
499  // render all
500  this->renderPassAll();
501
502  // flip buffers
503  GraphicsEngine::swapBuffers();
504}
505
506
507/**
508 * @brief draws all entities in the list drawList
509 * @param drawList the List of entities to draw.
510 */
511void GameWorld::drawEntityList(const ObjectManager::EntityList& drawList) const
512{
513  ObjectManager::EntityList::const_iterator entity;
514  for (entity = drawList.begin(); entity != drawList.end(); entity++)
515    if ((*entity)->isVisible())
516      (*entity)->draw();
517}
518
519
520void GameWorld::applyCameraSettings()
521{
522  this->dataTank->localCamera->apply ();
523  this->dataTank->localCamera->project ();
524  GraphicsEngine::storeMatrices();
525}
526
527
528
529/**
530 * reflection rendering for water surfaces
531 */
532void GameWorld::renderPassReflection()
533{
534    // clear buffer
535  glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
536//  glLoadIdentity();
537
538  const std::list<BaseObject*>* reflectedWaters;
539  MappedWater* mw;
540
541  if( (reflectedWaters = ClassList::getList(CL_MAPPED_WATER)) != NULL)
542  {
543    std::list<BaseObject*>::const_iterator it;
544    for (it = reflectedWaters->begin(); it != reflectedWaters->end(); it++)
545    {
546      mw =  dynamic_cast<MappedWater*>(*it);
547
548      //camera and light
549      //this->dataTank->localCamera->apply ();
550      //this->dataTank->localCamera->project ();
551
552      LightManager::getInstance()->draw();
553
554
555      // prepare for reflection rendering
556      mw->activateReflection();
557
558      // draw everything to be included in the reflection
559      this->drawEntityList(State::getObjectManager()->getReflectionList());
560//       for (unsigned int i = 0; i < this->dataTank->drawLists.size(); ++i)
561//         this->drawEntityList(State::getObjectManager()->getObjectList(this->dataTank->drawLists[i]));
562
563      // clean up from reflection rendering
564      mw->deactivateReflection();
565    }
566  }
567
568}
569
570
571/**
572 *  refraction rendering for water surfaces
573 */
574void GameWorld::renderPassRefraction()
575{
576    // clear buffer
577  glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
578  //glLoadIdentity();
579
580  const std::list<BaseObject*>* reflectedWaters;
581  MappedWater* mw;
582
583  if( (reflectedWaters = ClassList::getList(CL_MAPPED_WATER)) != NULL)
584  {
585    std::list<BaseObject*>::const_iterator it;
586    for (it = reflectedWaters->begin(); it != reflectedWaters->end(); it++)
587    {
588      mw =  dynamic_cast<MappedWater*>(*it);
589
590      //camera and light
591      //this->dataTank->localCamera->apply ();
592      //this->dataTank->localCamera->project ();
593      // prepare for reflection rendering
594      mw->activateRefraction();
595
596
597      LightManager::getInstance()->draw();
598      // draw everything to be included in the reflection
599      this->drawEntityList(State::getObjectManager()->getReflectionList());
600//       for (unsigned int i = 0; i < this->dataTank->drawLists.size(); ++i)
601//         this->drawEntityList(State::getObjectManager()->getObjectList(this->dataTank->drawLists[i]));
602
603      // clean up from reflection rendering
604      mw->deactivateRefraction();
605    }
606  }
607}
608
609
610/**
611 *  this render pass renders the whole wolrd
612 */
613void GameWorld::renderPassAll()
614{
615  // clear buffer
616  glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
617  GraphicsEngine* engine = GraphicsEngine::getInstance();
618
619
620  // glEnable(GL_DEPTH_TEST);
621  // glEnable(GL_LIGHTING);
622
623  // set Lighting
624  LightManager::getInstance()->draw();
625
626  /* Draw the BackGround */
627  this->drawEntityList(State::getObjectManager()->getObjectList(OM_BACKGROUND));
628  engine->drawBackgroundElements();
629
630  /* draw all WorldEntiy groups */
631  for (unsigned int i = 0; i < this->dataTank->drawLists.size(); ++i)
632    this->drawEntityList(State::getObjectManager()->getObjectList(this->dataTank->drawLists[i]));
633
634  AtmosphericEngine::getInstance()->draw();
635
636  if( unlikely( this->showBV))
637  {
638    CDEngine* engine = CDEngine::getInstance();
639    for (unsigned int i = 0; i < this->dataTank->drawLists.size(); ++i)
640      engine->drawBV(State::getObjectManager()->getObjectList(this->dataTank->drawLists[i]), this->showBVLevel);
641  }
642
643  if( unlikely(this->showPNodes))
644    PNode::getNullParent()->debugDraw(0);
645
646  engine->draw();
647
648  // draw the game ruls
649  if( likely(this->dataTank->gameRule != NULL))
650    this->dataTank->gameRule->draw();
651}
652
653
654/**
655 *  shows the loading screen
656 */
657void GameWorld::displayLoadScreen ()
658{
659  PRINTF(3)("GameWorld::displayLoadScreen - start\n");
660  this->dataTank->glmis = new GLMenuImageScreen();
661  this->dataTank->glmis->setMaximum(8);
662  PRINTF(3)("GameWorld::displayLoadScreen - end\n");
663}
664
665
666/**
667 *  removes the loadscreen, and changes over to the game
668 */
669void GameWorld::releaseLoadScreen ()
670{
671  PRINTF(3)("GameWorld::releaseLoadScreen - start\n");
672  this->dataTank->glmis->setValue(this->dataTank->glmis->getMaximum());
673  PRINTF(3)("GameWorld::releaseLoadScreen - end\n");
674}
675
676
677
678/**
679 * @brief toggles the PNode visibility in the world (drawn as boxes)
680 */
681void GameWorld::togglePNodeVisibility()
682{
683  this->showPNodes = !this->showPNodes;
684};
685
686
687/**
688 * @brief toggles the bounding volume (BV) visibility
689*/
690void GameWorld::toggleBVVisibility(int level)
691{
692  if( level < 1)
693    this->showBV = false;
694  else
695  {
696    this->showBV = true;
697    this->showBVLevel = level;
698  }
699
700};
701
Note: See TracBrowser for help on using the repository browser.