Changeset 8894 in orxonox.OLD for trunk

Timestamp:

Jun 29, 2006, 12:19:48 AM (18 years ago)

Author:

patrick

Message:

merged the branche single_player_map with the trunk

Location:

trunk/src

Files:

• defs/class_id.h (modified) (2 diffs)
• lib/collision_detection/cd_engine.cc (modified) (1 diff)
• lib/collision_reaction/collision_event.h (modified) (4 diffs)
• lib/collision_reaction/cr_defs.h (modified) (1 diff)
• lib/collision_reaction/cr_physics_ground_walk.cc (modified) (9 diffs)
• lib/collision_reaction/cr_physics_ground_walk.h (modified) (1 diff)
• lib/event/event_handler.cc (modified) (1 diff)
• lib/graphics/importer/bsp_file.cc (modified) (14 diffs)
• lib/graphics/importer/bsp_manager.cc (modified) (6 diffs)
• lib/graphics/importer/interactive_model.h (modified) (1 diff)
• lib/graphics/importer/md2/md2Model.cc (modified) (3 diffs)
• lib/graphics/importer/md2/md2Model.h (modified) (3 diffs)
• lib/math/quaternion.h (modified) (1 diff)
• lib/math/vector.h (modified) (1 diff)
• lib/script_engine/script_manager.h (modified) (1 diff)
• lib/shell/shell_command.cc (modified) (1 diff)
• lib/util/executor/executor.cc (modified) (4 diffs)
• lib/util/executor/executor.h (modified) (3 diffs)
• lib/util/executor/executor_functional.cc (modified) (1 diff)
• lib/util/executor/executor_lua.cc (modified) (1 diff)
• lib/util/executor/executor_lua.h (modified) (2 diffs)
• lib/util/executor/functor_list.h (modified) (1 diff)
• story_entities/game_world.cc (modified) (1 diff)
• story_entities/multi_player_world.cc (modified) (1 diff)
• world_entities/WorldEntities.am (modified) (4 diffs)
• world_entities/creatures/fps_player.cc (modified) (3 diffs)
• world_entities/door.cc (copied) (copied from branches/single_player_map/src/world_entities/door.cc)
• world_entities/door.h (copied) (copied from branches/single_player_map/src/world_entities/door.h)
• world_entities/npcs/generic_npc.cc (modified) (8 diffs)
• world_entities/npcs/generic_npc.h (modified) (3 diffs)
• world_entities/npcs/npc.cc (modified) (1 diff)
• world_entities/script_trigger.cc (modified) (8 diffs)
• world_entities/script_trigger.h (modified) (3 diffs)
• world_entities/weapons/fps_sniper_rifle.cc (copied) (copied from branches/single_player_map/src/world_entities/weapons/fps_sniper_rifle.cc)
• world_entities/weapons/fps_sniper_rifle.h (copied) (copied from branches/single_player_map/src/world_entities/weapons/fps_sniper_rifle.h)
• world_entities/world_entity.cc (modified) (4 diffs)
• world_entities/world_entity.h (modified) (3 diffs)

trunk/src/defs/class_id.h

@@ -187 +187 @@
   CL_BSP_ENTITY                 =    0x00000312,
   CL_SKYDOME                    =    0x00000313,
+  CL_DOOR                       =    0x00000314,
 
   // Playables
@@ -212 +213 @@
   CL_TARGETING_TURRET           =    0x000003a4,
   CL_HYPERBLASTER               =    0x000003a5,
+  CL_FPS_SNIPER_RIFLE           =    0x000003a6,
+  CL_FPS_LASER_RIFLE            =    0x000003a7,
 
   // Projectiles

trunk/src/lib/collision_detection/cd_engine.cc

@@ -84 +84 @@
         if( likely((*entity2) != this->terrain))
         {
-          PRINTF(4)("checking object %s against %s\n", (*entity1)->getName(), (*entity2)->getName());
+          PRINTF(5)("checking object %s (%s) against %s (%s)\n", (*entity1)->getClassName(), (*entity1)->getName(), (*entity2)->getClassName(), (*entity2)->getName());
           tree = (*entity1)->getOBBTree();
           if( likely(tree != NULL) && (*entity2)->getOBBTree() != NULL)

trunk/src/lib/collision_reaction/collision_event.h

@@ -9 +9 @@
 #include "vector.h"
 
+#include "cr_defs.h"
+
+
 class WorldEntity;
 class BoundingVolume;
 class Plane;
+
 
 
@@ -22 +26 @@
 
   /** collides two WorldEntities @param entityA world entity A, @param entityB world entity B, @param bvA volume A @param bvB volumeB */
-  inline void collide(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
-  { this->entityA = entityA; this->entityB = entityB; this->bvA = bvA; this->bvB = bvB; }
+  inline void collide(int type, WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
+  { this->collisionType = type; this->entityA = entityA; this->entityB = entityB; this->bvA = bvA; this->bvB = bvB; }
   /** collides two WorldEntities @param entity world entity , @param ground ground plane, @param position position on the ground */
-  inline void collide(WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position)
-  { this->entityA = entity; this->entityB = groundEntity, this->groundNormal = normal; this->position = position; }
+  inline void collide(int type, WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position, bool bInWall)
+  { this->collisionType = type; this->entityA = entity; this->entityB = groundEntity, this->groundNormal = normal; this->position = position; this->bInWall = bInWall; }
 
 
@@ -44 +48 @@
   inline Vector getCollisionPosition() { return this->position; }
 
+  /** @return the type of the collision */
+  inline int getType() { return this->collisionType; }
+
+  /** @return true if the entity is in the wall */
+  inline bool isInWall() { return this->bInWall; }
+
+
  private:
   WorldEntity*      entityA;                       //!< the collision body A
@@ -53 +64 @@
   Vector            groundNormal;                  //!< the ground plane with which it collides (only for bsp-model collisions
   Vector            position;                      //!< position of the collision on the ground plane
+
+  bool              bInWall;                       //!< true if is in wall
+  int               collisionType;                 //!< collision type
 };
 

trunk/src/lib/collision_reaction/cr_defs.h

@@ -28 +28 @@
 
 
+//!< the collision axis x collision event
+#define COLLISION_TYPE_AXIS_X   1
+//!< the collision axis y collision event
+#define COLLISION_TYPE_AXIS_Y   2
+//!< the collision axis z collision event
+#define COLLISION_TYPE_AXIS_Z   4
+//!< the collision is a obb collision
+#define COLLISION_TYPE_OBB      8
+
 
 #endif /* _NETWORK_MANAGER */

trunk/src/lib/collision_reaction/cr_physics_ground_walk.cc

@@ -1 +1 @@
 /*
    orxonox - the future of 3D-vertical-scrollers
- 
+
    Copyright (C) 2004 orx
- 
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2, or (at your option)
    any later version.
- 
+
    ### File Specific:
    main-programmer: Patrick Boenzli
@@ -26 +26 @@
 #include <vector>
 
+#include "debug.h"
+
 #include "aabb.h"
+
+#include "cr_defs.h"
 
 using namespace std;
@@ -64 +68 @@
   //   collision->getEntityB()->getAbsCoor().debug();
 
-  Vector height;
+  float height;
   AABB* box = collision->getEntityB()->getModelAABB();
-  
-  
-  
-  if(box!=NULL)
+  WorldEntity* entity = collision->getEntityB();
+
+  // collision position maths
+  Vector collPos =  collision->getEntityB()->getAbsCoor()  + box->center - ce->getCollisionPosition();
+
+  float CR_MAX_WALK_HEIGHT = 2.0f;
+  float CR_THRESHOLD = 0.2f;
+
+  if( box == NULL)
+  {
+    PRINTF(2)("this model has no aabb box so there is no correct collision reaction implemented. skipping\n");
+    return;
+  }
+
+
+  switch( ce->getType())
+  {
+    case COLLISION_TYPE_AXIS_Y:
+
+      height = collPos.y - box->halfLength[1];
+     // PRINTF(0)("height: %f          , model height: %f\n", height, box->halfLength[1]);
+     // PRINTF(0)(" ground normal: %f, %f, %f\n", normal.x, normal.y, normal.z);
+
+      // object is beneath the plane (ground)
+      if( height <= 0.0f )
+      {
+        entity->shiftCoor(Vector(0, -height, 0));
+      }
+      // object is already in the wall
+      else if( ce->isInWall())
+      {
+        entity->setAbsCoor(entity->getLastAbsCoor());
+      }
+      break;
+
+
+    case COLLISION_TYPE_AXIS_X:
+    case COLLISION_TYPE_AXIS_Z:
+      break;
+
+    }
+
+
+
+
+
+
+
+
+#if 0
+  if( box != NULL)
     height = ( ce->getCollisionPosition() - collision->getEntityB()->getAbsCoor() )*(-1.0f) ;
   else
     height = ce->getCollisionPosition() - collision->getEntityB()->getAbsCoor() ;
 
-  if(box!=NULL) {
+
+  if( box != NULL) {
 
 
@@ -90 +142 @@
       return;
     }
-    
-    
+
+
     if(ce->getGroundNormal().len() >= 1.4f) {
       downspeed++;
@@ -101 +153 @@
     if(height.y > box->halfLength[1] + 0.0f ) // Above ground
     {
-      if(height.y < box->halfLength[1] + 1.3f) // Snap in
+      if(height.y < box->halfLength[1] + 2.3f) // Snap in
       {
         downspeed = 0;
@@ -116 +168 @@
       {
         //if(downspeed <= 0) downspeed =1;
-        collision->getEntityB()->setAbsCoor(collision->getEntityB()->getAbsCoor() + Vector(0.0, -height.y  +  box->halfLength[1] + 2.0f/* 0.00001 *//*height.y+3.500005 + 10.0*/,0.0));
+        collision->getEntityB()->setAbsCoor(collision->getEntityB()->getAbsCoor() + Vector(0.0, -height.y  +  box->halfLength[1] + 2.0f,0.0));
         //collision->getEntityB()->setVelocity(Vector(0.0,0.0,0.0));
         downspeed = 0;
