Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/world_entities/world_entity.cc @ 10356

Last change on this file since 10356 was 10314, checked in by patrick, 18 years ago

merged branche mount_point to trunk. this will add mount point abilities, bsp transparency fix and some other smaller stuff to this trunk

File size: 23.1 KB
Line 
1
2
3/*
4   orxonox - the future of 3D-vertical-scrollers
5
6   Copyright (C) 2004 orx
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2, or (at your option)
11   any later version.
12
13   ### File Specific:
14   main-programmer: Patrick Boenzli
15   main-programmer: Benjamin Grauer
16   co-programmer:   Christian Meier
17*/
18#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
19
20#include "world_entity.h"
21#include "shell_command.h"
22
23#include "util/loading/resource_manager.h"
24#include "resource_obj.h"
25#include "md2/md2Model.h"
26#include "md3/md3_model.h"
27
28#include "oif/object_information_file.h"
29#include "mount_point.h"
30
31#include "aabb_tree_node.h"
32
33#include "util/loading/load_param.h"
34#include "obb_tree.h"
35
36#include "elements/glgui_energywidget.h"
37
38#include "state.h"
39#include "camera.h"
40
41#include "collision_filter.h"
42#include "collision_event.h"
43#include "game_rules.h"
44#include "kill.h"
45#include "debug.h"
46
47#include "projectiles/projectile.h"
48
49SHELL_COMMAND(model, WorldEntity, loadModel)
50->describe("sets the Model of the WorldEntity")
51->defaultValues("models/ships/fighter.obj", 1.0f);
52
53SHELL_COMMAND(debugEntity, WorldEntity, debugWE);
54
55
56ObjectListDefinition(WorldEntity);
57/**
58 *  Loads the WordEntity-specific Part of any derived Class
59 *
60 * @param root: Normally NULL, as the Derived Entities define a loadParams Function themeselves,
61 *              that can calls WorldEntities loadParams for itself.
62 */
63WorldEntity::WorldEntity()
64  : Synchronizeable(), _collisionFilter(this)
65{
66  this->registerObject(this, WorldEntity::_objectList);
67
68  this->obbTree = NULL;
69  this->aabbNode = NULL;
70  this->healthWidget = NULL;
71  this->healthMax = 1.0f;
72  this->health = 1.0f;
73  this->damage = 0.0f; // no damage dealt by a default entity
74  this->scaling = 1.0f;
75  this->oiFile = NULL;
76  // add 10 members to this array
77  this->mountPoints.reserve(10);
78
79  /* OSOLETE */
80  this->bVisible = true;
81  this->bCollide = true;
82
83  this->objectListNumber = OM_INIT;
84  this->lastObjectListNumber = OM_INIT;
85
86  this->_bOnGround = false;
87
88  // registering default reactions:
89  this->subscribeReaction(CoRe::CREngine::CR_OBJECT_DAMAGE, Projectile::staticClassID());
90
91  this->toList(OM_NULL);
92
93  this->registerVar( new SynchronizeableString( &this->md2TextureFileName, &this->md2TextureFileName, "md2TextureFileName", PERMISSION_MASTER_SERVER ) );
94  this->modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName", PERMISSION_MASTER_SERVER ) );
95  this->scaling_handle = registerVarId( new SynchronizeableFloat( &scaling, &scaling, "scaling", PERMISSION_MASTER_SERVER ) );
96  this->list_handle = registerVarId( new SynchronizeableInt( (int*)&objectListNumber, &list_write, "list", PERMISSION_MASTER_SERVER ) );
97
98  this->health_handle = registerVarId( new SynchronizeableFloat( &this->health, &this->health_write, "health", PERMISSION_MASTER_SERVER ) );
99  this->healthMax_handle = registerVarId( new SynchronizeableFloat( &this->healthMax, &this->healthMax_write, "maxHealth", PERMISSION_MASTER_SERVER ) );
100}
101
102/**
103 *  standard destructor
104*/
105WorldEntity::~WorldEntity ()
106{
107  State::getObjectManager()->toList(this, OM_INIT);
108
109  // Delete the model (unregister it with the ResourceManager)
110  for (unsigned int i = 0; i < this->models.size(); i++)
111    this->setModel(NULL, i);
112
113  // remove the object information file
114  if( this->oiFile)
115    delete this->oiFile;
116  // and clear all monut points
117  this->mountPoints.clear();
118
119  // Delete the obbTree
120  if( this->obbTree != NULL)
121    delete this->obbTree;
122
123  if (this->healthWidget != NULL)
124    delete this->healthWidget;
125
126  this->unsubscribeReactions();
127}
128
129/**
130 * loads the WorldEntity Specific Parameters.
131 * @param root: the XML-Element to load the Data From
132 */
133void WorldEntity::loadParams(const TiXmlElement* root)
134{
135  // Do the PNode loading stuff
136  PNode::loadParams(root);
137
138  LoadParam(root, "md2texture", this, WorldEntity, loadMD2Texture)
139  .describe("the fileName of the texture, that should be loaded onto this world-entity. (must be relative to the data-dir)")
140  .defaultValues("");
141
142  // Model Loading
143  LoadParam(root, "model", this, WorldEntity, loadModel)
144  .describe("the fileName of the model, that should be loaded onto this world-entity. (must be relative to the data-dir)")
145  .defaultValues("", 1.0f, 0);
146
147  LoadParam(root, "mountpoints", this, WorldEntity, loadMountPoints)
148  .describe("the fileName of the object information file (optional)");
149
150  LoadParam(root, "maxHealth", this, WorldEntity, setHealthMax)
151  .describe("The Maximum health that can be loaded onto this entity")
152  .defaultValues(1.0f);
153
154  LoadParam(root, "health", this, WorldEntity, setHealth)
155  .describe("The Health the WorldEntity has at this moment")
156  .defaultValues(1.0f);
157
158  LoadParam(root, "list", this, WorldEntity, toListS);
159}
160
161
162/**
163 * loads a Model onto a WorldEntity
164 * @param fileName the name of the model to load
165 * @param scaling the Scaling of the model
166 *
167 * FIXME
168 * @todo: separate the obb tree generation from the model
169 */
170void WorldEntity::loadModel(const std::string& fileName, float scaling, unsigned int modelNumber, unsigned int obbTreeDepth)
171{
172  this->modelLODName = fileName;
173  this->scaling = scaling;
174
175  std::string name = fileName;
176
177  if (  name.find( Resources::ResourceManager::getInstance()->mainGlobalPath().name() ) == 0 )
178  {
179    name.erase(Resources::ResourceManager::getInstance()->mainGlobalPath().name().size());
180  }
181
182  this->modelFileName = name;
183
184  if (!fileName.empty())
185  {
186    // search for the special character # in the LoadParam
187    if (fileName.find('#') != std::string::npos)
188    {
189      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName.c_str());
190      std::string lodFile = fileName;
191      unsigned int offset = lodFile.find('#');
192      for (unsigned int i = 0; i < 3; i++)
193      {
194        lodFile[offset] = 48+(int)i;
195        if (Resources::ResourceManager::getInstance()->checkFileInMainPath( lodFile))
196          this->loadModel(lodFile, scaling, i);
197      }
198      return;
199    }
200    if (this->scaling <= 0.0)
201    {
202      PRINTF(1)("YOU GAVE ME A CRAPY SCALE resetting to 1.0\n");
203      this->scaling = 1.0;
204    }
205    /// LOADING AN OBJ FILE
206    if(fileName.find(".obj") != std::string::npos)
207    {
208      PRINTF(4)("fetching OBJ file: %s\n", fileName.c_str());
209      // creating the model and loading it
210      StaticModel* model = new StaticModel();
211      *model = ResourceOBJ(fileName, this->scaling);
212
213      // check if ther is a valid model and load other stuff
214      if (model->getVertexCount() > 0)
215      {
216        this->setModel(model, modelNumber);
217
218        if( modelNumber == 0)
219        {
220          this->buildObbTree(obbTreeDepth);
221        }
222      }
223      else
224        delete model;
225    }
226    /// LOADING AN MD2-model
227    else if(fileName.find(".md2") != std::string::npos)
228    {
229      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
230      Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
231      //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);
232      this->setModel(m, 0);
233
234      if( m != NULL)
235        this->buildObbTree(obbTreeDepth);
236    }
237    /// LOADING AN MD3-MODEL.
238    else if(fileName.find(".md3") != std::string::npos)
239    {
240      PRINTF(4)("fetching MD3 file: %s\n", fileName.c_str());
241//      Model* m = new md3::MD3Model(fileName, this->scaling);
242//      this->setModel(m, 0);
243
244      //       if( m != NULL)
245      //         this->buildObbTree(obbTreeDepth);
246    }
247  }
248  else
249  {
250    this->setModel(NULL);
251  }
252}
253
254/**
255 * sets a specific Model for the Object.
256 * @param model The Model to set
257 * @param modelNumber the n'th model in the List to get.
258 */
259void WorldEntity::setModel(Model* model, unsigned int modelNumber)
260{
261  if (this->models.size() <= modelNumber)
262    this->models.resize(modelNumber+1, NULL);
263
264  if (this->models[modelNumber] != NULL)
265  {
266    delete this->models[modelNumber];
267  }
268
269  this->models[modelNumber] = model;
270}
271
272
273
274/**
275 * loads the object information file for this model
276 * @param fileName the name of the file
277 */
278void WorldEntity::loadMountPoints(const std::string& fileName)
279{
280  PRINTF(5)("loading the oif File: %s\n", fileName.c_str());
281
282  // now load the object information file
283  this->oiFile = new ObjectInformationFile(fileName);
284
285  // get the model to load
286  Model* model = this->getModel();
287
288  // extract the mount points
289  model->extractMountPoints();
290
291  // first get all mount points from the model
292  const std::list<mountPointSkeleton> mpList = model->getMountPoints();
293  // for each skeleton create a mounting point world entity
294  std::list<mountPointSkeleton>::const_iterator it = mpList.begin();
295
296  for( ; it != mpList.end(); it++)
297  {
298    // create the mount points world entity
299    MountPoint* mp = new MountPoint( (*it).up, (*it).forward, (*it).center, (*it).name);
300    // parent it to this WE
301    mp->setParent( this);
302    // now add to the right group
303    mp->toList( (OM_LIST)(this->getOMListNumber()+1));
304    // now get the number and add the mount point to the slot
305    std::string nrStr = (*it).name.substr(3, 2);
306    // add the mount point
307    this->addMountPoint(atoi(nrStr.c_str()), mp);
308
309    // now fill the mount point
310    mp->initMountPoint( this->oiFile->getMountPointDescription());
311  }
312
313}
314
315
316/**
317 * builds the obb-tree
318 * @param depth the depth to calculate
319 */
320bool WorldEntity::buildObbTree(int depth)
321{
322  if( this->obbTree != NULL)
323  {
324    delete this->obbTree;
325    this->obbTree = NULL;
326  }
327
328  if (this->models[0] != NULL)
329    this->obbTree = new OBBTree(depth, models[0]->getModelInfo(), this);
330  else
331  {
332    PRINTF(1)("could not create obb-tree, because no model was loaded yet\n");
333    this->obbTree = NULL;
334    return false;
335  }
336
337
338  // create the axis aligned bounding box
339  if( this->aabbNode != NULL)
340  {
341    delete this->aabbNode;
342    this->aabbNode = NULL;
343  }
344
345  if( this->models[0] != NULL)
346  {
347    this->aabbNode = new AABBTreeNode();
348    this->aabbNode->spawnBVTree(this->models[0]);
349  }
350  else
351  {
352    PRINTF(1)("could not create aabb bounding box, because no model was loaded yet\n");
353    this->aabbNode = NULL;
354    return false;
355  }
356  return true;
357}
358
359
360/**
361 * adds a mount point to the end of the list
362 * @param mountPoint point to be added
363 */
364void WorldEntity::addMountPoint(MountPoint* mountPoint)
365{
366  // add the mount point at the last position
367  this->mountPoints.push_back(mountPoint);
368}
369
370/**
371 * adds a mount point to a world entity
372 * @param mountPoint point to be added
373 */
374void WorldEntity::addMountPoint(int slot, MountPoint* mountPoint)
375{
376  if( this->mountPoints.capacity() < (unsigned int)slot)
377  {
378    // reserve 5 more slots than needed so this function is called as rare as possible
379    this->mountPoints.reserve(slot + 5);
380  }
381  else if( this->mountPoints[slot] != NULL)
382  {
383    PRINTF(4)("adding a mount point to a slot, that already is occupied! ignoring - maybe some object did not get connected well (object: %s)\n", this->getClassCName());
384  }
385
386  // just connect the mount point
387  this->mountPoints[slot] = mountPoint;
388}
389
390
391/**
392 * mounts a world entity on a specified mount point (~socket)
393 * @param entity entity to be connected
394 */
395void WorldEntity::mount(int slot, WorldEntity* entity)
396{
397  if( this->mountPoints[slot] == NULL)
398  {
399    PRINTF(0)("you tried to add an entity to a mount point that doesn't exist (slot %i)\n", slot);
400    return;
401  }
402
403  // mount the entity
404  this->mountPoints[slot]->mount(entity);
405}
406
407
408/**
409 * removes a mount point from a specified mount point
410 * @param mountPoint entity to be unconnected
411 */
412void WorldEntity::unmount(int slot)
413{
414    if( this->mountPoints[slot] == NULL)
415  {
416    PRINTF(0)("you tried to remove an entity from a mount point that doesn't exist (slot %i)\n", slot);
417    return;
418  }
419
420  // unmount the entity
421  this->mountPoints[slot]->unmount();
422}
423
424
425/**
426 * subscribes this world entity to a collision reaction
427 *  @param type the type of reaction to subscribe to
428 *  @param target1 a filter target (classID)
429 */
430void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1)
431{
432  this->_collisionFilter.subscribeReaction(type, target1);
433}
434
435
436/**
437 * subscribes this world entity to a collision reaction
438 *  @param type the type of reaction to subscribe to
439 *  @param target1 a filter target (classID)
440 */
441void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1, const ClassID& target2)
442{
443  this->_collisionFilter.subscribeReaction(type, target1, target2);
444}
445
446
447/**
448 * subscribes this world entity to a collision reaction
449 *  @param type the type of reaction to subscribe to
450 *  @param target1 a filter target (classID)
451 */
452void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1, const ClassID& target2, const ClassID& target3)
453{
454  this->_collisionFilter.subscribeReaction(type, target1, target2, target3);
455}
456
457
458/**
459 * unsubscribes a specific reaction from the worldentity
460 *  @param type the reaction to unsubscribe
461 */
462void WorldEntity::unsubscribeReaction(CoRe::CREngine::ReactionType type)
463{
464  this->_collisionFilter.unsubscribeReaction(type);
465}
466
467
468/**
469 * unsubscribes all collision reactions
470 */
471void WorldEntity::unsubscribeReactions()
472{
473  this->_collisionFilter.unsubscribeReactions();
474}
475
476
477/**
478 * @brief moves this entity to the List OM_List
479 * @param list the list to set this Entity to.
480 *
481 * this is the same as a call to State::getObjectManager()->toList(entity , list);
482 * directly, but with an easier interface.
483 *
484 * @todo inline this (peut etre)
485 */
486void WorldEntity::toList(OM_LIST list)
487{
488  State::getObjectManager()->toList(this, list);
489}
490
491void WorldEntity::toListS(const std::string& listName)
492{
493  OM_LIST id = ObjectManager::StringToOMList(listName);
494  if (id != OM_NULL)
495    this->toList(id);
496  else
497    PRINTF(2)("List %s not found\n", listName.c_str());
498}
499
500
501void WorldEntity::toReflectionList()
502{
503  State::getObjectManager()->toReflectionList( this );
504}
505
506void removeFromReflectionList()
507{
508  /// TODO
509  ///  State::getObject
510}
511
512/**
513 * sets the character attributes of a worldentity
514 * @param character attributes
515 *
516 * these attributes don't have to be set, only use them, if you need them
517*/
518//void WorldEntity::setCharacterAttributes(CharacterAttributes* charAttr)
519//{}
520
521
522/**
523 *  this function is called, when two entities collide
524 * @param entity: the world entity with whom it collides
525 *
526 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
527 */
528void WorldEntity::collidesWith(WorldEntity* entity, const Vector& location)
529{
530  /**
531   * THIS IS A DEFAULT COLLISION-Effect.
532   * IF YOU WANT TO CREATE A SPECIFIC COLLISION ON EACH OBJECT
533   * USE::
534   * if (entity->isA(CL_WHAT_YOU_ARE_LOOKING_FOR)) { printf "dothings"; };
535   *
536   * You can always define a default Action.... don't be affraid just test it :)
537   */
538  //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassCName(), entity->getClassCName(), location.x, location.y, location.z);
539}
540
541
542/**
543 *  this function is called, when two entities collide
544 * @param entity: the world entity with whom it collides
545 *
546 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
547 */
548void WorldEntity::collidesWithGround(const Vector& location)
549{
550  PRINTF(0)("BSP_GROUND: %s collides \n", this->getClassCName() );
551}
552
553void WorldEntity::collidesWithGround(const Vector& feet, const Vector& ray_1, const Vector& ray_2)
554{
555
556  // PRINTF(0)("BSP_GROUND: Player collides \n", this->getClassCName() );
557
558  Vector v = this->getAbsDirX();
559  v.x *= 10.1;
560  v.y *= 10.1;
561  v.z *= 10.1;
562  Vector u = Vector(0.0,-20.0,0.0);
563
564
565  if(!(this->getAbsCoor().x == ray_2.x && this->getAbsCoor().y == ray_2.y && this->getAbsCoor().z == ray_2.z) )
566  {
567
568    this->setAbsCoor(ray_2 - v);
569
570  }
571  else
572  {
573    if(ray_1.x == this->getAbsCoor().x + v.x && ray_1.y == this->getAbsCoor().y + v.y + 0.1 && ray_1.z ==this->getAbsCoor().z + v.z)
574    {
575      this->setAbsCoor(feet -u );
576    }
577
578    this->setAbsCoor(ray_2 - v);
579
580  }
581
582
583}
584
585/**
586 *  this is called immediately after the Entity has been constructed, initialized and then Spawned into the World
587 *
588 */
589void WorldEntity::postSpawn ()
590{}
591
592
593/**
594 *  this method is called by the world if the WorldEntity leaves the game
595 */
596void WorldEntity::leaveWorld ()
597{}
598
599
600/**
601 * resets the WorldEntity to its initial values. eg. used for multiplayer games: respawning
602 */
603void WorldEntity::reset()
604{
605  this->setHealth( this->getHealthMax() );
606}
607
608/**
609 *  this method is called every frame
610 * @param time: the time in seconds that has passed since the last tick
611 *
612 * Handle all stuff that should update with time inside this method (movement, animation, etc.)
613*/
614void WorldEntity::tick(float time)
615{}
616
617
618/**
619 *  the entity is drawn onto the screen with this function
620 *
621 * This is a central function of an entity: call it to let the entity painted to the screen.
622 * Just override this function with whatever you want to be drawn.
623*/
624void WorldEntity::draw() const
625{
626  //PRINTF(0)("(%s::%s)\n", this->getClassCName(), this->getName());
627  //  assert(!unlikely(this->models.empty()));
628  {
629    glMatrixMode(GL_MODELVIEW);
630    glPushMatrix();
631
632    /* translate */
633    glTranslatef (this->getAbsCoor ().x,
634                  this->getAbsCoor ().y,
635                  this->getAbsCoor ().z);
636    Vector tmpRot = this->getAbsDir().getSpacialAxis();
637    glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
638
639
640    // This Draws the LOD's
641    float cameraDistance = State::getCamera()->distance(this);
642    if (cameraDistance > 30 && this->models.size() >= 3 && this->models[2] != NULL)
643    {
644      this->models[2]->draw();
645    }
646    else if (cameraDistance > 10 && this->models.size() >= 2 && this->models[1] != NULL)
647    {
648      this->models[1]->draw();
649    }
650    else if (this->models.size() >= 1 && this->models[0] != NULL)
651    {
652      this->models[0]->draw();
653    }
654
655    //     if( this->aabbNode != NULL)
656    //       this->aabbNode->drawBV(0, DRAW_BV_POLYGON, Vector(1, 0.6, 0.2), true);
657
658    glPopMatrix();
659  }
660}
661
662/**
663 * @param health the Health to add.
664 * @returns the health left (this->healthMax - health+this->health)
665 */
666float WorldEntity::increaseHealth(float health)
667{
668  this->health += health;
669  if (this->health > this->healthMax)
670  {
671    float retHealth = this->healthMax - this->health;
672    this->health = this->healthMax;
673    this->updateHealthWidget();
674    return retHealth;
675  }
676  this->updateHealthWidget();
677  return 0.0;
678}
679
680/**
681 * @param health the Health to be removed
682 * @returns 0.0 or the rest, that was not substracted (bellow 0.0)
683 */
684float WorldEntity::decreaseHealth(float health)
685{
686  this->health -= health;
687
688  if (this->health < 0)
689  {
690    float retHealth = -this->health;
691    this->health = 0.0f;
692    this->updateHealthWidget();
693    return retHealth;
694  }
695  this->updateHealthWidget();
696  return 0.0;
697
698}
699
700/**
701 * @param maxHealth the maximal health that can be loaded onto the entity.
702 */
703void WorldEntity::setHealthMax(float healthMax)
704{
705  this->healthMax = healthMax;
706  if (this->health > this->healthMax)
707  {
708    PRINTF(3)("new maxHealth is bigger as the old health. Did you really intend to do this for (%s::%s)\n", this->getClassCName(), this->getCName());
709    this->health = this->healthMax;
710  }
711  this->updateHealthWidget();
712}
713
714/**
715 * @brief creates the HealthWidget
716 *
717 * since not all entities need an HealthWidget, it is only created on request.
718 */
719void WorldEntity::createHealthWidget()
720{
721  if (this->healthWidget == NULL)
722  {
723    this->healthWidget = new OrxGui::GLGuiEnergyWidget();
724    this->healthWidget->setDisplayedName(std::string(this->getClassName()) + " Energy:");
725    this->healthWidget->setSize2D(30,400);
726    this->healthWidget->setAbsCoor2D(10,100);
727
728    this->updateHealthWidget();
729  }
730  else
731    PRINTF(3)("Allready created the HealthWidget for %s::%s\n", this->getClassCName(), this->getCName());
732}
733
734void WorldEntity::increaseHealthMax(float increaseHealth)
735{
736  this->healthMax += increaseHealth;
737  this->updateHealthWidget();
738}
739
740
741OrxGui::GLGuiWidget* WorldEntity::getHealthWidget()
742{
743  this->createHealthWidget();
744  return this->healthWidget;
745}
746
747/**
748 * @param visibility shows or hides the health-bar
749 * (creates the widget if needed)
750 */
751void WorldEntity::setHealthWidgetVisibilit(bool visibility)
752{
753  if (visibility)
754  {
755    if (this->healthWidget != NULL)
756      this->healthWidget->show();
757    else
758    {
759      this->createHealthWidget();
760      this->updateHealthWidget();
761      this->healthWidget->show();
762    }
763  }
764  else if (this->healthWidget != NULL)
765    this->healthWidget->hide();
766}
767
768
769/**
770 * hit the world entity with
771 *  @param damage damage to be dealt
772 */
773void WorldEntity::hit(float damage, WorldEntity* killer)
774{
775  this->decreaseHealth(damage);
776
777  PRINTF(5)("Hit me: %s::%s now only %f/%f health\n", this->getClassCName(), this->getCName(), this->getHealth(), this->getHealthMax());
778
779  if( this->getHealth() > 0)
780  {
781    // any small explosion animaitions
782  }
783  else
784  {
785    this->destroy( killer );
786  }
787}
788
789
790/**
791 * destoys the world entity
792 */
793void WorldEntity::destroy(WorldEntity* killer)
794{
795  this->toList(OM_DEAD);
796}
797
798
799/**
800 * @brief updates the HealthWidget
801 */
802void WorldEntity::updateHealthWidget()
803{
804  if (this->healthWidget != NULL)
805  {
806    this->healthWidget->setMaximum(this->healthMax);
807    this->healthWidget->setValue(this->health);
808  }
809}
810
811
812/**
813 * DEBUG-DRAW OF THE BV-Tree.
814 * @param depth What depth to draw
815 * @param drawMode the mode to draw this entity under
816 */
817void WorldEntity::drawBVTree(int depth, int drawMode) const
818{
819  glMatrixMode(GL_MODELVIEW);
820  glPushMatrix();
821  /* translate */
822  glTranslatef (this->getAbsCoor ().x,
823                this->getAbsCoor ().y,
824                this->getAbsCoor ().z);
825  /* rotate */
826  Vector tmpRot = this->getAbsDir().getSpacialAxis();
827  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
828
829
830  if (this->obbTree)
831    this->obbTree->drawBV(depth, drawMode);
832
833
834  glPopMatrix();
835}
836
837
838
839/**
840 * draw the mounting points
841 */
842void WorldEntity::debugDrawMountPoints() const
843{
844
845  std::vector<MountPoint*>::const_iterator it = this->mountPoints.begin();
846  for( ; it < this->mountPoints.end(); it++)
847  {
848    if( (*it) != NULL)
849    {
850      (*it)->debugDraw();
851    }
852  }
853}
854
855
856/**
857 * Debug the WorldEntity
858 */
859void WorldEntity::debugEntity() const
860{
861  PRINT(0)("WorldEntity %s::%s  (DEBUG)\n", this->getClassCName(), this->getCName());
862  this->debugNode();
863  PRINT(0)("List: %s ; ModelCount %d - ", ObjectManager::OMListToString(this->objectListNumber).c_str(), this->models.size());
864  for (unsigned int i = 0; i < this->models.size(); i++)
865  {
866    if (models[i] != NULL)
867      PRINT(0)(" : %d:%s", i, this->models[i]->getCName());
868  }
869  PRINT(0)("\n");
870
871}
872
873
874/**
875 * handler for changes on registred vars
876 * @param id id's which changed
877 */
878void WorldEntity::varChangeHandler( std::list< int > & id )
879{
880  if ( std::find( id.begin(), id.end(), modelFileName_handle ) != id.end() ||
881       std::find( id.begin(), id.end(), scaling_handle ) != id.end()
882     )
883  {
884    loadModel( modelFileName, scaling );
885  }
886
887  if ( std::find( id.begin(), id.end(), list_handle ) != id.end() )
888  {
889    this->toList( (OM_LIST)list_write );
890  }
891
892  if ( std::find( id.begin(), id.end(), health_handle ) != id.end() )
893  {
894    this->setHealth( health_write );
895  }
896
897  if ( std::find( id.begin(), id.end(), healthMax_handle ) != id.end() )
898  {
899    this->setHealthMax( healthMax_write );
900  }
901
902  PNode::varChangeHandler( id );
903}
904
Note: See TracBrowser for help on using the repository browser.