Changeset 3746 in orxonox.OLD for orxonox/branches/levelloader/src/world_entities

Timestamp:

Apr 7, 2005, 3:54:49 PM (20 years ago)

Author:

chris

Message:

orxonox/branches/levelloader: Merged trunk into branch… still not working though…

Location:

orxonox/branches/levelloader/src/world_entities

Files:

• environment.cc (modified) (2 diffs)
• player.cc (modified) (8 diffs)
• player.h (modified) (3 diffs)
• primitive.cc (deleted)
• primitive.h (deleted)
• projectile.cc (modified) (4 diffs)
• projectile.h (modified) (4 diffs)
• skysphere.cc (modified) (2 diffs)
• skysphere.h (modified) (1 diff)
• terrain.cc (modified) (2 diffs)
• test_bullet.cc (copied) (copied from orxonox/trunk/src/world_entities/test_bullet.cc)
• test_bullet.h (copied) (copied from orxonox/trunk/src/world_entities/test_bullet.h)
• test_gun.cc (copied) (copied from orxonox/trunk/src/world_entities/test_gun.cc)
• test_gun.h (copied) (copied from orxonox/trunk/src/world_entities/test_gun.h)
• weapon.cc (modified) (5 diffs)
• weapon.h (modified) (3 diffs)
• world_entity.cc (modified) (4 diffs)
• world_entity.h (modified) (2 diffs)

orxonox/branches/levelloader/src/world_entities/environment.cc

@@ -30 +30 @@
 Environment::Environment () : WorldEntity()
 {
-  this->model = new OBJModel("../data/models/fighter.obj");
+  this->model = (Model*) ResourceManager::getInstance()->load("cube", RP_LEVEL);
+  //  this->model = new OBJModel("../data/models/fighter.obj");
 }
 
@@ -54 +55 @@
         string = grabParameter( root, "model");
         if( string != NULL)
-                this->model = new OBJModel( string);
+        this->model = (Model*) ResourceManager::getInstance()->load( string, RP_LEVEL);
         else
         {
                 PRINTF0("Environment is missing a proper 'model'\n");
-                this->model = new OBJModel( "../data/models/reaplow.obj");
+        this->model = (Model*) ResourceManager::getInstance()->load( "cube", RP_LEVEL);
         }
         if( this->model == NULL)

orxonox/branches/levelloader/src/world_entities/player.cc

@@ -20 +20 @@
 #include "player.h"
 
+#include "track_manager.h"
+#include "objModel.h"
+#include "resource_manager.h"
+#include "weapon.h"
+#include "test_gun.h"
+#include "world.h"
+
+#include "list.h"
 #include "stdincl.h"
-//#include "collision.h"
-#include "objModel.h"
-#include "list.h"
-#include "weapon.h"
-#include "track_manager.h"
 
 using namespace std;
@@ -35 +38 @@
    \param isFree if the player is free
 */
-Player::Player(bool isFree) : WorldEntity(isFree)
-{
-  this->model = new OBJModel("../data/models/reaplow.obj");
+Player::Player() : WorldEntity()
+{
   this->weapons = new tList<Weapon>();
   this->activeWeapon = NULL;
-
+  /*
+    this is the debug player - actualy we would have to make a new
+     class derivated from Player for each player. for now, we just use
+     the player.cc for debug also
+  */
+  this->model = (Model*)ResourceManager::getInstance()->load("models/reaplow.obj", OBJ, RP_CAMPAIGN);
   travelSpeed = 15.0;
-  velocity = Vector();
+  velocity = new Vector();
   bUp = bDown = bLeft = bRight = bAscend = bDescend = false;
   bFire = false;
   acceleration = 10.0;
+  //weapons:
+  Weapon* wp = new TestGun(this, new Vector(-1.1, 0.0, 2.6), new Quaternion());
+  this->weapons->add(wp);
+  this->activeWeapon = wp;  
 }
 
@@ -53 +64 @@
 Player::~Player ()
 {
-  Weapon* w = this->weapons->enumerate(); 
-  while( w != NULL) 
-    { 
-      delete w;
-      w = this->weapons->nextElement();
-    }
+  /* do not delete the weapons, they are contained in the pnode tree
+     and will be deleted there.
+     this only frees the memory allocated to save the list.
+  */
   delete this->weapons;
-  
-  //delete this->velocity;
 }
 
@@ -94 +101 @@
         string = grabParameter( root, "model");
         if( string != NULL)
-                this->model = new OBJModel( string);
+        this->model = (Model*)ResourceManager::getInstance()->load(string, OBJ, RP_CAMPAIGN);
         else
         {
                 PRINTF0("Player is missing a proper 'model'\n");
-                this->model = new OBJModel( "../data/models/reaplow.obj");
+        this->model = (Model*)ResourceManager::getInstance()->load("models/reaplow.obj", OBJ, RP_CAMPAIGN);
         }
         if( this->model == NULL)
@@ -104 +111 @@
                 PRINTF0("Player model '%s' could not be loaded\n", string);
         }