@@ -124 +176 @@
 
   }// if(box!= NULL)
+#endif
   /*
   PRINTF(0)("Collision with Ground: \n");
@@ -131 +184 @@
 
   */
+
 }
 
@@ -141 +195 @@
 void CRPhysicsGroundWalk::update(WorldEntity* owner)
 {
-  for( int i = 9; i > 0; i--) {
-    this->lastPositions[i] = this->lastPositions[i-1];
-    //     PRINTF(0)("lastPosition[%i]: %f, %f, %f\n", i, lastPositions[i].x, lastPositions[i].y, lastPositions[i].z);
-  }
-  this->lastPositions[0] = owner->getAbsCoor();
+
 }
 

trunk/src/lib/collision_reaction/cr_physics_ground_walk.h

@@ -23 +23 @@
     virtual void update(WorldEntity* entity);
 
+
   private:
-    Vector       lastPosition;                //!< vector with the last valid position
-    Vector       afterLastPosition;           //!< vector for the after last
-    Quaternion   lastDirection;               //!< quat with the last valid direction
-
-    Vector       lastPositions[10];           //!< last 10 positions
     float        downspeed;
 };

trunk/src/lib/event/event_handler.cc

@@ -357 +357 @@
   else
   {
-    SDL_WM_GrabInput(SDL_GRAB_ON);
-    SDL_ShowCursor(SDL_DISABLE);
+//     SDL_WM_GrabInput(SDL_GRAB_ON);
+//     SDL_ShowCursor(SDL_DISABLE);
   }
 }

trunk/src/lib/graphics/importer/bsp_file.cc

@@ -214 +214 @@
     bspFile.read(this->visData, size);
 
-    PRINTF(0)("BSP FILE: VisDataSize: %i Bytes. \n", size);
-    PRINTF(0)("BSP FILE: NumVisData: %i. \n", size /1 - 8);
-    PRINTF(0)("BSP FILE: Remainder: %i. \n", size % 1);
-    PRINTF(0)("BSP FILE: VisDataOffset: %i. \n", offset);
+    PRINTF(4)("BSP FILE: VisDataSize: %i Bytes. \n", size);
+    PRINTF(4)("BSP FILE: NumVisData: %i. \n", size /1 - 8);
+    PRINTF(4)("BSP FILE: Remainder: %i. \n", size % 1);
+    PRINTF(4)("BSP FILE: VisDataOffset: %i. \n", offset);
 
     // Get the Textures
@@ -298 +298 @@
     this->VertexArrayModels  = new VertexArrayModel*[this->numPatches];
 
-    PRINTF(0)("BSP FILE:NumberOfPatches: %i . \n", numPatches);
+    PRINTF(4)("BSP FILE:NumberOfPatches: %i . \n", numPatches);
 
     this->swapAllBspCoordinates();
@@ -308 +308 @@
     }
 
-    PRINTF(0)("BSP FILE:PatchOffset: %i . \n", this->patchOffset);
+    PRINTF(4)("BSP FILE:PatchOffset: %i . \n", this->patchOffset);
 
     return  1;
   } else {
-    PRINTF(0)("BSP FILE: Datei nicht gefunden. \n");
+    PRINTF(4)("BSP FILE: Datei nicht gefunden. \n");
     return -1;
   }
@@ -323 +323 @@
 {
 
-  PRINTF(0)("BSP FILE:\n");
-  PRINTF(0)("BSP FILE: Building Tree...\n");
+  PRINTF(4)("BSP FILE:\n");
+  PRINTF(4)("BSP FILE: Building Tree...\n");
   root = this->build_tree_rec(0);
-  PRINTF(0)("BSP FILE: ...done. \n");
-  PRINTF(0)("BSP FILE:  \n");
-  PRINTF(0)("BSP FILE: Node #0: \n");
-  PRINTF(0)("BSP FILE:  x: %f \n",root->plane.x);
-  PRINTF(0)("BSP FILE:  y: %f\n",root->plane.y);
-  PRINTF(0)("BSP FILE:  z: %f\n",root->plane.z);
+  PRINTF(4)("BSP FILE: ...done. \n");
+  PRINTF(4)("BSP FILE:  \n");
+  PRINTF(4)("BSP FILE: Node #0: \n");
+  PRINTF(4)("BSP FILE:  x: %f \n",root->plane.x);
+  PRINTF(4)("BSP FILE:  y: %f\n",root->plane.y);
+  PRINTF(4)("BSP FILE:  z: %f\n",root->plane.z);
 }
 
