Changeset 2190 in orxonox.OLD for orxonox/trunk/src/world_entity.cc

Timestamp:

Jul 17, 2004, 12:11:20 PM (21 years ago)

Author:

bensch

Message:

orxonox/trunk: merged and copied all files from branches/chris into trunk. it all seems to be in propper order.

File:

• orxonox/trunk/src/world_entity.cc (modified) (4 diffs)

orxonox/trunk/src/world_entity.cc

@@ -13 +13 @@
    ### File Specific:
    main-programmer: Patrick Boenzli
-   co-programmer: ...
+   co-programmer: Christian Meyer
 */
 
@@ -19 +19 @@
 
 #include "world_entity.h"
-
-#include "vector.h"
+#include "stdincl.h"
+#include "collision.h"
 
 using namespace std;
 
-
 /**
-   \brief 
-   \param v:
-   \return 
+   \brief standard constructor
+   
+   Every derived contructor HAS to call the previous one supplying the isFree parameter. This is necessary to distunguish
+   between free and bound entities. The difference between them is simply the fact that the movement of a free entity is
+   not bound to the track of a world. Use this to implement projectile or effect classes that do not have to travel along the track.
+   To specify an entity to be free or bound set the default parameter in the declaration of the constructor.
+   Theoretically you should never have to call the constructor of an Entity directly, for it is called by the spawn() function of the World
+   class. So if you want to create a new entity at any time, call World::spawn(). It will handle everything that is necessary.
 */
-
-/**
-   \brief Constructor
-
-   This Constructor initializises the all WorldEntities. Everything, that is a part of the game-world is a child of WorldEntity. This class implements empty functions for all sort of operation a WorldEntity has to or can implement.
-This is some sort of standard interface to all WorldEntities...
-*/
-WorldEntity::WorldEntity () 
+WorldEntity::WorldEntity (bool isFree) : bFree(isFree)
 {
-  health = 100;
-  speed = 0;
-}
-
-
-WorldEntity::~WorldEntity () {}
-
-/**
-   \brief sets the position of this entity
-   \param position: Vector, pointing (from 0,0,0) to the new position
-*/
-void WorldEntity::setPosition(Vector* position) {} 
-
-/**
-   \brief gets the postion of this entity
-   \return a Vector, pointing (from 0,0,0) to the new position
-*/
-Vector* getPosition() {}
-
-/**
-   \brief sets orientation of this entity
-   \param orientation: vector specifying in which direction the entity looks
-*/
-void WorldEntity::setOrientation(Vector* orientation) {}
-
-/**
-   \brief gets orientation of this entity
-   \return vector specifying in which direction the entity looks
-*/
-Vector* WorldEntity::getOrientation() {}
-
-/**
-   \brief sets the speed of the entity, if any
-   \param speed: the speed in points (openGL points) per seconds
-*/
-void WorldEntity::setSpeed(float speed)
-{
-  this->speed = speed;
+        collisioncluster = NULL;
+        owner = NULL;
 }
 
 /**
-   \brief gets the speed of the entity, if any
-   \return the speed in points (openGL points) per seconds
+        \brief standard destructor
 */
-float WorldEntity::getSpeed()
+WorldEntity::~WorldEntity ()
 {
-  return speed;
+        if( collisioncluster != NULL) delete collisioncluster;
 }
 
 /**
-   \brief sets the health of the entity
-   \param health: number for the life count, normaly {0..100}
+        \brief get the Location of the WorldEntity
+        \return a pointer to location
 */
-void WorldEntity::setHealth(float health)
+Location* WorldEntity::get_location ()
 {
-  this->health = health;
+        return &loc;
 }
 
 /**
-   \brief gets the health of the entity
-   \return number for the life count, normaly {0..100}
+        \brief get the Placement of the WorldEntity
+        \return a pointer to placement
 */
-float WorldEntity::getHealth()
+Placement* WorldEntity::get_placement ()
 {
-  return health;
+        return &place;
 }
 
 /**
-   \brief this method is called every tick
-   \param time: the time since the last frame was painted
-
-   This function is called before every repaint of the world, to update every time dependent variable of the entity. If the entity moves, it has to calculate the new position every tick here in this function. Do not use this for animations.
+        \brief query whether the WorldEntity in question is free
+        \return true if the WorldEntity is free or false if it isn't
 */