+        
+        this->weapons = new tList<Weapon>();
+  this->activeWeapon = NULL;
+  /*
+    this is the debug player - actualy we would have to make a new
+     class derivated from Player for each player. for now, we just use
+     the player.cc for debug also
+  */
+  travelSpeed = 15.0;
+  velocity = new Vector();
+  bUp = bDown = bLeft = bRight = bAscend = bDescend = false;
+  bFire = false;
+  acceleration = 10.0;
+  //weapons:
+  Weapon* wp = new TestGun(this, new Vector(-1.1, 0.0, 2.6), new Quaternion());
+  this->weapons->add(wp);
+  this->activeWeapon = wp; 
 }
 
@@ -192 +216 @@
 void Player::tick (float time)
 {
+  /* link tick to weapon */
+  this->activeWeapon->tick(time);
   // player controlled movement
-  this->move (time);
+  this->move(time);
   // weapon system manipulation
-  this->fire();
+  this->weapon();
 }
 
@@ -214 +240 @@
   //orthDirection = orthDirection.cross (direction);
 
-  if( this->bUp && this->getRelCoor().x < 20)
+  if( this->bUp && this->getRelCoor()->x < 20)
     accel = accel+(direction*acceleration);
-  if( this->bDown && this->getRelCoor().x > -5)
+  if( this->bDown && this->getRelCoor()->x > -5)
     accel = accel-(direction*acceleration);
-  if( this->bLeft &&  TrackManager::getInstance()->getWidth() > -this->getRelCoor().z*2)
+  if( this->bLeft &&  TrackManager::getInstance()->getWidth() > -this->getRelCoor()->z*2)
     accel = accel - (orthDirection*acceleration); 
-  if( this->bRight &&  TrackManager::getInstance()->getWidth() > this->getRelCoor().z*2)
+  if( this->bRight &&  TrackManager::getInstance()->getWidth() > this->getRelCoor()->z*2)
     accel = accel + (orthDirection*acceleration);
   if( this->bAscend )
@@ -233 +259 @@
    \brief weapon manipulation by the player
 */
-void Player::fire()
-{
-  if(this->bFire)
+void Player::weapon()
+{
+  if( this->bFire)
     {
       if(this->activeWeapon != NULL)
         this->activeWeapon->fire();
     }
-  if(this->bWeaponChange)
+  if( this->bWeaponChange && this->weapons->getSize() > 1)
     {
-      Weapon* w = this->weapons->enumerate(); 
+      PRINTF(1)("changing the weapon of the player: deactivate old, activate new\n");
+      this->activeWeapon->deactivate();
+      //this->weapons->enumerate();  FIX: strang weapon change...
       this->activeWeapon = this->weapons->nextElement(this->activeWeapon);
+      this->activeWeapon->activate();
     }
 }

orxonox/branches/levelloader/src/world_entities/player.h

@@ -10 +10 @@
 
 template<class T> class tList;
-class OBJModel;
 class Weapon;
+class Vector;
+class World;
 
 //! Basic controllable WorldEntity
@@ -19 +20 @@
   
  public:
-  Player(bool isFree = false);
+  Player();
   Player(TiXmlElement* root);
   virtual ~Player();
@@ -48 +49 @@
   tList<Weapon>* weapons;//!< a list of weapon
   Weapon* activeWeapon;  //!< the weapon that is currenty activated
+  World* myWorld;        //!< reference to the world object
 
-  Vector velocity;       //!< the velocity of the player.
+  Vector* velocity;       //!< the velocity of the player.
   float travelSpeed;     //!< the current speed of the player (to make soft movement)
   float acceleration;    //!< the acceleration of the player.
   
   void move(float time);
-  void fire(void);
+  void weapon(void);
   
 };

orxonox/branches/levelloader/src/world_entities/projectile.cc

@@ -18 +18 @@
 
 #include "projectile.h"
-#include "stdincl.h"
+
 #include "world_entity.h"
+#include "weapon.h"
+#include "null_parent.h"
+#include "model.h"
 #include "vector.h"
-#include "objModel.h"
 
 using namespace std;
@@ -29 +31 @@
    \brief standard constructor
 */
-Projectile::Projectile () : WorldEntity()
+Projectile::Projectile (Weapon* weapon) : WorldEntity()
 {
-  this->model = new OBJModel("");
+  this->model = (Model*)ResourceManager::getInstance()->load("sphere", PRIM, RP_LEVEL);
+  this->weapon = weapon;
+  this->flightDirection = NULL;
+  this->currentLifeTime = 0.0f;
+  this->ttl = 0.75f; /* sec */
+  this->speed = 2.0f;
 }
 