@@ -400 +400 @@
   this->Materials = new AMat[this->numTextures];
   for(int i = 0 ; i < this->numTextures; i++) {
-    PRINTF(0)("BSP FILE: Texture : %s. \n", &this->textures[8+ 72*i]);
+    PRINTF(4)("BSP FILE: Texture : %s. \n", &this->textures[8+ 72*i]);
 
 
@@ -429 +429 @@
     strncat (fileName, ext, strlen(fileName) );
 
-    PRINTF(0)("BSP FILE: Name %s . \n", fileName);
+    PRINTF(4)("BSP FILE: Name %s . \n", fileName);
 
     absFileName = ResourceManager::getFullName(fileName);
 
     if(File(absFileName).exists()) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] = this->loadAVI(fileName);
       continue;
@@ -449 +449 @@
 
     if(File(absFileName).exists()) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] = this->loadAVI(fileName);
       continue;
@@ -479 +479 @@
 
     if(File(absFileName).exists()) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] = this->loadMat(fileName);
       continue;
@@ -492 +492 @@
 
     if(File(absFileName).exists()/*stat( absFileName.c_str() , &results) == 0*/) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] = this->loadMat(fileName);
       continue;
@@ -504 +504 @@
     absFileName = ResourceManager::getFullName(fileName);
     if(File(absFileName).exists()) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] =this->loadMat(fileName);
       continue;
@@ -518 +518 @@
     absFileName = ResourceManager::getFullName(fileName);
     if(File(absFileName).exists()) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] =this->loadMat(fileName);
       continue;
@@ -534 +534 @@
 
     if(File(absFileName).exists()) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] =this->loadMat(fileName);
       continue;
@@ -548 +548 @@
 
     if(File(absFileName).exists()) {
-      PRINTF(0)("BSP FILE: gefunden . \n");
+      PRINTF(4)("BSP FILE: gefunden . \n");
       this->Materials[i] = this->loadMat(fileName);
       continue;
     }
 
-
+    PRINTF(0)("BSP FILE: Textur %s nicht  gefunden . \n", &this->textures[8+72*i]);
     //  Default Material
     this->Materials[i].mat = new Material();
@@ -1012 +1012 @@
   Face->meshvert = patchOffset -sz;  //3*(patchOffset-sz)*level1*level1;
   Face->n_meshverts = sz;
-  PRINTF(0)("BSP FILE: sz: %i. \n", sz);
-  PRINTF(0)("BSP FILE: Face->meshvert %i . \n", Face->meshvert);
+  PRINTF(4)("BSP FILE: sz: %i. \n", sz);
+  PRINTF(4)("BSP FILE: Face->meshvert %i . \n", Face->meshvert);
 
   //Face->n_meshverts = sz;

trunk/src/lib/graphics/importer/bsp_manager.cc

@@ -45 +45 @@
 
 #include "aabb.h"
-
+#include "cr_defs.h"
 
 
@@ -912 +912 @@
 {
   leaf& curLeaf = this->bspFile->leaves[node->leafIndex];
-  for(int i = 0; i < curLeaf.n_leaffaces ; i++) {
-  }
+  for(int i = 0; i < curLeaf.n_leaffaces ; i++) {}
   return 10.0f;
 }
 
 void BspManager::checkCollisionBox(void)
-{
-}
-;
+{}
+
 
 void BspManager::TraceBox( Vector& inputStart, Vector& inputEnd,
@@ -954 +952 @@
 
 
-  Vector forwardDir = worldEntity->getAbsDirX();
-
-
-  Vector upDir = worldEntity->getAbsDirY();
-  upDir.x = 0.0;
-  upDir.y = 1.0;
-  upDir.z = 0.0;
-  Vector dest;
-   
-
-  Vector position = worldEntity->getAbsCoor();       //+ upDir*10.0f ;
-  dest = worldEntity->getAbsCoor() - upDir*40.0f; //
-  Vector out = dest;
-
-
+  Vector forwardDir = Vector(0.0,0.0,1.0);
+  Vector upDir = Vector(0.0,1.0,0.0);
+  Vector position = worldEntity->getAbsCoor();
+
+  bool SolidFlag = false;
   bool collision = false;
   Vector position1 = position;
   Vector position2 = position + Vector(0.0,1.0,0.0);
+  Vector dest = worldEntity->getAbsCoor() - upDir*40.0f; //
   Vector dest1 = position + forwardDir*4.0f;
   Vector dest2 = position2 + forwardDir;
   dest = position - Vector(0.0, 40.0,0.0);
+  Vector out = dest;
   Vector out1;
   Vector out2;
 
- 
+
 
   float height = 40;
-  
-  
-  if( box != NULL)
-  {
+
+
+  if( box != NULL) {
     position = worldEntity->getAbsCoor() +  box->center; // + box->axis[1] * box->halfLength[1];
     dest     = worldEntity->getAbsCoor() +  box->center - box->axis[1] * box->halfLength[1] * 40.0;
-    
+
     position1 = worldEntity->getAbsCoor() +  box->center + box->axis[0] * box->halfLength[0] * 2.0f;
     dest1     = worldEntity->getAbsCoor() +  box->center - box->axis[0] * box->halfLength[0] *2.0f;
-    
-        
+
+
     position2 = worldEntity->getAbsCoor() +  box->center + box->axis[2] * box->halfLength[2] * 2.0f;
     dest2     = worldEntity->getAbsCoor() +  box->center - box->axis[2] * box->halfLength[2] * 2.0f;
-    
-  }
-  else
-  {
-    
-  }
-
-  
-  
-  //
+
+  } else {
+    // Init positions and destinations to anything useful!
+
+  }
+
+
+
+  // 1st Ray
   this->inputStart =  position;
   this->inputEnd =   dest;
@@ -1025 +1013 @@
         this->collPlane->z = 0.0f;
         collision = true;
-      } else 
+        SolidFlag = true;
+      } else
         collision = false;
