Index: code/branches/pickup2/src/orxonox/worldentities/CMakeLists.txt
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/CMakeLists.txt	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/CMakeLists.txt	(revision 6412)
@@ -7,4 +7,5 @@
 
   BigExplosion.cc
+  EffectContainer.cc
   ExplosionChunk.cc
   CameraPosition.cc
Index: code/branches/pickup2/src/orxonox/worldentities/ControllableEntity.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/ControllableEntity.cc	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/ControllableEntity.cc	(revision 6412)
@@ -36,4 +36,5 @@
 #include "core/GameMode.h"
 #include "core/XMLPort.h"
+#include "network/NetworkFunction.h"
 
 #include "Scene.h"
@@ -47,4 +48,7 @@
 {
     CreateFactory(ControllableEntity);
+
+    registerMemberNetworkFunction( ControllableEntity, fire );
+    registerMemberNetworkFunction( ControllableEntity, setTargetInternal );
 
     ControllableEntity::ControllableEntity(BaseObject* creator) : MobileEntity(creator)
@@ -62,7 +66,9 @@
         this->camera_ = 0;
         this->xmlcontroller_ = 0;
+        this->controller_ = 0;
         this->reverseCamera_ = 0;
         this->bDestroyWhenPlayerLeft_ = false;
         this->cameraPositionRootNode_ = this->node_->createChildSceneNode();
+        this->currentCameraPosition_ = 0;
         this->bMouseLook_ = false;
         this->mouseLookSpeed_ = 200;
@@ -169,4 +175,5 @@
             {
                 this->cameraPositions_.front()->attachCamera(this->camera_);
+                this->currentCameraPosition_ = this->cameraPositions_.front().get();
             }
             else if (this->cameraPositions_.size() > 0)
@@ -178,7 +185,13 @@
                         ++it;
                         if (it != this->cameraPositions_.end())
+                        {
                             (*it)->attachCamera(this->camera_);
+                            this->currentCameraPosition_ = *it;
+                        }
                         else
+                        {
                             (*this->cameraPositions_.begin())->attachCamera(this->camera_);
+                            this->currentCameraPosition_ = *this->cameraPositions_.begin();
+                        }
                         break;
                     }
@@ -188,4 +201,5 @@
             {
                 this->camera_->attachToNode(this->cameraPositionRootNode_);
+                this->currentCameraPosition_ = 0;
             }
         }
@@ -198,4 +212,11 @@
         if (!this->bMouseLook_)
             this->cameraPositionRootNode_->setOrientation(Quaternion::IDENTITY);
+        if (this->getCamera())
+        {
+            if (!this->bMouseLook_&& this->currentCameraPosition_->getDrag())
+                this->getCamera()->setDrag(true);
+            else
+                this->getCamera()->setDrag(false);
+        }
     }
 
@@ -216,4 +237,37 @@
         if (this->bMouseLook_)
             this->cameraPositionRootNode_->roll(Radian(value.y * this->mouseLookSpeed_), Ogre::Node::TS_LOCAL);
+    }
+
+    void ControllableEntity::fire(unsigned int firemode)
+    {
+        if(GameMode::isMaster())
+        {
+            this->fired(firemode);
+        }
+        else
+        {
+            callMemberNetworkFunction(ControllableEntity, fire, this->getObjectID(), 0, firemode);
+        }
+    }
+
+    void ControllableEntity::setTarget( WorldEntity* target )
+    {
+        this->target_ = target;
+        if ( !GameMode::isMaster() )
+        {
+            if ( target != 0 )
+            {
+                callMemberNetworkFunction(ControllableEntity, setTargetInternal, this->getObjectID(), 0, target->getObjectID() );
+            }
+           else
+           {
+                callMemberNetworkFunction(ControllableEntity, setTargetInternal, this->getObjectID(), 0, OBJECTID_UNKNOWN );
+           }
+        }
+    }
+
+    void ControllableEntity::setTargetInternal( uint32_t targetID )
+    {
+        this->setTarget( orxonox_cast<WorldEntity*>(Synchronisable::getSynchronisable(targetID)) );
     }
 
@@ -279,15 +333,21 @@
             this->camera_ = new Camera(this);
             this->camera_->requestFocus();
-            if (this->cameraPositionTemplate_ != "")
+            if (!this->cameraPositionTemplate_.empty())
                 this->addTemplate(this->cameraPositionTemplate_);
             if (this->cameraPositions_.size() > 0)
+            {
                 this->cameraPositions_.front()->attachCamera(this->camera_);
+                this->currentCameraPosition_ = this->cameraPositions_.front();
+            }
             else
