Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 7707 was 7230, checked in by bensch, 19 years ago

orxonox/trunk: merged the std::branche back

File size: 15.3 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   co-programmer: Christian Meyer
16*/
17#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
18
19#include "world_entity.h"
20#include "shell_command.h"
21
22#include "model.h"
23#include "md2Model.h"
24#include "util/loading/resource_manager.h"
25#include "util/loading/load_param.h"
26#include "vector.h"
27#include "obb_tree.h"
28
29#include "glgui_bar.h"
30
31#include "state.h"
32#include "camera.h"
33
34using namespace std;
35
36SHELL_COMMAND(model, WorldEntity, loadModel)
37->describe("sets the Model of the WorldEntity")
38->defaultValues("models/ships/fighter.obj", 1.0);
39
40SHELL_COMMAND(debugEntity, WorldEntity, debugWE);
41
42/**
43 *  Loads the WordEntity-specific Part of any derived Class
44 *
45 * @param root: Normally NULL, as the Derived Entities define a loadParams Function themeselves,
46 *              that can calls WorldEntities loadParams for itself.
47 */
48WorldEntity::WorldEntity()
49    : Synchronizeable()
50{
51  this->setClassID(CL_WORLD_ENTITY, "WorldEntity");
52
53  this->obbTree = NULL;
54  this->healthWidget = NULL;
55  this->healthMax = 1.0f;
56  this->health = 1.0f;
57  this->scaling = 1.0f;
58
59  /* OSOLETE */
60  this->bVisible = true;
61  this->bCollide = true;
62
63  this->objectListNumber = OM_INIT;
64  this->objectListIterator = NULL;
65
66  this->toList(OM_NULL);
67}
68
69/**
70 *  standard destructor
71*/
72WorldEntity::~WorldEntity ()
73{
74  State::getObjectManager()->toList(this, OM_INIT);
75
76  // Delete the model (unregister it with the ResourceManager)
77  for (unsigned int i = 0; i < this->models.size(); i++)
78    this->setModel(NULL, i);
79
80  // Delete the obbTree
81  if( this->obbTree != NULL)
82    delete this->obbTree;
83
84  if (this->healthWidget != NULL)
85    delete this->healthWidget;
86}
87
88/**
89 * loads the WorldEntity Specific Parameters.
90 * @param root: the XML-Element to load the Data From
91 */
92void WorldEntity::loadParams(const TiXmlElement* root)
93{
94  // Do the PNode loading stuff
95  PNode::loadParams(root);
96
97  LoadParam(root, "md2texture", this, WorldEntity, loadMD2Texture)
98  .describe("the fileName of the texture, that should be loaded onto this world-entity. (must be relative to the data-dir)")
99  .defaultValues("");
100
101  // Model Loading
102  LoadParam(root, "model", this, WorldEntity, loadModel)
103  .describe("the fileName of the model, that should be loaded onto this world-entity. (must be relative to the data-dir)")
104  .defaultValues("", 1.0f, 0);
105
106  LoadParam(root, "maxHealth", this, WorldEntity, setHealthMax)
107  .describe("The Maximum health that can be loaded onto this entity")
108  .defaultValues(1.0f);
109
110  LoadParam(root, "health", this, WorldEntity, setHealth)
111  .describe("The Health the WorldEntity has at this moment")
112  .defaultValues(1.0f);
113}
114
115
116/**
117 * loads a Model onto a WorldEntity
118 * @param fileName the name of the model to load
119 * @param scaling the Scaling of the model
120 */
121void WorldEntity::loadModel(const std::string& fileName, float scaling, unsigned int modelNumber)
122{
123  this->modelLODName = fileName;
124  this->scaling = scaling;
125  if (!fileName.empty())
126  {
127    // search for the special character # in the LoadParam
128    if (fileName.find('#') != std::string::npos)
129    {
130      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName.c_str());
131      std::string lodFile = fileName;
132      unsigned int offset = lodFile.find('#');
133      for (unsigned int i = 0; i < 3; i++)
134      {
135        lodFile[offset] = 48+(int)i;
136        if (ResourceManager::isInDataDir(lodFile))
137          this->loadModel(lodFile, scaling, i);
138      }
139      return;
140    }
141    if (this->scaling <= 0.0)
142    {
143      PRINTF(1)("YOU GAVE ME A CRAPY SCALE resetting to 1.0\n");
144      this->scaling = 1.0;
145    }
146    if(fileName.find(".obj") != std::string::npos)
147    {
148      PRINTF(4)("fetching OBJ file: %s\n", fileName.c_str());
149      BaseObject* loadedModel = ResourceManager::getInstance()->load(fileName, OBJ, RP_CAMPAIGN, this->scaling);
150      if (loadedModel != NULL)
151        this->setModel(dynamic_cast<Model*>(loadedModel), modelNumber);
152      else
153        PRINTF(1)("OBJ-File %s not found.\n", fileName.c_str());
154
155      if( modelNumber == 0)
156        this->buildObbTree(4);
157    }
158    else if(fileName.find(".md2") != std::string::npos)
159    {
160      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
161      Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
162      //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);
163      this->setModel(m, 0);
164
165      if( m != NULL)
166        this->buildObbTree(4);
167    }
168  }
169  else
170  {
171    this->setModel(NULL);
172  }
173}
174
175/**
176 * sets a specific Model for the Object.
177 * @param model The Model to set
178 * @param modelNumber the n'th model in the List to get.
179 */
180void WorldEntity::setModel(Model* model, unsigned int modelNumber)
181{
182  if (this->models.size() <= modelNumber)
183    this->models.resize(modelNumber+1, NULL);
184
185  if (this->models[modelNumber] != NULL)
186  {
187    Resource* resource = ResourceManager::getInstance()->locateResourceByPointer(dynamic_cast<BaseObject*>(this->models[modelNumber]));
188    if (resource != NULL)
189      ResourceManager::getInstance()->unload(resource, RP_LEVEL);
190    else
191    {
192      PRINTF(4)("Forcing model deletion\n");
193      delete this->models[modelNumber];
194    }
195  }
196
197  this->models[modelNumber] = model;
198
199
200  //   if (this->model != NULL)
201  //     this->buildObbTree(4);
202}
203
204
205/**
206 * builds the obb-tree
207 * @param depth the depth to calculate
208 */
209bool WorldEntity::buildObbTree(unsigned int depth)
210{
211  if (this->obbTree)
212    delete this->obbTree;
213
214  if (this->models[0] != NULL)
215  {
216    PRINTF(4)("creating obb tree\n");
217
218
219    this->obbTree = new OBBTree(depth, (sVec3D*)this->models[0]->getVertexArray(), this->models[0]->getVertexCount());
220    return true;
221  }
222  else
223  {
224    PRINTF(2)("could not create obb-tree, because no model was loaded yet\n");
225    this->obbTree = NULL;
226    return false;
227  }
228}
229
230/**
231 * @brief moves this entity to the List OM_List
232 * @param list the list to set this Entity to.
233 *
234 * this is the same as a call to State::getObjectManager()->toList(entity , list);
235 * directly, but with an easier interface.
236 *
237 * @todo inline this (peut etre)
238 */
239void WorldEntity::toList(OM_LIST list)
240{
241  State::getObjectManager()->toList(this, list);
242}
243
244
245
246/**
247 * sets the character attributes of a worldentity
248 * @param character attributes
249 *
250 * these attributes don't have to be set, only use them, if you need them
251*/
252//void WorldEntity::setCharacterAttributes(CharacterAttributes* charAttr)
253//{}
254
255
256/**
257 *  this function is called, when two entities collide
258 * @param entity: the world entity with whom it collides
259 *
260 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
261 */
262void WorldEntity::collidesWith(WorldEntity* entity, const Vector& location)
263{
264  /**
265   * THIS IS A DEFAULT COLLISION-Effect.
266   * IF YOU WANT TO CREATE A SPECIFIC COLLISION ON EACH OBJECT
267   * USE::
268   * if (entity->isA(CL_WHAT_YOU_ARE_LOOKING_FOR)) { printf "dothings"; };
269   *
270   * You can always define a default Action.... don't be affraid just test it :)
271   */
272  //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
273}
274
275
276/**
277 *  this is called immediately after the Entity has been constructed, initialized and then Spawned into the World
278 *
279 */
280void WorldEntity::postSpawn ()
281{}
282
283
284/**
285 *  this method is called by the world if the WorldEntity leaves the game
286 */
287void WorldEntity::leaveWorld ()
288{}
289
290
291/**
292 * resets the WorldEntity to its initial values. eg. used for multiplayer games: respawning
293 */
294void WorldEntity::reset()
295{}
296
297/**
298 *  this method is called every frame
299 * @param time: the time in seconds that has passed since the last tick
300 *
301 * Handle all stuff that should update with time inside this method (movement, animation, etc.)
302*/
303void WorldEntity::tick(float time)
304{}
305
306
307/**
308 *  the entity is drawn onto the screen with this function
309 *
310 * This is a central function of an entity: call it to let the entity painted to the screen.
311 * Just override this function with whatever you want to be drawn.
312*/
313void WorldEntity::draw() const
314{
315  //PRINTF(0)("(%s::%s)\n", this->getClassName(), this->getName());
316  //  assert(!unlikely(this->models.empty()));
317  {
318    glMatrixMode(GL_MODELVIEW);
319    glPushMatrix();
320
321    /* translate */
322    glTranslatef (this->getAbsCoor ().x,
323                  this->getAbsCoor ().y,
324                  this->getAbsCoor ().z);
325    Vector tmpRot = this->getAbsDir().getSpacialAxis();
326    glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
327
328
329    // This Draws the LOD's
330    float cameraDistance = State::getCamera()->distance(this);
331    if (cameraDistance > 30 && this->models.size() >= 3 && this->models[2] != NULL)
332    {
333      this->models[2]->draw();
334    }
335    else if (cameraDistance > 10 && this->models.size() >= 2 && this->models[1] != NULL)
336    {
337      this->models[1]->draw();
338    }
339    else if (this->models.size() >= 1 && this->models[0] != NULL)
340    {
341      this->models[0]->draw();
342    }
343    glPopMatrix();
344  }
345}
346
347/**
348 * @param health the Health to add.
349 * @returns the health left (this->healthMax - health+this->health)
350 */
351float WorldEntity::increaseHealth(float health)
352{
353  this->health += health;
354  if (this->health > this->healthMax)
355  {
356    float retHealth = this->healthMax - this->health;
357    this->health = this->healthMax;
358    this->updateHealthWidget();
359    return retHealth;
360  }
361  this->updateHealthWidget();
362  return 0.0;
363}
364
365/**
366 * @param health the Health to be removed
367 * @returns 0.0 or the rest, that was not substracted (bellow 0.0)
368 */
369float WorldEntity::decreaseHealth(float health)
370{
371  this->health -= health;
372
373  if (this->health < 0)
374  {
375    float retHealth = -this->health;
376    this->health = 0.0f;
377    this->updateHealthWidget();
378    return retHealth;
379  }
380  this->updateHealthWidget();
381  return 0.0;
382
383}
384
385/**
386 * @param maxHealth the maximal health that can be loaded onto the entity.
387 */
388void WorldEntity::setHealthMax(float healthMax)
389{
390  this->healthMax = healthMax;
391  if (this->health > this->healthMax)
392  {
393    PRINTF(3)("new maxHealth is bigger as the old health. Did you really intend to do this for (%s::%s)\n", this->getClassName(), this->getName());
394    this->health = this->healthMax;
395  }
396  this->updateHealthWidget();
397}
398
399/**
400 * @brief creates the HealthWidget
401 *
402 * since not all entities need an HealthWidget, it is only created on request.
403 */
404void WorldEntity::createHealthWidget()
405{
406  if (this->healthWidget == NULL)
407  {
408    this->healthWidget = new GLGuiBar();
409    this->healthWidget->setSize2D(30,400);
410    this->healthWidget->setAbsCoor2D(10,100);
411
412    this->updateHealthWidget();
413  }
414  else
415    PRINTF(3)("Allready created the HealthWidget for %s::%s\n", this->getClassName(), this->getName());
416}
417
418void WorldEntity::increaseHealthMax(float increaseHealth)
419{
420  this->healthMax += increaseHealth;
421  this->updateHealthWidget();
422}
423
424
425GLGuiWidget* WorldEntity::getHealthWidget()
426{
427  this->createHealthWidget();
428  return this->healthWidget;
429}
430
431/**
432 * @param visibility shows or hides the health-bar
433 * (creates the widget if needed)
434 */
435void WorldEntity::setHealthWidgetVisibilit(bool visibility)
436{
437  if (visibility)
438  {
439    if (this->healthWidget != NULL)
440      this->healthWidget->show();
441    else
442    {
443      this->createHealthWidget();
444      this->updateHealthWidget();
445      this->healthWidget->show();
446    }
447  }
448  else if (this->healthWidget != NULL)
449    this->healthWidget->hide();
450}
451
452/**
453 * @brief updates the HealthWidget
454 */
455void WorldEntity::updateHealthWidget()
456{
457  if (this->healthWidget != NULL)
458  {
459    this->healthWidget->setMaximum(this->healthMax);
460    this->healthWidget->setValue(this->health);
461  }
462}
463
464
465/**
466 * DEBUG-DRAW OF THE BV-Tree.
467 * @param depth What depth to draw
468 * @param drawMode the mode to draw this entity under
469 */
470void WorldEntity::drawBVTree(unsigned int depth, int drawMode) const
471{
472  glMatrixMode(GL_MODELVIEW);
473  glPushMatrix();
474  /* translate */
475  glTranslatef (this->getAbsCoor ().x,
476                this->getAbsCoor ().y,
477                this->getAbsCoor ().z);
478  /* rotate */
479  Vector tmpRot = this->getAbsDir().getSpacialAxis();
480  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
481
482  if (this->obbTree)
483    this->obbTree->drawBV(depth, drawMode);
484  glPopMatrix();
485}
486
487
488/**
489 * Debug the WorldEntity
490 */
491void WorldEntity::debugEntity() const
492{
493  PRINT(0)("WorldEntity %s::%s  (DEBUG)\n", this->getClassName(), this->getName());
494  this->debugNode();
495  PRINT(0)("List: %s ; ModelCount %d - ", ObjectManager::OMListToString(this->objectListNumber) , this->models.size());
496  for (unsigned int i = 0; i < this->models.size(); i++)
497  {
498    if (models[i] != NULL)
499      PRINT(0)(" : %d:%s", i, this->models[i]->getName());
500  }
501  PRINT(0)("\n");
502
503}
504
505
506
507
508/********************************************************************************************
509 NETWORK STUFF
510 ********************************************************************************************/
511
512
513/**
514 * Writes data from network containing information about the state
515 * @param data pointer to data
516 * @param length length of data
517 * @param sender hostID of sender
518 */
519int WorldEntity::writeState( const byte * data, int length, int sender )
520{
521  std::string modelFileName;
522  SYNCHELP_READ_BEGIN();
523
524  SYNCHELP_READ_FKT( PNode::writeState, NWT_WE_PN_WRITESTATE );
525
526  SYNCHELP_READ_STRING( modelFileName, NWT_WE_PN_MODELFILENAME );
527  SYNCHELP_READ_FLOAT( scaling, NWT_WE_PN_SCALING );
528  //check if modelFileName is relative to datadir or absolute
529
530
531  PRINTF(0)("================ LOADING MODEL %s, %f\n", modelFileName.c_str(), scaling);
532
533  if ( modelFileName != "" )
534  {
535    loadModel( modelFileName, scaling);
536    PRINTF(0)("modelfilename: %s\n", getModel( 0 )->getName());
537  }
538
539  /*SYNCHELP_READ_STRINGM( modelFileName );
540
541  if ( strcmp(modelFileName, "") )
542    if ( strstr(modelFileName, ResourceManager::getInstance()->getDataDir()) )
543    {
544      this->md2TextureFileName = new char[strlen(modelFileName)-strlen(ResourceManager::getInstance()->getDataDir())+1];
545      strcpy((char*)this->md2TextureFileName, modelFileName+strlen(ResourceManager::getInstance()->getDataDir()));
546    }
547    else
548    {
549      this->md2TextureFileName = modelFileName;
550    }
551  */
552
553  return SYNCHELP_READ_N;
554}
555
556
557/**
558 * data copied in data will bee sent to another host
559 * @param data pointer to data
560 * @param maxLength max length of data
561 * @return the number of bytes writen
562 */
563int WorldEntity::readState( byte * data, int maxLength )
564{
565  SYNCHELP_WRITE_BEGIN();
566
567  SYNCHELP_WRITE_FKT( PNode::readState, NWT_WE_PN_WRITESTATE );
568
569  if ( getModel(0) && getModel(0)->getName() != "" )
570  {
571    std::string name = getModel( 0 )->getName();
572
573    if (  name.find( ResourceManager::getInstance()->getDataDir() ) == 0 ) 
574    {
575      name.erase(ResourceManager::getInstance()->getDataDir().size());
576    }
577
578    SYNCHELP_WRITE_STRING( name, NWT_WE_PN_MODELFILENAME );
579  }
580  else
581  {
582    SYNCHELP_WRITE_STRING("", NWT_WE_PN_MODELFILENAME);
583  }
584
585  SYNCHELP_WRITE_FLOAT( scaling, NWT_WE_PN_SCALING );
586  /*if ( this->md2TextureFileName!=NULL && strcmp(this->md2TextureFileName, "") )
587  {
588    SYNCHELP_WRITE_STRING(this->md2TextureFileName);
589  }
590  else
591  {
592    SYNCHELP_WRITE_STRING("");
593  }*/
594
595  return SYNCHELP_WRITE_N;
596}
Note: See TracBrowser for help on using the repository browser.