-        
-        
-        out = dest;
-      
+
+
+      out = dest;
+
     } else {
       collision = true;
@@ -1046 +1035 @@
   plane* testPlane = this->collPlane;
 
-  
-  // 2nd Collision Detection
-  this->outputStartsOut = true;
-  this->outputAllSolid = false;
-  this->outputFraction = 1.0f;
-  this->inputStart =  position1;
-  this->inputEnd =   dest1;
-  this->checkCollisionRayN(this->root,0.0f,1.0f, &position1, &dest1 );
-  out.x = this->outputFraction;
-  //out.z = this->outputFraction;
-  
-  
-    // 3rd Collision Detection
-  this->outputStartsOut = true;
-  this->outputAllSolid = false;
-  this->outputFraction = 1.0f;
-  this->inputStart =  position2;
-  this->inputEnd =   dest2;
-  this->checkCollisionRayN(this->root,0.0f,1.0f, &position2, &dest2 );
-  //out.x = this->outputFraction;
-  out.z = this->outputFraction;
-  
-
+
+  bool xCollision = false;
+  bool zCollision = false;
+  if(!SolidFlag) {
+
+    // 2nd Collision Detection
+    this->outputStartsOut = true;
+    this->outputAllSolid = false;
+    this->outputFraction = 1.0f;
+    this->inputStart =  position1;
+    this->inputEnd =   dest1;
+    this->checkCollisionRayN(this->root,0.0f,1.0f, &position1, &dest1 );
+
+    if(!this->outputAllSolid != 1.0f) {
+      out.x = dest1.x + (dest1.x -position1.x) * this->outputFraction;
+      xCollision = true;
+      testPlane = this->collPlane;
+    }
+    if(this->outputAllSolid) {
+      SolidFlag = true;
+      xCollision = true;  
+    }
+    //out.z = this->outputFraction;
+
+    if(!SolidFlag) {
+
+      // 3rd Collision Detection
+      this->outputStartsOut = true;
+      this->outputAllSolid = false;
+      this->outputFraction = 1.0f;
+      this->inputStart =  position2;
+      this->inputEnd =   dest2;
+      this->checkCollisionRayN(this->root,0.0f,1.0f, &position2, &dest2 );
+      //out.x = this->outputFraction;
+
+      if(this->outputFraction != 1.0f ) {
+        out.z = out.z = dest2.z + (dest2.z -position2.z) * this->outputFraction;
+        zCollision = true;
+        testPlane = this->collPlane;
+
+      }
+      if(this->outputAllSolid) {
+          SolidFlag = true;
+          zCollision = true;   
+      }
+    }
+  }//end if
   /*
   This is how you would calculate the Coordinates where worldEntity Collided with the BSP world.
@@ -1077 +1090 @@
 
   // Return the normal here: Normal's stored in this->collPlane;
-  if( collision) 
-  {
+  if( collision) {
     PRINTF(5)("We got a collision!! Are you sure: outputFraction = %f\n", this->outputFraction);
-    worldEntity->registerCollision(this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), out);
-  } 
-  else  worldEntity->registerCollision(this->parent, worldEntity, Vector(0.0, 2.0, 0.0), dest);
+    worldEntity->registerCollision(COLLISION_TYPE_AXIS_Y || (xCollision ? COLLISION_TYPE_AXIS_X :0) | (zCollision ? COLLISION_TYPE_AXIS_Z :0), this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), out, SolidFlag);
+  } else {
+    if(xCollision || zCollision) {
+
+      worldEntity->registerCollision((xCollision ? COLLISION_TYPE_AXIS_X :0) | (zCollision ? COLLISION_TYPE_AXIS_Z :0) , this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), out, SolidFlag);
+    }
+
+  }
+  //else  worldEntity->registerCollision(COLLISION_TYPE_AXIS_Y, this->parent, worldEntity, Vector(0.0, 2.0, 0.0), dest, false);
 
 }

trunk/src/lib/graphics/importer/interactive_model.h

@@ -37 +37 @@
 
     virtual void setAnimation(int animNum, int playbackMode = 0) = 0;
+    virtual void setAnimation(int firstFrame, int lastFrame, int fps, int bStoppable, int animPlayback) {}
     virtual int getAnimation() = 0;
+
+    virtual void setAnimationSpeed(float speed) {}
 };
 

trunk/src/lib/graphics/importer/md2/md2Model.cc

@@ -103 +103 @@
   this->pModelInfo.pTexCoor = (float*)this->data->pTexCoor;
 
+  this->animationSpeed = 1.0f;
+
   // triangle conversion
   this->pModelInfo.pTriangles = new sTriangleExt[this->data->numTriangles];
@@ -159 +161 @@
 
 /**
+ * sets the animation type
+ * @param firstFrame: index of the first frame
+ * @param lastFrame: index of the last frame
+ * @param fps: frames per second
+ * @param bStoppable: is 1 if so, 0 else
+ */
+void MD2Model::setAnimation(int firstFrame, int lastFrame, int fps, int bStoppable, int animPlayback)
+{
+  this->animationState.startFrame = firstFrame;
+  this->animationState.endFrame = lastFrame;
+  this->animationState.nextFrame = firstFrame + 1;
+  this->animationState.fps = fps;
+  this->animationState.type = 0;
+  this->animationState.numPlays = 0;
+  this->animationState.animPlaybackMode = animPlayback;
+
+  this->animationState.interpolationState = 0.0f;
+  this->animationState.localTime = 0.0f;
+  this->animationState.lastTime = 0.0f;
+  this->animationState.currentFrame = firstFrame;
+}
+
+/**
   \brief sets the animation type
 * @param type: animation type
@@ -196 +221 @@
 void MD2Model::tick(float time)
 {
-  this->animate(time);
+  this->animate(time * this->animationSpeed);
   this->processLighting();
   this->interpolate(/*this->verticesList*/);

trunk/src/lib/graphics/importer/md2/md2Model.h

@@ -69 +69 @@
 
 //! animation names enumeration
-typedef enum animType
+typedef enum MD2animType
   {
     STAND,                       //0
@@ -156 +156 @@
   void renderFrameTriangles() const;
 
-
   virtual void setAnimation(int type, int animPlayback = MD2_ANIM_LOOP);
+  virtual void setAnimation(int firstFrame, int lastFrame, int fps, int bStoppable, int animPlayback);
   /**  returns the current animation @returns animation type */
   inline int MD2Model::getAnimation() { return this->animationState.type; }
+  virtual void setAnimationSpeed(float speed) { this->animationSpeed = speed; }
   /**  scales the current model @param scaleFactor: the factor [0..1] to use for scaling */
   void scaleModel(float scaleFactor) { this->scaleFactor = scaleFactor;}
@@ -186 +187 @@
  private:
   float               scaleFactor;                      //!< the scale factor (individual)
+  float               animationSpeed;                   //!< the speed of the animation (factor for the time)
   sAnimState          animationState;                   //!< animation state of the model
   sVec3D              verticesList[MD2_MAX_VERTICES];   //!< place to temp sav the vert

trunk/src/lib/math/quaternion.h

@@ -51 +51 @@
   inline bool operator== (const Quaternion& q) const { return (unlikely(this->v==q.v&&this->w==q.w))?true:false; };
   /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
-  inline bool operator!= (const Quaternion& q) const { return (unlikely(this->v!=q.v&&this->w!=q.w))?true:false; };
+  inline bool operator!= (const Quaternion& q) const { return (unlikely(this->v!=q.v||this->w!=q.w))?true:false; };
   /** @param f: a real value @return a Quaternion containing the quotient */
   inline Quaternion operator/ (const float& f) const { return (unlikely(f==0.0)) ? Quaternion() : Quaternion(this->v/f, this->w/f); };

trunk/src/lib/math/vector.h

@@ -47 +47 @@
   inline bool operator== (const Vector& v) const { return (this->x==v.x&&this->y==v.y&&this->z==v.z)?true:false; };
   /** @param v: the Vecor to compare with this one @returns true, if the Vecors are different, false otherwise */
-  inline bool operator!= (const Vector& v) const { return (this->x!=v.x&&this->y!=v.y&&this->z!=v.z)?true:false; };
+  inline bool operator!= (const Vector& v) const { return (this->x!=v.x||this->y!=v.y||this->z!=v.z)?true:false; };
   /** @param index The index of the "array" @returns the x/y/z coordinate */
   inline float operator[] (float index) const {if( index == 0) return this->x; if( index == 1) return this->y; if( index == 2) return this->z; }

trunk/src/lib/script_engine/script_manager.h

@@ -1 +1 @@
 /*!
- * @file scrip_manager.h
+ * @file script_manager.h
  *  manages the scripts
  */

trunk/src/lib/shell/shell_command.cc

@@ -373 +373 @@
     else
     {
-      delete this->completors[parameter];
+      if(this->completors[parameter] == NULL)
+      //delete this->completors[parameter];
       this->completors[parameter] = completorPlugin.clone();
     }

trunk/src/lib/util/executor/executor.cc

@@ -31 +31 @@
                    const MultiType& param2,
                    const MultiType& param3,
-                   const MultiType& param4)
+                   const MultiType& param4,
+                   const MultiType& param5,
+                   const MultiType& param6)
 {
   this->setClassID(CL_EXECUTOR, "Executor");
@@ -41 +43 @@
   this->defaultValue[3] = param3;
   this->defaultValue[4] = param4;
+  this->defaultValue[5] = param5;
+  this->defaultValue[6] = param6;
 
   this->paramCount = 0;
@@ -83 +87 @@
                                   const MultiType& value2,
                                   const MultiType& value3,
-                                  const MultiType& value4)
+                                  const MultiType& value4,
+                                  const MultiType& value5,
+                                  const MultiType& value6)
 {
   if (this == NULL)
@@ -94 +100 @@
   value[3] = &value3;
   value[4] = &value4;
-
+  value[5] = &value5;
+  value[6] = &value6;
   for (unsigned int i = 0; i < this->paramCount; i++)
   {

trunk/src/lib/util/executor/executor.h

@@ -47 +47 @@
     Executor* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
                             const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
-                            const MultiType& value4 = MT_NULL);
+                            const MultiType& value4 = MT_NULL, const MultiType& param5 = MT_NULL,
+                            const MultiType& param6 = MT_NULL);
     /** @param i the i'th defaultValue, @returns reference to the MultiType */
     inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