+            {
                 this->camera_->attachToNode(this->cameraPositionRootNode_);
+                this->currentCameraPosition_ = 0;
+            }
         }
 
         if (!this->hud_ && GameMode::showsGraphics())
         {
-            if (this->hudtemplate_ != "")
+            if (!this->hudtemplate_.empty())
             {
                 this->hud_ = new OverlayGroup(this);
Index: code/branches/pickup2/src/orxonox/worldentities/ControllableEntity.h
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/ControllableEntity.h	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/ControllableEntity.h	(revision 6412)
@@ -84,5 +84,6 @@
                 { this->rotateRoll(Vector2(value, 0)); }
 
-            virtual void fire(unsigned int firemode) {}
+            void fire(unsigned int firemode);
+            virtual void fired(unsigned int firemode) {}
             virtual void reload() {}
 
@@ -139,4 +140,14 @@
             inline Controller* getXMLController() const
                 { return this->xmlcontroller_; }
+
+            inline Controller* getController() const
+                { return this->controller_; }
+            inline void setController(Controller* val)
+                { this->controller_ = val; }
+
+            virtual void setTarget( WorldEntity* target );
+            virtual WorldEntity* getTarget()
+                { return this->target_.get(); }
+            void setTargetInternal( uint32_t targetID );
 
         protected:
@@ -199,7 +210,10 @@
             Ogre::SceneNode* cameraPositionRootNode_;
             std::list<SmartPtr<CameraPosition> > cameraPositions_;
+            CameraPosition* currentCameraPosition_;
             std::string cameraPositionTemplate_;
             Controller* xmlcontroller_;
+            Controller* controller_;
             CameraPosition* reverseCamera_;
+            WeakPtr<WorldEntity> target_;
     };
 }
Index: code/branches/pickup2/src/orxonox/worldentities/EffectContainer.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/EffectContainer.cc	(revision 6412)
+++ code/branches/pickup2/src/orxonox/worldentities/EffectContainer.cc	(revision 6412)
@@ -0,0 +1,111 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   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
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "EffectContainer.h"
+
+extern "C" {
+#include <lua.h>
+}
+
+#include "core/CoreIncludes.h"
+#include "core/LuaState.h"
+#include "core/XMLPort.h"
+#include "worldentities/WorldEntity.h"
+
+namespace orxonox
+{
+    CreateFactory(EffectContainer);
+
+    EffectContainer::EffectContainer(BaseObject* creator)
+        : BaseObject(creator)
+        , lua_(NULL)
+    {
+        RegisterObject(EffectContainer);
+    }
+
+    EffectContainer::~EffectContainer()
+    {
+    }
+
+    void EffectContainer::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(EffectContainer, XMLPort, xmlelement, mode);
+        XMLPortParam(EffectContainer, "condition", setCondition, getCondition, xmlelement, mode);
+        XMLPortObject(EffectContainer, WorldEntity, "", addEffect, getEffect, xmlelement, mode);
+    }
+
+    void EffectContainer::setCondition(const std::string& condition)
+    {
+        // TODO: Watch out for code injection!
+        this->condition_ = condition;
+        if (this->lua_)
+        {
+            this->lua_->doString(
+                this->functionName_ + " = function() \n"
+                "    return (" + condition + ") \n"
+                "end"
+            );
+        }
+    }
+
+    void EffectContainer::setLuaState(LuaState* state, const std::string& functionName)
+    {
+        this->functionName_ = functionName;
+        this->lua_ = state;
+        this->setCondition(this->condition_);
+    }
+
+    void EffectContainer::addEffect(WorldEntity* effect)
+    {
+        this->effects_.push_back(effect);
+    }
+
+    WorldEntity* EffectContainer::getEffect(unsigned int index) const
+    {
+        unsigned int i = 0;
+        for (std::vector<WorldEntity*>::const_iterator it = this->effects_.begin(); it != this->effects_.end(); ++it)
+            if (i == index)
+                return (*it);
+        return NULL;
+    }
+
+    void EffectContainer::updateCondition()
+    {
+        if (this->lua_)
+        {
+            lua_getglobal(this->lua_->getInternalLuaState(), this->functionName_.c_str());
+            lua_call(this->lua_->getInternalLuaState(), 0, 1);
+            bool result = (bool)lua_toboolean(this->lua_->getInternalLuaState(), -1);
+            lua_pop(this->lua_->getInternalLuaState(), 1);
+            for (std::vector<WorldEntity*>::const_iterator it = this->effects_.begin(); it != this->effects_.end(); ++it)
+            {
+                (*it)->setMainState(result);
+            }
+        }
+    }
+}
Index: code/branches/pickup2/src/orxonox/worldentities/EffectContainer.h
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/EffectContainer.h	(revision 6412)
+++ code/branches/pickup2/src/orxonox/worldentities/EffectContainer.h	(revision 6412)
@@ -0,0 +1,71 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   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
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _EffectContainer_H__
+#define _EffectContainer_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include <vector>
+#include "core/BaseObject.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport EffectContainer : public BaseObject
+    {
+        public:
+            EffectContainer(BaseObject* creator);
+            virtual ~EffectContainer();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
+            void setLuaState(LuaState* state, const std::string& functionName);
+
+            void setCondition(const std::string& condition);
+            inline const std::string& getCondition() const
+                { return this->condition_; }
+
+            void addEffect(WorldEntity* effect);
+            WorldEntity* getEffect(unsigned int index) const;
+
+            inline std::vector<WorldEntity*>::const_iterator getEffectsBegin()
+                { return this->effects_.begin(); }
+            inline std::vector<WorldEntity*>::const_iterator getEffectsEnd()
+                { return this->effects_.end(); }
+
+            void updateCondition();
+
+        private:
+            std::string               condition_;
+            std::string               functionName_;
+            LuaState*                 lua_;
+            std::vector<WorldEntity*> effects_;
+    };
+}
+
+#endif /* _EffectContainer_H__ */
Index: code/branches/pickup2/src/orxonox/worldentities/MovableEntity.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/MovableEntity.cc	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/MovableEntity.cc	(revision 6412)
@@ -79,5 +79,6 @@
             if (victim)
             {
-                victim->damage(this->collisionDamage_ * (victim->getVelocity() - this->getVelocity()).length());
+                float damage = this->collisionDamage_ * (victim->getVelocity() - this->getVelocity()).length();
+                victim->hit(0, contactPoint, damage);
             }
         }
