Index: trunk/src/world_entities/npcs/actionbox_enemy.cc
===================================================================
--- trunk/src/world_entities/npcs/actionbox_enemy.cc	(revision 10698)
+++ trunk/src/world_entities/npcs/actionbox_enemy.cc	(revision 10698)
@@ -0,0 +1,264 @@
+/*
+   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: Christoph Renner
+   co-programmer:
+*/
+
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
+
+#include "loading/factory.h"
+#include "debug.h"
+#include "loading/load_param.h"
+#include "util/loading/load_param_xml.h"
+#include "state.h"
+#include "player.h"
+#include "playable.h"
+
+#include "actionbox_enemy.h"
+
+ObjectListDefinition(ActionboxEnemy);
+CREATE_FACTORY(ActionboxEnemy);
+
+ActionboxEnemy::ActionboxEnemy(const TiXmlElement* root)
+{
+  PRINTF(0)("ActionboxEnemy\n");
+  
+  this->registerObject(this, ActionboxEnemy::_objectList);
+  this->toList(OM_GROUP_00);
+  
+  this->isActive = true;
+  
+  this->pitch = 0.0f;
+  this->dPitch = 0.0;
+  
+  this->maxSpeed = 30;
+  this->acceleration = 3;
+  this->speed = 0;
+  
+  this->onEscape = false;
+  
+  if ( root )
+    this->loadParams( root );
+}
+
+ActionboxEnemy::~ActionboxEnemy()
+{
+}
+
+void ActionboxEnemy::loadParams(const TiXmlElement* root)
+{
+  WorldEntity::loadParams( root );
+}
+
+void ActionboxEnemy::tick( float dt )
+{
+  this->bFire = false;
+  
+  if ( !State::getPlayer() || !State::getPlayer()->getPlayable() )
+    return;
+  
+  Vector playerDir = State::getPlayer()->getPlayable()->getAbsDir().apply( Vector(1, 0, 0) );
+  Vector dist = this->getAbsCoor() - State::getPlayer()->getPlayable()->getAbsCoor();
+  
+  bool behindPlayer = playerDir.dot( dist ) < 0;
+  
+  if ( behindPlayer )
+    return;
+  
+  myDir = this->getAbsDir();
+  myCoor = this->getAbsCoor();
+  
+  this->pitch += this->dPitch*dt;
+  while ( pitch > 2*PI )
+    pitch -= 2*PI;
+  while ( pitch < 0 )
+    pitch += 2*PI;
+  
+  myDir *= qPitch.inverse();
+  
+  qPitch = Quaternion( pitch, Vector( 1, 0, 0 ) );
+  
+  if ( isActive && State::getActionBox() )
+  {
+    ActionBox* box = State::getActionBox();
+    if ( box->isPointInBox( this->getAbsCoor() ) )
+    {
+      attackPlayer( box, dt );
+    }
+    else
+    {
+      moveTowardsBox( box, dt );
+      onEscape = false;
+    }
+  }
+  
+  myDir *= qPitch;
+  
+  this->setAbsDir( myDir );
+  this->setAbsCoor( myCoor );
+}
+
+void ActionboxEnemy::attackPlayer( ActionBox * box, float dt )
+{
+  if ( !State::getPlayer() || !State::getPlayer()->getPlayable() || !box )
+    return;
+  
+  float distance = (State::getPlayer()->getPlayable()->getAbsCoor() - getAbsCoor() ).len();
+  
+  if ( distance > box->getDepth()/4.0 && !onEscape )
+  {
+    Vector targetPos = State::getPlayer()->getPlayable()->getAbsCoor();
+    Vector targetDir = State::getPlayer()->getPlayable()->getAbsCoor()-this->getAbsCoor();
+    moveTowards( targetPos, targetDir, dt );
+    if ( this->getAbsDir().apply( Vector(1, 0, 0) ).dot(targetDir) > 0.9 )
+    {
+      this->bFire = true;
+      PRINTF(0)("FIRE\n");
+    }
+  }
+  else
+  {
+    if ( !onEscape )
+    {
+      Vector ds = this->getAbsCoor() - State::getPlayer()->getPlayable()->getAbsCoor();
+      float projy = box->getAbsDir().apply( Vector(0, 1, 0) ).dot( ds );
+      float projz = box->getAbsDir().apply( Vector(0, 0, 1) ).dot( ds );
+      this->escapePoint = Vector( 0, projy, projz );
+      this->escapePoint.normalize();
+      this->escapePoint*= 2*box->getWidth_2();
+      PRINTF(0)("ESCAPE\n");
+    }
+    onEscape = true;
+    
+    Vector rEscapePoint = box->getAbsDir().apply(escapePoint);
+    Vector targetPos = State::getPlayer()->getPlayable()->getAbsCoor() + rEscapePoint;
+    Vector targetDir = State::getPlayer()->getPlayable()->getAbsCoor() + rEscapePoint - this->getAbsCoor();
+    moveTowards( targetPos, targetDir, dt );    
+  }
+}
+
+void ActionboxEnemy::moveTowards( Vector targetPos, Vector targetDir, float dt )
+{
+  Quaternion cur = myDir;
+  Quaternion rx( dt, Vector( 0, 0, 1 ) );
+  
+  Quaternion tmp1 = cur * rx;
+  Quaternion tmp2 = cur * rx.inverse();
+  
+  Quaternion dec;
+  if ( tmp1.apply( Vector(1, 0, 0) ).dot(targetDir) > tmp2.apply( Vector(1, 0, 0)).dot(targetDir) )
+    dec = tmp1;
+  else
+    dec = tmp2;
+  
+  float dp = dec.apply( Vector(1, 0, 0) ).dot(Vector(0, 1, 0));
+  if ( dp > -0.9 && dp < 0.9 )
+  {
+    cur = dec;
+  }
+  
+  Quaternion ry( dt, cur.inverse().apply( Vector( 0, 1, 0 ) ) );
+  
+  tmp1 = cur * ry;
+  tmp2 = cur * ry.inverse();
+  
+  if ( tmp1.apply( Vector(1, 0, 0) ).dot(targetDir) > tmp2.apply( Vector(1, 0, 0)).dot(targetDir) )
+    cur = tmp1;
+  else
+    cur = tmp2;
+  
+  myDir = cur;
+  
+  Vector fw = cur.apply( Vector(1, 0, 0) );
+  
+  this->speed += this->acceleration*dt;
+  if ( this->speed > this->maxSpeed )
+    this->speed = this->maxSpeed;
+  this->myCoor += fw*speed*dt;
+}
+
+void ActionboxEnemy::moveTowardsBox( ActionBox * box, float dt )
+{
+    
+  Vector targetPos = box->getAbsCoor() + box->getAbsDir().apply( Vector( 1, 0, 0 ) )*box->getDepth()*0.66f;
+  Vector targetDir = targetPos - myCoor;
+  
+  moveTowards(targetPos, targetDir, dt);
+}
+
+void ActionboxEnemy::draw( ) const
+{
+#if 0
+  Vector fw = this->getAbsDir().apply( Vector( 1, 0, 0 ) );
+  fw.normalize();
+  fw = fw * 100;
+  
+  Vector mp = this->getAbsCoor();
+  Vector op = mp + fw;
+  
+  Vector targetPos = State::getPlayer()->getPlayable()->getAbsCoor();
+  Vector dv = targetPos - this->getAbsCoor();
+  dv.normalize();
+  dv *= 100;
+  dv += mp;
+  
+  Vector spUp = this->getAbsDir().inverse().apply( this->getAbsDir().apply( Vector( 0, 1, 0 ) ) );
+  spUp.normalize();
+  spUp *= 100;
+  spUp += mp;
+  
+  Vector up = fw.cross( dv );
+  up += mp;
+  
+  //PRINTF(0)("DEBUG\n");
+  //mp.debug();
+  //op.debug();
+  
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+
+  glPushAttrib(GL_ENABLE_BIT);
+
+  glDisable(GL_LIGHTING);
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+  glLineWidth(2.0);
+  glColor3f(1.0, 0.0, 0.0 );
+  
+  
+  glBegin(GL_LINE_STRIP);
+    glVertex3f(mp.x, mp.y, mp.z);
+    glVertex3f(op.x, op.y, op.z);
+  glEnd();
+  
+  glColor3f(0.0, 1.0, 0.0 );
+  glBegin(GL_LINE_STRIP);
+    glVertex3f(mp.x, mp.y, mp.z);
+    glVertex3f(dv.x, dv.y, dv.z);
+  glEnd();
+  
+  glColor3f(0.0, 0.0, 1.0 );
+  glBegin(GL_LINE_STRIP);
+    glVertex3f(mp.x, mp.y, mp.z);
+    glVertex3f(up.x, up.y, up.z);
+  glEnd();
+  
+  glColor3f(1.0, 1.0, 1.0 );
+  glBegin(GL_LINE_STRIP);
+    glVertex3f(mp.x, mp.y, mp.z);
+    glVertex3f(spUp.x, spUp.y, spUp.z);
+  glEnd();
+
+  glPopMatrix();
+#endif
+  WorldEntity::draw();
+}
Index: trunk/src/world_entities/npcs/actionbox_enemy.h
===================================================================
--- trunk/src/world_entities/npcs/actionbox_enemy.h	(revision 10698)
+++ trunk/src/world_entities/npcs/actionbox_enemy.h	(revision 10698)
@@ -0,0 +1,45 @@
+
+#ifndef _NPC_H
+#define _NPC_H
+
+#include "world_entity.h"
+#include "world_entities/weapons/weapon_manager.h"
+#include "track/action_box.h"
+
+class ActionboxEnemy : public WorldEntity
+{
+  ObjectListDeclaration(ActionboxEnemy);
+
+  public:
+    ActionboxEnemy(const TiXmlElement* root = NULL);
+    virtual ~ActionboxEnemy ();
+  
+    virtual void tick(float dt);
+    virtual void draw() const;
+
+    virtual void loadParams(const TiXmlElement* root);
+   
+  private:
+    bool  isActive;
+    float pitch;      // rotate angle around x-axix
+    float dPitch;     // change pitch += dPitch*dt
+    Quaternion qPitch;
+    
+    float acceleration;
+    float maxSpeed;
+    float speed;
+    
+    Quaternion myDir;
+    Vector     myCoor;
+    
+    bool       bFire;
+    
+    Vector     escapePoint;
+    bool       onEscape;
+    
+    void attackPlayer( ActionBox* box, float dt );
+    void moveTowardsBox( ActionBox* box, float dt );
+    void moveTowards( Vector targetPos, Vector targetDir, float dt );
+};
+
+#endif
Index: trunk/src/world_entities/npcs/adm_turret.cc
===================================================================
--- trunk/src/world_entities/npcs/adm_turret.cc	(revision 10698)
+++ trunk/src/world_entities/npcs/adm_turret.cc	(revision 10698)
@@ -0,0 +1,352 @@
+/*
+* 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: Reto Luechinger
+*/
+
+
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
+#include "adm_turret.h"
+#include "weapons/weapon_manager.h"
+#include "weapons/weapon.h"
+#include "lib/util/loading/factory.h"
+#include "world_entities/projectiles/projectile.h"
+#include "loading/load_param.h"
+#include "debug.h"
+#include "loading/load_param_xml.h"
+
+#include "environments/bsp_entity.h"
+
+ObjectListDefinition(AdmTurret);
+CREATE_FACTORY(AdmTurret);
+
+/**
+*  Standard constructor
+*/
+AdmTurret::AdmTurret ()
+{
+	this->init();
+}
+
+/**
+* destructs the turret, deletes allocated memory
+*/
+AdmTurret::~AdmTurret ()
+{
+          // will be deleted
+}
+
+/**
+* Constructor with XML Element
+*/
+AdmTurret::AdmTurret (const  TiXmlElement* root)
+{
+	this->init();
+	if (root != NULL)
+        {
+		this->loadParams(root);
+	}
+}
+/**
+* XML Loader
+*/
+void AdmTurret::loadParams(const TiXmlElement* root)
+{
+	if (root != NULL)
+	{
+		WorldEntity::loadParams(root);
+
+		LoadParam(root, "target", this, AdmTurret, setTarget)
+			.describe("The filename of the World Entity, that is to be shot at")
+			.defaultValues("");
+                
+                LoadParam(root, "type", this, AdmTurret, setType)
+                        .describe("floor|ceil"); 
+
+		LoadParamXML(root, "Cannons", this, AdmTurret, addCannons)
+  			.describe("add cannons to ADM");
+		LoadParamXML(root, "Sensor", this, AdmTurret, addSensor)
+  			.describe("add sensor to ADM");
+		LoadParamXML(root, "Weapon", this, AdmTurret, addWeapon)
+  			.describe("add weapon to ADM");
+
+	}
+//         this->removeNodeFlags( PNODE_ALL );
+        this->addNodeFlags( PNODE_ROTATE_AND_MOVE );
+        this->addNodeFlags( PNODE_REPARENT_KEEP_POSITION );
+        
+        //HACK this is needed to get the correct coordinates instead (0, 0, 0)
+        this->updateNode( 0 );
+        
+        if ( this->isCeil )
+        {
+          Vector a = this->sensor->getRelCoor();
+          this->sensor->setRelCoor( -a.x, -a.y, -a.z );
+          a = this->cannons->getRelCoor();
+          this->cannons->setRelCoor( -a.x, -a.y, -a.z );
+        }
+}
+
+/**
+* Sets Target onto the World Entity with filename "target", given as String
+*/
+void AdmTurret::setTarget(const std::string& target)
+{
+	WorldEntity* targetEntity = WorldEntity::objectList().getObject(target);
+	if (targetEntity != NULL) 
+	{
+		this->myTarget = targetEntity;
+	}
+	else
+	{
+		PRINTF(1)("ERROR ADMTURRET : Target %s does not exist\n", target.c_str());
+	}
+}
+
+void AdmTurret::setType( const std::string& type )
+{
+  if ( type == "floor" )
+  {
+    this->isCeil = false;
+    return;
+  }
+  
+  if ( type == "ceil" )
+  {
+    this->isCeil = true;
+    return;
+  }
+  
+  //invalid argument
+  PRINTF(1)("%s is not a valid type for AdmTurret\n", type.c_str());
+  assert("false");
+}
+
+void AdmTurret::init()
+{
+	this->registerObject(this, AdmTurret::_objectList);
+        
+        this->bodyAngle = this->cannonAngle = 0.0f;
+        this->isActive = true;
+        this->range = 400;
+        this->isCeil = false;
+        this->playerVisible = false;
+	this->weapon = NULL;
+
+	
+}
+
+void AdmTurret::tick(float dt)
+{
+  WorldEntity::tick(dt);
+  if (this->weapon) this->weapon->fire(false);
+  this->updatePlayerVisible();
+
+  //rotate sensor 2PI/sec
+  this->sensor->setAbsDir( this->sensor->getAbsDir() * Quaternion( PI*2*dt, Vector( 0, -1, 0 ) ) );
+
+
+  Vector playerPos = this->myTarget->getAbsCoor() + Vector(0, 12, 0);
+  Vector ds = playerPos - ( this->cannons->getAbsCoor() );
+  if ( isActive && ds.len() <= range && playerVisible )
+  {
+    this->moveTowards( ds,  dt);
+    
+    //if target within +/- 2.5 degrees of aim -> fire
+    Vector dv1 = ds;
+    dv1.normalize();
+    Vector dv2 = this->cannons->getAbsDir().apply( Vector(-1, 0, 0));
+    dv2.normalize();
+    float angle = dv1.dot(dv2);
+    if (angle > 0.999)
+    {
+     	if (this->weapon) this->weapon->fire(true);
+    }
+  }
+  else
+    this->moveTowards( Vector(0, -1, 0), dt );
+}
+
+void AdmTurret::draw() const
+{
+  WorldEntity::draw();
+
+#if 0
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+
+  glPushAttrib(GL_ENABLE_BIT);
+
+  glDisable(GL_LIGHTING);
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+  glLineWidth(2.0);
+
+
+  Vector mp = this->cannons->getAbsCoor();
+  Vector op = this->cannons->getAbsDir().apply( Vector(-1, 0, 0) );
+  op *= 100;
+  op += mp;
+
+  glColor3f(1.0, 0.0, 0.0 );
+  glBegin(GL_LINE_STRIP);
+    glVertex3f(mp.x, mp.y, mp.z);
+    glVertex3f(op.x, op.y, op.z);
+  glEnd();
+
+  op = this->myTarget->getAbsCoor() - ( this->cannons->getAbsCoor() );
+  op += mp;
+
+  glColor3f(0.0, 1.0, 0.0 );
+  glBegin(GL_LINE_STRIP);
+    glVertex3f(mp.x, mp.y, mp.z);
+    glVertex3f(op.x, op.y, op.z);
+  glEnd();
+  
+  glPopAttrib();
+  glPopMatrix();
+#endif
+}
+
+void AdmTurret::collidesWith(WorldEntity* entity, const Vector& location)
+{
+}
+
+void AdmTurret::activate()
+{
+}
+
+void AdmTurret::deactivate()
+{
+}
+
+void AdmTurret::addCannons( const TiXmlElement * root )
+{
+  this->cannons = new WorldEntity();
+	this->cannons->setParent(this);
+	this->cannons->loadParams( root );
+
+	//this->cannons->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+	//this->cannons->addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
+	
+	this->cannons->toList( getOMListNumber() );
+
+
+}
+
+void AdmTurret::addWeapon( const TiXmlElement * root )
+{
+	this->weapon = new BspWeapon();
+	this->weapon->setParent( this->cannons );
+	this->weapon->loadParams(root);
+	this->weapon->toList( getOMListNumber() );
+	//this->weapon->setAbsCoor( this->cannons->getAbsCoor() );
+	this->weapon->setAbsDir( this->weapon->getAbsDir() * Quaternion( PI, Vector(0, 1, 0) ) );
+}
+
+void AdmTurret::addSensor( const TiXmlElement * root )
+{
+  this->sensor = new WorldEntity();
+	this->sensor->setParent(this);
+	this->sensor->loadParams( root );
+
+	//this->sensor->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+	//this->sensor->addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
+	this->sensor->toList( getOMListNumber() );
+}
+
+void AdmTurret::moveTowards( Vector targetDir, float dt )
+{
+  if ( this->cannons->getParent() != NullParent::getNullParent() )
+  {
+    this->cannons->setParent( NullParent::getNullParent() );
+    this->cannons->shiftCoor( this->getAbsCoor() );
+    
+    this->sensor->setParent( NullParent::getNullParent() );
+    this->sensor->shiftCoor( this->getAbsCoor() );
+  }
+  
+  targetDir.normalize();
+  
+  float dAngle = dt;
+  
+  float bestResult = -1.0f;
+  Quaternion bestBodyRot;
+  Quaternion bestCannonRot;
+  float bestBodyAngle = 0.0f;
+  float bestCannonAngle = 0.0f;
+  
+   Quaternion baseRot(0, Vector(1, 0, 0));
+   if ( isCeil )
+   {
+     baseRot = Quaternion( PI, Vector( 1, 0, 0 ) );
+   }
+  
+  for ( int dBodyAngle = -1; dBodyAngle<2; dBodyAngle++ )
+  {
+    for ( int dCannonAngle = -1; dCannonAngle<2; dCannonAngle++ )
+    {
+      float bodyAngle = this->bodyAngle + dBodyAngle*dAngle;
+      float cannonAngle = this->cannonAngle + dCannonAngle*dAngle;
+      
+      while ( bodyAngle > 2*PI )
+        bodyAngle -= 2*PI;
+      while ( bodyAngle < 0 )
+        bodyAngle += 2*PI;
+      while ( cannonAngle > 2*PI )
+        cannonAngle -= 2*PI;
+      while ( cannonAngle < 0 )
+        cannonAngle += 2*PI;
+      
+      Quaternion bodyRot( bodyAngle, Vector( 0, 1, 0 ) );
+      Quaternion cannonRot( cannonAngle, Vector( 0, 0, 1) );
+      
+       bodyRot = baseRot * bodyRot;
+       cannonRot = baseRot * cannonRot;
+      
+      float result = (bodyRot * cannonRot).apply( Vector( -1, 0, 0 ) ).dot( targetDir );
+      
+      if ( result > bestResult )
+      {
+        bestResult = result;
+        bestBodyRot = bodyRot;
+        bestBodyAngle = bodyAngle;
+        bestCannonRot = cannonRot;
+        bestCannonAngle = cannonAngle;
+      }
+    }
+  }
+  
+  this->bodyAngle = bestBodyAngle;
+  this->cannonAngle = bestCannonAngle;
+  
+  this->setAbsDir( bestBodyRot );
+  this->cannons->setAbsDir( bestBodyRot * bestCannonRot );
+}
+
+void AdmTurret::updatePlayerVisible( )
+{
+  std::list<WorldEntity*>::iterator entityIterator;
+  // for all bsp managers check all entities
+  Vector pos = this->cannons->getAbsCoor();
+  Vector dir = this->myTarget->getAbsCoor() - pos;
+
+
+  this->playerVisible = true;
+  for( ObjectList<BspEntity>::const_iterator bspIterator = BspEntity::objectList().begin();
+       bspIterator != BspEntity::objectList().end();
+       bspIterator++) {
+      float res = (dynamic_cast<BspEntity*>(*bspIterator)->getBspManager())->checkCollisionRay( pos, dir, dir.len() + 1 );
+      
+      if ( res < dir.len() )
+        this->playerVisible = false;
+  }
+}
Index: trunk/src/world_entities/npcs/adm_turret.h
===================================================================
--- trunk/src/world_entities/npcs/adm_turret.h	(revision 10698)
+++ trunk/src/world_entities/npcs/adm_turret.h	(revision 10698)
@@ -0,0 +1,62 @@
+/*
+* file groundTurret.h
+* A weapon that is fix located, and automatically shooting at a target.
+*/
+
+#ifndef _ADM_TURRET_H
+#define _ADM_TURRET_H
+
+//#include "sound_buffer.h"
+//#include "sound_source.h"
+
+#include "world_entity.h"
+#include "weapons/bsp_weapon.h"
+
+class AdmTurret : public WorldEntity
+      {
+                   ObjectListDeclaration(AdmTurret);
+      public:
+                   AdmTurret ();
+                   AdmTurret (const  TiXmlElement* root);
+                   virtual ~AdmTurret();
+                   
+                   void init();
+                   void loadParams(const TiXmlElement* root);
+                   
+                   virtual void tick(float dt);
+                   virtual void draw() const;
+                   virtual void collidesWith(WorldEntity* entity, const Vector& location);
+                   
+                   virtual void activate();
+                   virtual void deactivate();
+                   
+                   virtual void setTarget(const std::string& target);
+                   
+      private:
+                   WorldEntity* cannons;
+                   WorldEntity* sensor;
+                   WorldEntity* myTarget;
+
+		   void addCannons(const TiXmlElement* root);
+		   void addSensor(const TiXmlElement* root);
+		   void addWeapon(const TiXmlElement* root);
+
+		   void moveTowards( Vector targetDir, float dt );
+                   
+                   float bodyAngle;
+                   float cannonAngle;
+                   
+                   bool isActive;
+                   float range;
+                   
+                   bool isCeil;
+                   void setType( const std::string& type );
+                   
+                   bool playerVisible;
+                   void updatePlayerVisible();
+
+		BspWeapon* weapon;
+      };
+
+#endif
+
Index: trunk/src/world_entities/npcs/npc.cc
===================================================================
--- trunk/src/world_entities/npcs/npc.cc	(revision 10695)
+++ trunk/src/world_entities/npcs/npc.cc	(revision 10698)
@@ -407,5 +407,5 @@
       {
         int slot = ws->getWeaponSlot();
-        int side = ws->getWeaponSide();
+//         int side = ws->getWeaponSide(); //FIXME / REMOVE: is not used
         this->getWeaponManager().setSlotPosition(slot, (*it).second->getCenter());
         this->getWeaponManager().setSlotDirection(slot, ws->getRelDir());