@@ -68 +69 @@
     Executor(const MultiType& param0 = MT_NULL, const MultiType& param1 = MT_NULL,
              const MultiType& param2 = MT_NULL, const MultiType& param3 = MT_NULL,
-             const MultiType& param4 = MT_NULL);
+             const MultiType& param4 = MT_NULL, const MultiType& param5 = MT_NULL,
+             const MultiType& param6 = MT_NULL);
 
     void cloning(Executor* executor) const;
@@ -75 +77 @@
     short                       functorType;      //!< The type of Function we've got (either static or objective).
     unsigned int                paramCount;       //!< the count of parameters.
-    MultiType                   defaultValue[5];  //!< Default Values.
+    MultiType                   defaultValue[7];  //!< Default Values.
 };
 

trunk/src/lib/util/executor/executor_functional.cc

@@ -15 +15 @@
 
 #include "executor.h"
-std::string ExecutorFunctional_returningString_from[5];
+std::string ExecutorFunctional_returningString_from[7];
 
 

trunk/src/lib/util/executor/executor_lua.cc

@@ -20 +20 @@
 #include "lunar.h"
 
-std::string temp[5];
+std::string temp[7];
 
 template<typename type> type fromLua(lua_State* state, int index) { type *obj = Lunar<type>::check(state, 1); lua_remove(state, 1); return obj;};

trunk/src/lib/util/executor/executor_lua.h

@@ -233 +233 @@
 
 
+///////////
+//// 4 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4 : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 0;
+
+      (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4) );
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua4<T, type0, type1, type2, type3>(this->functionPointer);
+    }
+  private:
+    void          (T::*functionPointer)(type0, type1, type2, type3);
+};
 
 
@@ -388 +438 @@
 };
 
+
+///////////
+//// 3 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2> class ExecutorLua3ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua3ret<T, ret, type0, type1, type2>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2);
+};
+
+
+///////////
+//// 4 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua4ret<T, ret, type0, type1, type2, type3>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2, type3);
+};
+
+///////////
+//// 5 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4> class ExecutorLua5ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4),
+          fromLua<type4>(state, 5) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua5ret<T, ret, type0, type1, type2, type3, type4>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2, type3, type4);
+};
+
+///////////
+//// 6 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5> class ExecutorLua6ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
+             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
+             ExecutorParamType<type4>(), ExecutorParamType<type5>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4),
+          fromLua<type4>(state, 5),
+          fromLua<type5>(state, 6) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua6ret<T, ret, type0, type1, type2, type3, type4, type5>(this->functionPointer);
+    }
+  private:
+    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5);
+};
+
+///////////
+//// 7 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5, typename type6> class ExecutorLua7ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
+             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
+             ExecutorParamType<type4>(), ExecutorParamType<type5>(),
+             ExecutorParamType<type6>())
+             {
+               this->functionPointer = function;
+               this->functorType = Executor_Objective | Executor_NoLoadString;
+             }
+
+    /**
+              * @brief executes the Command on BaseObject
+              * @param object the BaseObject to execute this Executor on
+              * @param loadString ignored in this case
+     */
+             virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+             {
+               PRINTF(1)("no usefull executor\n");
+             }
+
+             virtual void operator()(BaseObject* object, int& count, void* values) const
+             {
+               lua_State* state = (lua_State*)values;
+               count = 1;
+
+               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+                   fromLua<type0>(state, 1),
+                   fromLua<type1>(state, 2),
+                   fromLua<type2>(state, 3),
+                   fromLua<type3>(state, 4),
+                   fromLua<type4>(state, 5),
+                   fromLua<type5>(state, 6),
+                   fromLua<type6>(state, 7) ));
+             }
+
+    /**
+              * @returns a _new_ Copy of this Executor
+     */
+             virtual Executor* clone () const
+             {
+               return new ExecutorLua7ret<T, ret, type0, type1, type2, type3, type4, type5, type6>(this->functionPointer);
+             }
+  private:
+    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5, type6);
+};
+
+
 #endif /* _EXECUTOR_LUA_H */

trunk/src/lib/util/executor/functor_list.h

@@ -29 +29 @@
 
 //! defines the maximum count of arguments function pointers might have
-#define FUNCTOR_MAX_ARGUMENTS                5
+#define FUNCTOR_MAX_ARGUMENTS                7
 #include "multi_type.h"
 

trunk/src/story_entities/game_world.cc

@@ -308 +308 @@
     /* update the state */
     //this->update (); /// LESS REDUNDANCY.
-    PNode::getNullParent()->updateNode(this->dtS);
+//     PNode::getNullParent()->updateNode(this->dtS);
 
 

trunk/src/story_entities/multi_player_world.cc

@@ -98 +98 @@
     this->dataTank->objectManager->getObjectList(OM_PLAYERS_PROJ));
 
+  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_PLAYERS),
+  this->dataTank->objectManager->getObjectList(OM_GROUP_00_PROJ));
+  CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_PLAYERS),
+  this->dataTank->objectManager->getObjectList(OM_GROUP_01_PROJ));
+
   CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
     this->dataTank->objectManager->getObjectList(OM_GROUP_01_PROJ));

trunk/src/world_entities/WorldEntities.am

@@ -16 +16 @@
                 world_entities/character_attributes.cc \
                 world_entities/test_entity.cc \
+                world_entities/door.cc \
                 world_entities/planet.cc \
                 world_entities/bsp_entity.cc \
@@ -26 +27 @@
                 world_entities/weapons/hyperblaster.cc \
                 world_entities/weapons/aim.cc \
+                world_entities/weapons/fps_sniper_rifle.cc \
                 \
                 world_entities/projectiles/bomb.cc \
@@ -74 +76 @@
                 character_attributes.h \
                 test_entity.h \
+                door.h \
                 planet.h \
                 bsp_entity.h \
@@ -84 +87 @@
                 weapons/targeting_turret.h \
                 weapons/aim.h \
+                weapons/fps_sniper_rifle.h \
                 \
                 projectiles/bomb.h \

trunk/src/world_entities/creatures/fps_player.cc

@@ -26 +26 @@
 #include "weapons/turret.h"
 #include "weapons/cannon.h"
+#include "weapons/fps_sniper_rifle.h"
 
 #include "key_mapper.h"
@@ -35 +36 @@
 
 CREATE_FACTORY(FPSPlayer, CL_FPS_PLAYER);