Index: code/branches/pickup2/src/orxonox/worldentities/MovableEntity.h
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/MovableEntity.h	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/MovableEntity.h	(revision 6412)
@@ -70,8 +70,8 @@
 
             inline void setEnableCollisionDamage(bool c)
-            { 
-                this->enableCollisionDamage_ = c; 
+            {
+                this->enableCollisionDamage_ = c;
                 this->enableCollisionCallback();
-            } 
+            }
 
             inline bool getEnableCollisionDamage()
Index: code/branches/pickup2/src/orxonox/worldentities/StaticEntity.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/StaticEntity.cc	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/StaticEntity.cc	(revision 6412)
@@ -42,5 +42,5 @@
     {
         RegisterObject(StaticEntity);
-        
+
         this->setPriority(Priority::VeryLow);
 
Index: code/branches/pickup2/src/orxonox/worldentities/WorldEntity.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/WorldEntity.cc	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/WorldEntity.cc	(revision 6412)
@@ -472,25 +472,33 @@
     //! Attaches an Ogre::MovableObject to this WorldEntity.
     void WorldEntity::attachOgreObject(Ogre::MovableObject* object)
-        { this->node_->attachObject(object); }
+    {
+        this->node_->attachObject(object);
+        object->setUserObject(this);
+    }
+
     void WorldEntity::attachOgreObject(Ogre::BillboardSet* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::Camera* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::Entity* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::ParticleSystem* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
 
     //! Detaches an Ogre::MovableObject from this WorldEntity.
     void WorldEntity::detachOgreObject(Ogre::MovableObject* object)
-        { this->node_->detachObject(object); }
+    {
+        object->setUserObject(NULL);
+        this->node_->detachObject(object);
+    }
+
     void WorldEntity::detachOgreObject(Ogre::BillboardSet* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::Camera* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::Entity* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::ParticleSystem* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
 
     //! Detaches an Ogre::MovableObject (by string) from this WorldEntity.
@@ -646,5 +654,5 @@
     /**
     @brief
-        Makes this WorldEntity look a specific target location.
+        Makes this WorldEntity look at a specific target location.
     @param relativeTo
         @see WorldEntity::TransformSpace
@@ -806,5 +814,5 @@
     void WorldEntity::setCollisionTypeStr(const std::string& typeStr)
     {
-        std::string typeStrLower = getLowercase(typeStr);
+        const std::string& typeStrLower = getLowercase(typeStr);
         CollisionType type;
         if (typeStrLower == "dynamic")
@@ -913,5 +921,5 @@
     }
 
-    //! Copies our own parameters for restitution, angular factor, dampings and friction to the bullet rigid body.
+    //! Copies our own parameters for restitution, angular factor, damping and friction to the bullet rigid body.
     void WorldEntity::internalSetPhysicsProps()
     {
Index: code/branches/pickup2/src/orxonox/worldentities/WorldEntity.h
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/WorldEntity.h	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/WorldEntity.h	(revision 6412)
@@ -33,4 +33,5 @@
 #include "OrxonoxPrereqs.h"
 
+#include <OgreUserDefinedObject.h>
 #ifdef ORXONOX_RELEASE
 #  include <OgreSceneNode.h>
@@ -55,5 +56,5 @@
 
         The basic task of the WorldEntity is provide a location, a direction and a scaling and the possibility
-        to create an entire hierarchy of derivated objects.
+        to create an entire hierarchy of derived objects.
         It is also the basis for the physics interface to the Bullet physics engine.
         Every WorldEntity can have a specific collision type: @see CollisionType
@@ -63,11 +64,11 @@
         There is also support for attaching WorldEntities with physics to each other. Currently, the collision shape
         of both objects simply get merged into one larger shape (for static collision type).
-        The phyiscal body that is internally stored and administrated has the following supported properties:
-        - Restitution, angular factor, linear damping, angular damping, fricition, mass and collision shape.
+        The physical body that is internally stored and administrated has the following supported properties:
+        - Restitution, angular factor, linear damping, angular damping, friction, mass and collision shape.
         You can get more information at the corresponding set function.
 
         Collision shapes: These are controlled by the internal WorldEntityCollisionShape. @see WorldEntityCollisionShape.
     */
-    class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState
+    class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState, public Ogre::UserDefinedObject
     {
         friend class Scene;
@@ -318,5 +319,5 @@
                 Sets an artificial parameter that tells how much torque is applied when you apply a non-central force.
 
-                Normally the angular factor is 1, which means it's physically 'correct'. Howerver if you have a player
+                Normally the angular factor is 1, which means it's physically 'correct'. However if you have a player
                 character that should not rotate when hit sideways, you can set the angular factor to 0.
             */
@@ -394,5 +395,5 @@
                 You can override this function in a derived class to constrain the collision to e.g. None or Dynamic.
                 A projectile may not prove very useful if there is no physical body. Simply set the CollisionType
-                in its constructor and override this method. But be careful that a derived classe's virtual functions
+                in its constructor and override this method. But be careful that a derived class's virtual functions
                 don't yet exist in the constructor if a base class.
             */
Index: code/branches/pickup2/src/orxonox/worldentities/pawns/Pawn.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/pawns/Pawn.cc	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/pawns/Pawn.cc	(revision 6412)
@@ -38,4 +38,5 @@
 #include "PawnManager.h"
 #include "infos/PlayerInfo.h"
+#include "controllers/Controller.h"
 #include "gametypes/Gametype.h"
 #include "graphics/ParticleSpawner.h"
@@ -52,6 +53,4 @@
     CreateFactory(Pawn);
 
-    registerMemberNetworkFunction( Pawn, doFire );
-
     Pawn::Pawn(BaseObject* creator) : ControllableEntity(creator)
     {
@@ -69,4 +68,6 @@
 
         this->spawnparticleduration_ = 3.0f;
+
+        this->aimPosition_ = Vector3::ZERO;
 
         //TODO: Remove.
@@ -111,5 +112,5 @@
         XMLPortObject(Pawn, WeaponSlot, "weaponslots", addWeaponSlot, getWeaponSlot, xmlelement, mode);
         XMLPortObject(Pawn, WeaponSet, "weaponsets", addWeaponSet, getWeaponSet, xmlelement, mode);
-        XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPack, getWeaponPack, xmlelement, mode);
+        XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPackXML, getWeaponPack, xmlelement, mode);
     }
 
@@ -120,4 +121,5 @@
         registerVariable(this->initialHealth_, VariableDirection::ToClient);
         registerVariable(this->bReload_,       VariableDirection::ToServer);
+        registerVariable(this->aimPosition_,   Bidirectionality::ServerMaster, 0, true);
     }
 
@@ -167,5 +169,5 @@
     void Pawn::hit(Pawn* originator, const Vector3& force, float damage)
     {
-        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator))
+        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
         {
             this->damage(damage, originator);
@@ -176,4 +178,17 @@
     }
 