@@ -40 +47 @@
 Projectile::~Projectile () 
 {
-
+  /* 
+     do not delete the test projectModel, since it is pnode 
+     and will be cleaned out by world 
+  */
+  //delete this->projectileModel;
 }
 
+
+/**
+   \brief this sets the flight direction of the projectile
+   \param directin in which to flight
+
+   this function will calculate a vector out of this to be used in the
+   tick function
+*/
+void Projectile::setFlightDirection(Quaternion flightDirection)
+{
+  if( this->flightDirection == NULL)
+    this->flightDirection = new Vector();
+  Vector v(1, 0, 0);
+  *this->flightDirection = flightDirection.apply(v);
+  this->flightDirection->normalize();
+}
+
+
+/**
+   \brief this sets the time to life of the projectile
+   \param ttl in second
+
+   after this life time, the projectile will garbage collect itself
+*/
+void Projectile::setTTL(float ttl)
+{
+  this->ttl = ttl;
+}
+
+
+/**
+   \brief sets the speed of the projectile
+*/
+void Projectile::setSpeed(float speed)
+{
+  this->speed = speed * 3; /* fix speed settings */
+  PRINTF(4)("Projectile::setting speed to: %f\n", this->speed);
+}
 
 /**
@@ -49 +98 @@
 */
 void Projectile::tick (float time) 
-{}
+{
+  Vector v = *this->flightDirection * ( this->speed * time * 1000 + 0.7);
+  this->shiftCoor(v);
+
+  this->currentLifeTime += time;
+  if( this->ttl < this->currentLifeTime)
+    {
+      PRINTF(5)("FINALIZE==========================\n");
+      PRINTF(5)("current life time is: %f/%f\n", this->currentLifeTime, this->ttl);
+      PRINTF(5)("FINALIZE===========================\n");
+      this->finalize();
+      this->currentLifeTime = 0.0f;
+    }
+}
 
 /**

orxonox/branches/levelloader/src/world_entities/projectile.h

@@ -2 +2 @@
     \projectile.h
     \brief a projectile, that is been shooted by a weapon
+
+    You can use this class to make some shoots, but this isn't the real idea. If you want to just test, if the
+    shooting funcions work, use the Projectile class. But if you want to implement your own shoots its 
+    different:<br>
+    Make a new class and derive it from Projectile. To have a weapon work well, reimplement the functions
+    - void tick()
+    - void draw()
+    - void hit() (only if you have working collision detection)
+    When you have implemented these functions you have just to add the projectiles to your weapon. You ll want 
+    to make this by looking into the function 
+    - Weapon::fire()
+    there you just change the line:
+    Projectile* pj = new Projectile();    TO     Projectile* pj = new MyOwnProjectileClass();
+    and schwups it works... :)
 */
 
@@ -9 +23 @@
 #include "world_entity.h"
 
+class Vector;
+class Weapon;
 
 class Projectile : public WorldEntity 
@@ -15 +31 @@
 
  public:
-  Projectile ();
+  Projectile (Weapon* weapon);
   virtual ~Projectile ();
+
+  void setFlightDirection(Quaternion flightDirection);
+  void setSpeed(float speed);
+  void setTTL(float ttl);
 
   virtual void hit (WorldEntity* weapon, Vector* loc);
@@ -24 +44 @@
   virtual void draw ();
 
- private:
+ protected:
   //physical attriutes like: force, speed, acceleration etc.
-
+  float speed;                         //!< this is the speed of the projectile
+  float currentLifeTime;               //!< this is the time, the projectile exists in this world (incremented by tick)
+  float ttl;                           //!< time to life, after this time, the projectile will garbage collect itself
+  Vector* flightDirection;             //!< direction in which the shoot flights
+  Weapon* weapon;                      //!< weapon the shoot belongs to
+  
 };
 

orxonox/branches/levelloader/src/world_entities/skysphere.cc

@@ -26 +26 @@
 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
 
-#include "material.h"
+
 #include "skysphere.h"
 #include "stdincl.h"
+
+#include "material.h"
 #include "vector.h"
-#include "world_entity.h"
+//#include "world_entity.h"
+
 
 using namespace std;
@@ -100 +103 @@
   glPushMatrix();
   glMatrixMode(GL_MODELVIEW);
-  glTranslatef(this->absCoordinate.x,
-               this->absCoordinate.y,
-               this->absCoordinate.z);
+  Vector r = this->getAbsCoor();
+  glTranslatef(r.x, r.y, r.z);
 
   //glRotatef(-30, 1, 0, 0);

orxonox/branches/levelloader/src/world_entities/skysphere.h

@@ -14 +14 @@
 
 /* INCLUDES */