+
+#include "script_class.h"
+CREATE_SCRIPTABLE_CLASS(FPSPlayer, CL_FPS_PLAYER,
+                        addMethod("setAbsCoor", ExecutorLua3<PNode,float,float,float>(&PNode::setAbsCoor))
+                            ->addMethod("getAbsCoorX", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorX))
+                            ->addMethod("getAbsCoorY", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorY))
+                            ->addMethod("getAbsCoorZ", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorZ))
+                       );
 
 
@@ -101 +110 @@
   dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false);
 
-  Weapon* wpRight = new TestGun(0);
+  Weapon* wpRight = new FPSSniperRifle(0);
   wpRight->setName("testGun Right");
-  Weapon* wpLeft = new TestGun(1);
+/*  Weapon* wpLeft = new TestGun(1);*/
 //   Weapon* wpLeft = new Turret();
-  wpLeft->setName("testGun Left");
-
-  this->addWeapon(wpLeft, 1, 0);
-  this->addWeapon(wpRight,1 ,1);
+//   wpLeft->setName("testGun Left");
+
+//   this->addWeapon(wpLeft, 1, 0);
+  this->addWeapon(wpRight,1, 0);
   this->getWeaponManager().changeWeaponConfig(1);
 
   this->getWeaponManager().setSlotCount(2);
-  this->getWeaponManager().setSlotPosition(0, Vector(-0.5, .2, -1.9));
+  this->getWeaponManager().setSlotPosition(0, Vector(0.0, 5.0, 0.0));
+  this->getWeaponManager().setSlotDirection(1, Quaternion(M_PI_4*.5, Vector(0,1,0)));
   this->getWeaponManager().setSlotCapability(0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
   this->getWeaponManager().setSlotPosition(1, Vector(-0.5, .2, 1.9));

trunk/src/world_entities/npcs/generic_npc.cc

@@ -38 +38 @@
 CREATE_FACTORY(GenericNPC, CL_GENERIC_NPC);
 
+#include "script_class.h"
+CREATE_SCRIPTABLE_CLASS(GenericNPC, CL_GENERIC_NPC,
+                       // Move
+                        addMethod("walkTo", ExecutorLua3ret<GenericNPC,float,float,float,float>(&GenericNPC::walkTo))
+                        ->addMethod("setTime", ExecutorLua1<GenericNPC,float>(&GenericNPC::setTime))
+                        ->addMethod("turnTo", ExecutorLua4ret<GenericNPC,bool,float,float,float,float>(&GenericNPC::turnTo))
+                       // Display
+                        ->addMethod("hide", ExecutorLua0<WorldEntity>(&WorldEntity::hide))
+                        ->addMethod("unhide", ExecutorLua0<WorldEntity>(&WorldEntity::unhide))
+                       // Coordinates
+                        ->addMethod("getAbsCoorX", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorX))
+                        ->addMethod("getAbsCoorY", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorY))
+                        ->addMethod("getAbsCoorZ", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorZ))
+                        ->addMethod("setAbsCoor", ExecutorLua3<PNode,float,float,float>(&PNode::setAbsCoor))
+                        ->addMethod("setAbsDir", ExecutorLua4<PNode,float,float,float,float>(&PNode::setAbsDir))
+                            
+                       );
+
 
 
@@ -52 +70 @@
 }
 