+    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage)
+    {
+        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
+        {
+            this->damage(damage, originator);
+
+            if ( this->getController() )
+                this->getController()->hit(originator, contactpoint, damage);
+
+            // play hit effect
+        }
+    }
+
     void Pawn::kill()
     {
@@ -185,5 +200,5 @@
     {
         // play spawn effect
-        if (this->spawnparticlesource_ != "")
+        if (!this->spawnparticlesource_.empty())
         {
             ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
@@ -264,22 +279,8 @@
     }
 
-    void Pawn::fire(unsigned int firemode)
-    {
-        this->doFire(firemode);
-    }
-
-    void Pawn::doFire(uint8_t firemode)
-    {
-        if(GameMode::isMaster())
-        {
-            if (this->weaponSystem_)
-                this->weaponSystem_->fire(firemode);
-        }
-        else
-        {
-            callMemberNetworkFunction(Pawn, doFire, this->getObjectID(), 0, firemode);
-            if (this->weaponSystem_)
-                this->weaponSystem_->fire(firemode);
-        }
+    void Pawn::fired(unsigned int firemode)
+    {
+        if (this->weaponSystem_)
+            this->weaponSystem_->fire(firemode);
     }
 
@@ -343,4 +344,11 @@
     }
 
+    void Pawn::addWeaponPackXML(WeaponPack * wPack)
+    {
+        if (this->weaponSystem_)
+            if (!this->weaponSystem_->addWeaponPack(wPack))
+                wPack->destroy();
+    }
+
     WeaponPack * Pawn::getWeaponPack(unsigned int index) const
     {
Index: code/branches/pickup2/src/orxonox/worldentities/pawns/Pawn.h
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/pawns/Pawn.h	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/pawns/Pawn.h	(revision 6412)
@@ -76,11 +76,10 @@
                 { return this->lastHitOriginator_; }
 
-            virtual void damage(float damage, Pawn* originator = 0);
             virtual void hit(Pawn* originator, const Vector3& force, float damage);
+            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
             virtual void kill();
 
-            virtual void fire(unsigned int firemode);
+            virtual void fired(unsigned int firemode);
             virtual void reload();
-            virtual void doFire(uint8_t firemode);
             virtual void postSpawn();
 
@@ -90,4 +89,5 @@
             WeaponSet * getWeaponSet(unsigned int index) const;
             void addWeaponPack(WeaponPack * wPack);
+            void addWeaponPackXML(WeaponPack * wPack);
             WeaponPack * getWeaponPack(unsigned int index) const;
 
@@ -119,4 +119,9 @@
             virtual void startLocalHumanControl();
 
+            void setAimPosition( Vector3 position )
+                { this->aimPosition_ = position; }
+            Vector3 getAimPosition()
+                { return this->aimPosition_; }
+
         protected:
             virtual void setPlayer(PlayerInfo* player);
@@ -127,4 +132,6 @@
             virtual void deatheffect();
             virtual void spawneffect();
+
+            virtual void damage(float damage, Pawn* originator = 0);
 
             bool bAlive_;
@@ -149,4 +156,6 @@
             inline void setWeaponSystem(WeaponSystem* weaponsystem)
                 { this->weaponSystem_ = weaponsystem; }
+
+            Vector3 aimPosition_;
     };
 }
Index: code/branches/pickup2/src/orxonox/worldentities/pawns/SpaceShip.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/pawns/SpaceShip.cc	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/pawns/SpaceShip.cc	(revision 6412)
@@ -187,5 +187,5 @@
     void SpaceShip::loadEngineTemplate()
     {
-        if (this->enginetemplate_ != "")
+        if (!this->enginetemplate_.empty())
         {
             Template* temp = Template::getTemplate(this->enginetemplate_);
Index: code/branches/pickup2/src/orxonox/worldentities/pawns/Spectator.cc
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/pawns/Spectator.cc	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/pawns/Spectator.cc	(revision 6412)
@@ -189,5 +189,5 @@
     }
 
-    void Spectator::fire(unsigned int firemode)
+    void Spectator::fired(unsigned int firemode)
     {
         if (this->getPlayer())
Index: code/branches/pickup2/src/orxonox/worldentities/pawns/Spectator.h
===================================================================
--- code/branches/pickup2/src/orxonox/worldentities/pawns/Spectator.h	(revision 6405)
+++ code/branches/pickup2/src/orxonox/worldentities/pawns/Spectator.h	(revision 6412)
@@ -55,5 +55,5 @@
             virtual void rotateRoll(const Vector2& value);
 
-            virtual void fire(unsigned int firemode);
+            virtual void fired(unsigned int firemode);
             virtual void greet();
 