-#include "p_node.h"
 #include "world_entity.h"
 

orxonox/branches/levelloader/src/world_entities/terrain.cc

@@ -16 +16 @@
 
 #include "terrain.h"
-
+#include "stdincl.h"
+#include "model.h"
+#include "vector.h"
 #include "glincl.h"
 
@@ -43 +45 @@
   if (strstr(fileName, ".obj") || strstr(fileName, ".OBJ"))
     {
-      this->model = (OBJModel*)new OBJModel(fileName);
+      this->model = (Model*)ResourceManager::getInstance()->load(fileName, OBJ, RP_LEVEL);
     }
   else

orxonox/branches/levelloader/src/world_entities/weapon.cc

@@ -21 +21 @@
 #include "world_entity.h"
 #include "vector.h"
-#include "objModel.h"
+#include "model.h"
 #include "projectile.h"
+#include "list.h"
+#include "world.h"
 
 using namespace std;
@@ -32 +34 @@
    creates a new weapon
 */
-Weapon::Weapon () : WorldEntity()
-{}
+Weapon::Weapon (PNode* parent, Vector* coordinate, Quaternion* direction) 
+  : WorldEntity()
+{
+  parent->addChild(this, PNODE_ROTATE_AND_MOVE);
+  this->setRelCoor(coordinate);
+  this->setRelDir(direction);
+  WorldInterface* wi = WorldInterface::getInstance();
+  this->worldEntities = wi->getEntityList();
+}
 
 
@@ -145 +154 @@
 */
 void Weapon::setWeaponIdleTime(float time)
-{}
+{
+  this->idleTime = time;
+}
 
 /**
@@ -155 +166 @@
 */
 float Weapon::getWeaponIdleTime(void)
-{}
+{
+  return this->idleTime;
+}
 
 /**
@@ -165 +178 @@
 */
 bool Weapon::hasWeaponIdleTimeElapsed(void)
-{}
+{
+  return (this->localTime>this->idleTime)?true:false;
+}
 
 

orxonox/branches/levelloader/src/world_entities/weapon.h

@@ -43 +43 @@
 
  public:
-  Weapon ();
+  Weapon (PNode* parent, Vector* coordinate, Quaternion* direction);
   virtual ~Weapon ();
   
@@ -57 +57 @@
   bool isActive(void);
 
-  virtual void setWeaponIdleTime(float time);
-  virtual float getWeaponIdleTime(void);
-  virtual bool hasWeaponIdleTimeElapsed(void);
+  void setWeaponIdleTime(float time);
+  float getWeaponIdleTime(void);
+  bool hasWeaponIdleTimeElapsed(void);
 
-  virtual void fire(void);
+  virtual void fire(void) = 0;
   virtual void hit (WorldEntity* weapon, Vector* loc);
   virtual void destroy(void);
@@ -69 +69 @@
   virtual void draw(void);
 
+ protected:
+  tList<WorldEntity>* worldEntities;
+  float localTime;
+  float idleTime;
+  float slowDownFactor;
 
  private:
   bool enabled;
-  float localTime;
-  float slowDownFactor;
   Projectile* projectile;
   //WeaponSound sound;
-
 };
 

orxonox/branches/levelloader/src/world_entities/world_entity.cc

@@ -19 +19 @@
 
 #include "world_entity.h"
-#include "stdincl.h"
+#include "objModel.h"
+#include "list.h"
+
+//#include "stdincl.h"
 //#include "collision.h"
 
@@ -48 +51 @@
 {
   // if( collisioncluster != NULL) delete collisioncluster;
-  delete this->model;
+  if (this->model)
+    ResourceManager::getInstance()->unload(this->model);
 }
 
@@ -167 +171 @@
    Handle all stuff that should update with time inside this method (movement, animation, etc.)
 */
-void WorldEntity::tick(float time) 
+inline void WorldEntity::tick(float time) 
 {
 }
@@ -177 +181 @@
    This is a central function of an entity: call it to let the entity painted to the screen. Just override this function with whatever you want to be drawn.
 */
-void WorldEntity::draw() 
+inline void WorldEntity::draw() 
 {}
 

orxonox/branches/levelloader/src/world_entities/world_entity.h

@@ -7 +7 @@
 #define _WORLD_ENTITY_H
 
-#include "stdincl.h"
 #include "p_node.h"
-#include "objModel.h"
+#include "comincl.h"
+#include "resource_manager.h"
+
 
 //class CollisionCluster;
 class CharacterAttributes;
+class Model;
 
 
@@ -48 +50 @@
   
  protected:
-  OBJModel* model;                  //!< The model that should be loaded for this entity.
+  Model* model;                  //!< The model that should be loaded for this entity.
   CharacterAttributes* charAttr;      //!< the character attributes of a world_entity