+
+GenericNPC::GenericNPC()
+  : NPC(NULL)
+{
+
+}
 
 /**
@@ -75 +99 @@
   this->soundBuffer = (OrxSound::SoundBuffer*)ResourceManager::getInstance()->load("sound/rain.wav", WAV);
 
+  time = 30.0f;
   // collision reaction registration
 //   this->subscribeReaction(CREngine::CR_PHYSICS_GROUND_WALK, CL_BSP_ENTITY);
@@ -136 +161 @@
 
   // check if this is the current goal
-  if( this->destCoor != destCoor && this->destDir != destDir)
+  if( this->destCoor != destCoor || this->destDir != destDir)
   {
-    this->destCoor = Vector(x, y, 0.0f);
-    this->destDir = Quaternion(Vector(qx, qy, qz), qu);
-
-    float time = 5.0f;
+    this->destCoor = destCoor;
+    this->destDir = destDir;
+
+    //float time = 100.0f;
 
     if( this->currentAnim != NULL)
@@ -147 +172 @@
 
     this->currentAnim = new Animation3D(this);
-    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->getAbsDir(), 0.0f);
-    this->currentAnim->addKeyFrame(this->destCoor, this->destDir, time);
+    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->getAbsDir(), 0.0f, ANIM_LINEAR, ANIM_LINEAR);
+    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->getAbsDir(), time, ANIM_LINEAR, ANIM_LINEAR);
+    this->currentAnim->addKeyFrame(this->destCoor, this->destDir, time, ANIM_LINEAR, ANIM_LINEAR);
+
+    this->currentAnim->setInfinity(ANIM_INF_CONSTANT);
+    this->currentAnim->play();
+
+    this->setAnimation(RUN, MD2_ANIM_LOOP);
   }
 
@@ -157 +188 @@
 
 
+/**
+ * walk to a specific place with direction
+ *
+ * @param x: x coordinate to go to
+ * @param y: y coordinate to go to
+ * @param z: z coordinate to go to
+ *
+ * without turning itself
+ */
+float GenericNPC::walkTo(float x, float y, float z)
+{
+  Quaternion q = this->getAbsDir();
+
+  //printf("%s moving to %f, %f, %f \n",this->getName(),x,y,z);
+
+  return this->walkTo(x, y, z, q.w, q.v.x, q.v.y, q.v.z);
+}
 
 /**
@@ -188 +236 @@
 
 
+
+/**
+ * run to a specific place with direction
+ *
+ * @param x: x coordinate to go to
+ * @param y: y coordinate to go to
+ * @param z: z coordinate to go to
+ * @param qu: angle to rotate
+ * @param qx: x coordinate of rotation vector
+ * @param qy: y coordinate of rotation vector
+ * @param qz: z coordinate of rotation vector
+ *
+ */
+float GenericNPC::runTo(float x, float y, float z, float qu, float qx, float qy, float qz)
+{
+  Vector destCoor = Vector(x, y, z);
+  Quaternion destDir = Quaternion(Vector(qx, qy, qz), qu);
+
+  // check if this is the current goal
+  if( this->destCoor != destCoor || this->destDir != destDir)
+  {
+    this->destCoor = destCoor;
+    this->destDir = destDir;
+
+    float time = 5.0f;
+
+    if( this->currentAnim != NULL)
+      delete this->currentAnim;
+
+    this->currentAnim = new Animation3D(this);
+    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->getAbsDir(), time, ANIM_LINEAR, ANIM_LINEAR);
+    this->currentAnim->addKeyFrame(this->destCoor, this->destDir, time, ANIM_LINEAR, ANIM_LINEAR);
+
+
+    this->currentAnim->setInfinity(ANIM_INF_CONSTANT);
+    this->currentAnim->play();
+
+    this->setAnimation(RUN, MD2_ANIM_LOOP);
+  }
+
+  // calculate the distance
+  Vector distance = this->getAbsCoor() - this->destCoor;
+  return distance.len();
+}
+
+
+/**
+ * run to a specific place with direction
+ *
+ * @param x: x coordinate to go to
+ * @param y: y coordinate to go to
+ * @param qu: angle to rotate
+ * @param qx: x coordinate of rotation vector
+ * @param qy: y coordinate of rotation vector
+ * @param qz: z coordinate of rotation vector
+ *
+ */
+float GenericNPC::runTo(float x, float y, float qu, float qx, float qy, float qz)
+{
+  this->runTo(x, y, 0.0f, qu, qx, qy, qz);
+}
+
+
+/**
+ * run to a specific place with direction
+ *
+ * @param coor: vector place
+ * @param dir: direction
+ *
+ */
+float GenericNPC::runTo(const Vector& coordinate, const Quaternion& dir)
+{
+  this->runTo(coordinate.x, coordinate.y, coordinate.z, dir.w, dir.v.x, dir.v.y, dir.v.z);
+}
+
+
+/**
+ * crouch to a specific place with direction
+ *
+ * @param x: x coordinate to go to
+ * @param y: y coordinate to go to
+ * @param z: z coordinate to go to
+ * @param qu: angle to rotate
+ * @param qx: x coordinate of rotation vector
+ * @param qy: y coordinate of rotation vector
+ * @param qz: z coordinate of rotation vector
+ *
+ */
+float GenericNPC::crouchTo(float x, float y, float z, float qu, float qx, float qy, float qz)
+{
+  Vector destCoor = Vector(x, y, z);
+  Quaternion destDir = Quaternion(Vector(qx, qy, qz), qu);
+
+  // check if this is the current goal
+  if( this->destCoor != destCoor || this->destDir != destDir)
+  {
+    this->destCoor = destCoor;
+    this->destDir = destDir;
+
+
+    if( this->currentAnim != NULL)
+      delete this->currentAnim;
+
+    this->currentAnim = new Animation3D(this);
+    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->getAbsDir(), time, ANIM_LINEAR, ANIM_LINEAR);
+    this->currentAnim->addKeyFrame(this->destCoor, this->destDir, time, ANIM_LINEAR, ANIM_LINEAR);
+
+
+    this->currentAnim->setInfinity(ANIM_INF_CONSTANT);
+    this->currentAnim->play();
+
+    this->setAnimation(CROUCH_WALK, MD2_ANIM_LOOP);
+  }
+
+  // calculate the distance
+  Vector distance = this->getAbsCoor() - this->destCoor;
+  return distance.len();
+}
+
+
+/**
+ * couch to a specific place with direction
+ *
+ * @param x: x coordinate to go to
+ * @param y: y coordinate to go to
+ * @param qu: angle to rotate
+ * @param qx: x coordinate of rotation vector
+ * @param qy: y coordinate of rotation vector
+ * @param qz: z coordinate of rotation vector
+ *
+ */
+float GenericNPC::crouchTo(float x, float y, float qu, float qx, float qy, float qz)
+{
+  this->crouchTo(x, y, 0.0f, qu, qx, qy, qz);
+}
+
+
+
+/**
+ * crouch to a specific place with direction
+ *
+ * @param coor: vector place
+ * @param dir: direction
+ *
+ */
+float GenericNPC::crouchTo(const Vector& coordinate, const Quaternion& dir)
+{
+  this->crouchTo(coordinate.x, coordinate.y, coordinate.z, dir.w, dir.v.x, dir.v.y, dir.v.z);
+}
+
+
+/**
+ * stops the generic animation
+ */
+void GenericNPC::stop()
+{
+  if( this->currentAnim != NULL)
+  {
+    this->currentAnim->stop();
+    delete this->currentAnim;
+    this->currentAnim = NULL;
+
+    this->setAnimation(STAND, MD2_ANIM_LOOP);
+  }
+}
+
+
+/**
+ * lookat a world entity
+ * @param worldEntity: the worldentity to look at
+ */
+float GenericNPC::lookAt(WorldEntity* worldEntity)
+{}
+
+
+/**
+ * turns to a given direction
+ */
+bool GenericNPC::turnTo(float qu, float qx, float qy, float qz)
+{
+  Quaternion destDir = Quaternion(Vector(qx, qy, qz).getNormalized(), qu);
+
+  printf("Turning: %f, %f, %f, %f \n",qu,qx,qy,qz);
+  // check if this is the current goal
+  if( this->destDir != destDir)
+  {
+//     if( this->currentAnim != NULL)
+//       this->currentAnim->stop();
+//
+    PRINTF(0)("SET ANIMATION\n");
+    this->destDir = destDir;
+//
+
+
+    if( this->currentAnim != NULL)
+      delete this->currentAnim;
+
+    this->setAbsDir(destDir);
+/*
+    this->currentAnim = new Animation3D(this);
+    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->getAbsDir(), 0.0f, ANIM_LINEAR, ANIM_LINEAR);
+    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->getAbsDir(), time, ANIM_LINEAR, ANIM_LINEAR);
+    this->currentAnim->addKeyFrame(this->getAbsCoor(), this->destDir, time, ANIM_LINEAR, ANIM_LINEAR);
+
+
+    this->currentAnim->setInfinity(ANIM_INF_CONSTANT);
+    this->currentAnim->play();*/
+
+    this->setAnimation(STAND, MD2_ANIM_LOOP);
+  }
+
+  // calculate the distance
+  Vector distance = this->getAbsCoor() - this->destCoor;
+  return distance.len();
+}
+
+
+
+/**
+ * talk to a world entity and play a sound/music/voice
+ * @param worldEntity: entity
+ * @param dialogNr: sound nr to be played (from the xml load tags)
+ */
+float GenericNPC::talkTo(WorldEntity* worldEntity, int dialogNr)
+{}
+
+
+/**
+ * world entity to shoot at if there is any weapon on the npc
+ * @param entity: entity to shoot entity
+ */
+void GenericNPC::shootAt(WorldEntity* entity)
+{}
+
+
+
+
+
+
+
+
+
+
 /**
  * tick this world entity
@@ -196 +487 @@
   if( likely(this->getModel(0) != NULL))
     ((InteractiveModel*)this->getModel(0))->tick(time);
+
 }
 

trunk/src/world_entities/npcs/generic_npc.h

@@ -28 +28 @@
 {
  public:
+  GenericNPC();
   GenericNPC(const TiXmlElement* root);
   virtual ~GenericNPC ();
@@ -38 +39 @@
   inline void setVolume(float vol) { this->soundVolume = vol; }
 
-  void playAnimation(int animationIndex, int animPlaybackMode);
 
-  void playSound(std::string filename);
-  void playSound(int i);
+  /* npc controlling functions */
 
-  float lookAt(WorldEntity* worldEntity);
-
+  /* walking functions */
   float walkTo(const Vector& coordinate, const Quaternion& dir);
+  float walkTo(float x, float y, float z);
   float walkTo(float x, float y, float z, float qu, float qx, float qy, float qz);
   float walkTo(float x, float y, float qu, float qx, float qy, float qz);
 
+  /* running functions */
   float runTo(const Vector& coordinate, const Quaternion& dir);
   float runTo(float x, float y, float z, float qu, float qx, float qy, float qz);
   float runTo(float x, float y, float qu, float qx, float qy, float qz);
 
+  /* couching functinos */
   float crouchTo(const Vector& coordinate, const Quaternion& dir);
   float crouchTo(float x, float y, float z, float qu, float qx, float qy, float qz);
   float crouchTo(float x, float y, float qu, float qx, float qy, float qz);
 
+  /* stopping the movement */
+  void stop();
+
+  /* some oriantation functions */
+  float lookAt(WorldEntity* worldEntity);
+  bool turnTo(float qu, float qx, float qy, float qz);
+
+  /* talking funcitons*/
   float talkTo(WorldEntity* worldEntity, int dialogNr);