-void WorldEntity::tick(float dt) 
-{}
+bool WorldEntity::isFree ()
+{
+  return bFree;
+}
 
 /**
-   \brief the entity is painted to the screen with this function
+        \brief set the WorldEntity's collision hull
+        \param newhull: a pointer to a completely assembled CollisionCluster
+        
+        Any previously assigned collision hull will be deleted on reassignment
+*/
+void WorldEntity::set_collision (CollisionCluster* newhull)
+{
+        if( newhull == NULL) return;
+        if( collisioncluster != NULL) delete collisioncluster;
+        collisioncluster = newhull;
+}
+
+/**
+        \brief this method is called every frame
+        \param time: the time in seconds that has passed since the last tick
+        
+        Handle all stuff that should update with time inside this method (movement, animation, etc.)
+*/
+void WorldEntity::tick(float time) 
+{
+}
+
+/**
+   \brief the entity is drawn onto the screen with this function
 
    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::paint() 
-{}
+void WorldEntity::draw() 
+{
+}
 
-/* virtual void WorldEntity::actionEvent(Event* event); */
 /**
-   \brief this function is called, when two entities collide
-   \param we: the world entity, with whom it collides
-   \param loc: place where the collision happens
+        \brief this function is called, when two entities collide
+        \param other: the world entity with whom it collides
+        \param ownhitflags: flags to the CollisionCluster subsections that registered an impact
+        \param otherhitflags: flags to the CollisionCluster subsections of the other entity that registered an impact
+
+        Implement behaviour like damage application or other miscellaneous collision stuff in this function
 */
-void WorldEntity::collide(WorldEntity* we, Vector loc) {}
+void WorldEntity::collide(WorldEntity* other, Uint32 ownhitflags, Uint32 otherhitflags) {}
 
 /**
@@ -141 +127 @@
 
 /**
-   \brief this function is called, if the entity is to be destroied
+   \brief this function is called when the entity is to be destroied
    
    This can be called, if eg. something realy bad happens :)
@@ -147 +133 @@
 void WorldEntity::destroy() {}
 
-/**
-   \brief this function is automatically called before the entity enters the world
-*/
-void WorldEntity::entityPreEnter() {}
 
 /**
-   \brief this function is automatically called after the entity enters the world
-
+        \brief basic initialisation for bound Entities
 */
-void WorldEntity::entityPostEnter() {}
+void WorldEntity::init( Location* spawnloc, WorldEntity* spawnowner)
+{
+        loc = *spawnloc;
+        owner = spawnowner;
+}
 
 /**
-   \brief this function is automatically called before the entity quits the world
-
+        \brief basic initialisation for free Entities
 */
-void WorldEntity::entityPreQuit() {}
+void WorldEntity::init( Placement* spawnplc, WorldEntity* spawnowner)
+{
+        place = *spawnplc;
+        owner = spawnowner;
+}
 
 /**
-   \brief this function is automatically called after the entity quits the world
+        \brief this is called immediately after the Entity has been constructed and initialized
+        
+        Put any initialisation code that requires knowledge of location (placement if the Entity is free) and owner of the entity here.
+        DO NOT place such code in the constructor, those variables are set AFTER the entity is constucted.
 */
-void WorldEntity::entityPostQuit() {}
+void WorldEntity::post_spawn ()
+{
+}
+
+/**
+        \brief this handles incoming command messages
+        \param cmd: a pointer to the incoming Command structure
+        
+        Put all code that handles Command messages here, this will mainly be called by the assigned CommandNode but can also be used
+        to send commands from one WorldEntity to another.
+*/
+void WorldEntity::command (Command* cmd)
+{
+}
+
+/**
+        \brief this is called by the local Camera to determine the point it should look at on the WorldEntity
+        \param locbuf: a pointer to the buffer to fill with a location to look at
+        
+        You may put any Location you want into locbuf, the Camera will determine via the corresponding Track how
+        to look at the location you return with this.
+*/
+void WorldEntity::get_lookat (Location* locbuf)
+{
+}
+
+/**
+        \brief this method is called by the world if the WorldEntity leaves valid gamespace
+        
+        For free entities this means it left the Track boundaries. With bound entities it means its Location adresses a
+        place that is not in the world anymore. In both cases you might have to take extreme measures (a.k.a. call destroy).
+*/
+void WorldEntity::left_world ()
+{
+}