+
+  /* shooting functions */
+  void shootAt(WorldEntity* entity);
+
+
+  /* some generic control funtions */
+  void playAnimation(int animationIndex, int animPlaybackMode);
+  void playSound(std::string filename);
+  void playSound(int i);
+
+  void setTime(float newTime){ this->time = newTime; };
+  
+  virtual void tick (float time);
 
 
   void destroy();
-
-  virtual void tick (float time);
 
 
@@ -74 +94 @@
 
    Animation3D*                            currentAnim;
+   float                                   time;          //!< Duration of the action
 };
 

trunk/src/world_entities/npcs/npc.cc

@@ -50 +50 @@
 void NPC::loadParams(const TiXmlElement* root)
 {
-  WorldEntity::loadParams(root);
+  if(root != NULL)
+   WorldEntity::loadParams(root);
 }
 

trunk/src/world_entities/script_trigger.cc

@@ -24 +24 @@
 CREATE_SCRIPTABLE_CLASS(ScriptTrigger, CL_SCRIPT_TRIGGER,
                             addMethod("setAbsCoor", ExecutorLua3<PNode,float,float,float>(&PNode::setAbsCoor))
-                                ->addMethod("getAbsCoorX", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorX))
-                                ->addMethod("getAbsCoorY", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorY))
-                                ->addMethod("getAbsCoorZ", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorZ))
+                            ->addMethod("getAbsCoorX", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorX))
+                            ->addMethod("getAbsCoorY", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorY))
+                            ->addMethod("getAbsCoorZ", ExecutorLua0ret<PNode, float>(&PNode::getAbsCoorZ))
                        );
 
@@ -41 +41 @@
 
   returnCount = 1;
-  actionFinished = false;
+  scriptFinished = false;
   doDebugDraw = false;
   invert = false;
   scriptCalled = false;
   scriptIsOk = false;
-  triggerLasts = false;
+  triggerLasts = true;
   addToScript = false;
   
@@ -54 +54 @@
   loadParams(root);
   
-  if(addToScript)
+  if(addToScript && scriptIsOk)
   {
     script->addObject( "ScriptTrigger", this->getName());
@@ -102 +102 @@
         .describe("The name of the parent as it is in the *.oxw file")
         .defaultValues("");
-    LoadParam(root, "callonce", this, ScriptTrigger, setCallOnce)
-        .describe("True if the script shoul only be called once")
-        .defaultValues("");
     LoadParam(root, "invert", this, ScriptTrigger, setInvert)
         .describe("")
-        .defaultValues("");
+        .defaultValues("false");
     LoadParam(root, "triggerlasts", this, ScriptTrigger, setTriggerLasts)
         .describe("")
-        .defaultValues("");
+        .defaultValues("true");
     LoadParam(root, "debugdraw", this, ScriptTrigger, setDebugDraw)
-        .describe("True if the script should only be called once")
-        .defaultValues("");
+        .describe("")
+        .defaultValues("false");
     LoadParam(root, "addtoscript", this, ScriptTrigger, setAddToScript)
         .describe("True if this scripttrigger should be aviable in the script")
-        .defaultValues("");
+        .defaultValues("false");
 }
 
@@ -159 +156 @@
 void ScriptTrigger::tick(float timestep)
 {
-  if(actionFinished) return;
+  if(scriptFinished) return;
 
   if(triggerLasts && scriptCalled)
@@ -169 +166 @@
   if( !invert && this->distance(target) < radius)
  {
-  if(!callOnce)
-   {
     executeAction(timestep);
     scriptCalled = true;
-   }
-  else if(callOnce && !scriptCalled)
-  {
-   executeAction(timestep);
-   scriptCalled = true;
-  }
   
  }
  else if( invert && this->distance(target) > radius)
  {
-   if(!callOnce)
-   {
-     executeAction(timestep);
-   }
-   else if(callOnce && !scriptCalled)
-   {
-     executeAction(timestep);
+     executeAction(timestep); 
      scriptCalled = true;
-   }
-   
  }
  //else
@@ -202 +183 @@
 void ScriptTrigger::executeAction(float timestep)
 {
+  
      if(scriptIsOk)
      {
@@ -213 +195 @@
        printf("Error ScriptTrigger: Execution of %s in %s failed.\n",functionName.c_str(), script->getFileName().c_str());
      
-     actionFinished = script->getReturnedBool();
+     scriptFinished = script->getReturnedBool();
      }
      

trunk/src/world_entities/script_trigger.h

@@ -35 +35 @@
     void setTarget(WorldEntity* target) { if(target!=NULL) this->target=target; }
     void setTriggerParent(const std::string& name);
-    void setCallOnce(const bool call) { this->callOnce = call; }
     void setTriggerLasts(const bool lasts) { this->triggerLasts = lasts; }
     void setInvert(const bool inv) { this->invert = invert; }
@@ -51 +50 @@
 
     WorldEntity* target;
-    bool         callOnce;
     bool         triggerLasts;
     bool         invert;
@@ -63 +61 @@
     bool         scriptCalled;
     bool         scriptIsOk;
-    bool         actionFinished;
+    bool         scriptFinished;
     int          returnCount;        //TODO: set return count correctly
 

trunk/src/world_entities/world_entity.cc

@@ -193 +193 @@
         PRINTF(1)("OBJ-File %s not found.\n", fileName.c_str());
 
-      if( modelNumber == 0)
+      if( modelNumber == 0 && !this->isA(CL_WEAPON))
         this->buildObbTree(obbTreeDepth);
     }
@@ -418 +418 @@
   CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
   assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
-  c->collide(entityA, entityB, bvA, bvB);
+  c->collide(COLLISION_TYPE_OBB, entityA, entityB, bvA, bvB);
 
   for( int i = 0; i < CREngine::CR_NUMBER; ++i)
@@ -433 +433 @@
  *  @param position it collides on the plane
  */
-bool WorldEntity::registerCollision(WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position)
+bool WorldEntity::registerCollision(int type, WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position, bool bInWall)
 {
   // is there any handler listening?
@@ -442 +442 @@
   CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
   assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
-  c->collide(entity, groundEntity, normal, position);
+  c->collide(type, entity, groundEntity, normal, position, bInWall);
 
   for( int i = 0; i < CREngine::CR_NUMBER; ++i)

trunk/src/world_entities/world_entity.h

@@ -88 +88 @@
 
   bool registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB);
-  bool registerCollision(WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position);
+  bool registerCollision(int type, WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position, bool bInWall = false);
   /** @return true if there is at least on collision reaction subscribed */
   inline bool isReactive() const { return this->bReactive; }
@@ -115 +115 @@
   /** @returns a Reference to the Iterator */
   ObjectManager::EntityList::iterator& getEntityIterator() { return this->objectListIterator; }
+
+  void hide() { if( this->objectListNumber != OM_DEAD) this->lastObjectListNumber = this->objectListNumber; this->toList(OM_DEAD); }
+  void unhide() { this->toList(this->lastObjectListNumber); }
+
 
   /* --- Character Attribute Block --- */
@@ -176 +180 @@
   OM_LIST                 objectListNumber;                //!< The ObjectList from ObjectManager this Entity is in.
   ObjectManager::EntityList::iterator objectListIterator;  //!< The iterator position of this Entity in the given list of the ObjectManager.
+  OM_LIST                 lastObjectListNumber;            //!< the last ObjectList from the ObjectManager this Entity was is in