Changeset 2493

Timestamp:

Dec 17, 2008, 2:10:11 AM (16 years ago)

Author:

landauf

Message:

merged weapon2 branch to presentation

Location:

code/branches/presentation

Files:

• . (modified) (1 prop)
• bin/def_keybindings.ini (modified) (1 diff)
• src/core/Template.cc (modified) (1 prop)
• src/core/Template.h (modified) (1 prop)
• src/core/XMLFile.h (modified) (1 prop)
• src/core/XMLIncludes.h (modified) (1 prop)
• src/orxonox/CameraManager.cc (modified) (1 prop)
• src/orxonox/CameraManager.h (modified) (1 prop)
• src/orxonox/OrxonoxPrereqs.h (modified) (2 diffs)
• src/orxonox/objects/controllers/AIController.cc (modified) (5 diffs)
• src/orxonox/objects/controllers/ArtificialController.cc (modified) (5 diffs)
• src/orxonox/objects/controllers/ArtificialController.h (modified) (2 diffs)
• src/orxonox/objects/controllers/HumanController.cc (modified) (2 diffs)
• src/orxonox/objects/pickup/Usable.h (modified) (1 prop)
• src/orxonox/objects/quest/AddQuest.cc (modified) (1 prop)
• src/orxonox/objects/quest/AddQuest.h (modified) (1 prop)
• src/orxonox/objects/quest/AddQuestHint.cc (modified) (1 prop)
• src/orxonox/objects/quest/AddQuestHint.h (modified) (1 prop)
• src/orxonox/objects/quest/AddReward.cc (modified) (1 prop)
• src/orxonox/objects/quest/AddReward.h (modified) (1 prop)
• src/orxonox/objects/quest/ChangeQuestStatus.cc (modified) (1 prop)
• src/orxonox/objects/quest/ChangeQuestStatus.h (modified) (1 prop)
• src/orxonox/objects/quest/CompleteQuest.cc (modified) (1 prop)
• src/orxonox/objects/quest/CompleteQuest.h (modified) (1 prop)
• src/orxonox/objects/quest/FailQuest.cc (modified) (1 prop)
• src/orxonox/objects/quest/FailQuest.h (modified) (1 prop)
• src/orxonox/objects/quest/GlobalQuest.cc (modified) (1 prop)
• src/orxonox/objects/quest/GlobalQuest.h (modified) (1 prop)
• src/orxonox/objects/quest/LocalQuest.cc (modified) (1 prop)
• src/orxonox/objects/quest/LocalQuest.h (modified) (1 prop)
• src/orxonox/objects/quest/Quest.cc (modified) (1 prop)
• src/orxonox/objects/quest/Quest.h (modified) (1 prop)
• src/orxonox/objects/quest/QuestDescription.cc (modified) (1 prop)
• src/orxonox/objects/quest/QuestDescription.h (modified) (1 prop)
• src/orxonox/objects/quest/QuestEffect.cc (modified) (1 prop)
• src/orxonox/objects/quest/QuestEffect.h (modified) (1 prop)
• src/orxonox/objects/quest/QuestHint.cc (modified) (1 prop)
• src/orxonox/objects/quest/QuestHint.h (modified) (1 prop)
• src/orxonox/objects/quest/QuestItem.cc (modified) (1 prop)
• src/orxonox/objects/quest/QuestItem.h (modified) (1 prop)
• src/orxonox/objects/quest/QuestManager.cc (modified) (1 prop)
• src/orxonox/objects/quest/QuestManager.h (modified) (1 prop)
• src/orxonox/objects/quest/Rewardable.cc (modified) (1 prop)
• src/orxonox/objects/quest/Rewardable.h (modified) (1 prop)
• src/orxonox/objects/weaponSystem/CMakeLists.txt (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/Munition.cc (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/Munition.h (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/Weapon.cc (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/Weapon.h (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/WeaponPack.cc (copied) (copied from code/branches/weapon2/src/orxonox/objects/weaponSystem/WeaponPack.cc) (3 diffs)
• src/orxonox/objects/weaponSystem/WeaponPack.h (copied) (copied from code/branches/weapon2/src/orxonox/objects/weaponSystem/WeaponPack.h)
• src/orxonox/objects/weaponSystem/WeaponSet.cc (modified) (3 diffs)
• src/orxonox/objects/weaponSystem/WeaponSet.h (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/WeaponSlot.cc (modified) (3 diffs)
• src/orxonox/objects/weaponSystem/WeaponSlot.h (modified) (3 diffs)
• src/orxonox/objects/weaponSystem/WeaponSystem.cc (modified) (6 diffs, 1 prop)
• src/orxonox/objects/weaponSystem/WeaponSystem.h (modified) (2 diffs, 1 prop)
• src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.cc (modified) (1 diff)
• src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.h (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/projectiles/BillboardProjectile.cc (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/projectiles/BillboardProjectile.h (modified) (1 diff)
• src/orxonox/objects/weaponSystem/projectiles/ParticleProjectile.cc (modified) (5 diffs)
• src/orxonox/objects/weaponSystem/projectiles/ParticleProjectile.h (modified) (1 diff)
• src/orxonox/objects/weaponSystem/projectiles/Projectile.cc (modified) (8 diffs)
• src/orxonox/objects/weaponSystem/projectiles/Projectile.h (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt (modified) (1 diff)
• src/orxonox/objects/weaponSystem/weapons/Fusion.cc (copied) (copied from code/branches/weapon2/src/orxonox/objects/weaponSystem/weapons/Fusion.cc) (3 diffs)
• src/orxonox/objects/weaponSystem/weapons/Fusion.h (copied) (copied from code/branches/weapon2/src/orxonox/objects/weaponSystem/weapons/Fusion.h)
• src/orxonox/objects/weaponSystem/weapons/LaserGun.cc (modified) (2 diffs)
• src/orxonox/objects/weaponSystem/weapons/LaserGun.h (modified) (2 diffs)
• src/orxonox/objects/worldentities/Backlight.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/Backlight.h (modified) (1 prop)
• src/orxonox/objects/worldentities/Camera.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/Camera.h (modified) (1 prop)
• src/orxonox/objects/worldentities/ControllableEntity.h (modified) (2 diffs)
• src/orxonox/objects/worldentities/ParticleSpawner.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/ParticleSpawner.h (modified) (1 prop)
• src/orxonox/objects/worldentities/pawns/Pawn.cc (modified) (9 diffs)
• src/orxonox/objects/worldentities/pawns/Pawn.h (modified) (4 diffs)
• src/orxonox/objects/worldentities/pawns/Spectator.cc (modified) (1 diff)
• src/orxonox/objects/worldentities/pawns/Spectator.h (modified) (1 diff)
• src/orxonox/objects/worldentities/triggers/DistanceTrigger.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/triggers/DistanceTrigger.h (modified) (1 prop)
• src/orxonox/objects/worldentities/triggers/Trigger.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/triggers/Trigger.h (modified) (1 prop)
• src/orxonox/tools/BillboardSet.h (modified) (1 diff)
• src/tolua/tolua-5.1.pkg (modified) (1 prop)
• src/util (modified) (1 prop)
• src/util/Exception.cc (modified) (1 prop)
• src/util/Exception.h (modified) (1 prop)
• src/util/SignalHandler.cc (modified) (1 prop)
• src/util/SignalHandler.h (modified) (1 prop)
• visual_studio/vc8/audio.vsprops (modified) (1 prop)
• visual_studio/vc8/base.vsprops (modified) (1 prop)
• visual_studio/vc8/ceguilua.vsprops (modified) (1 prop)
• visual_studio/vc8/core.vsprops (modified) (1 prop)
• visual_studio/vc8/cpptcl.vsprops (modified) (1 prop)
• visual_studio/vc8/debug.vsprops (modified) (1 prop)
• visual_studio/vc8/directories.vsprops (modified) (1 prop)
• visual_studio/vc8/lua.vsprops (modified) (1 prop)
• visual_studio/vc8/network.vsprops (modified) (1 prop)
• visual_studio/vc8/orxonox.vsprops (modified) (1 prop)
• visual_studio/vc8/orxonox_vc8.sln (modified) (1 prop)
• visual_studio/vc8/release.vsprops (modified) (1 prop)
• visual_studio/vc8/tinyxml.vcproj (modified) (1 prop)
• visual_studio/vc8/tinyxml.vsprops (modified) (1 prop)
• visual_studio/vc8/tolua.vsprops (modified) (1 prop)
• visual_studio/vc8/toluagen.vcproj (modified) (1 prop)
• visual_studio/vc8/toluagen.vsprops (modified) (1 prop)
• visual_studio/vc8/toluagen_orxonox.vcproj (modified) (1 prop)
• visual_studio/vc8/toluagen_orxonox.vsprops (modified) (1 prop)
• visual_studio/vc8/util.vsprops (modified) (1 prop)

code/branches/presentation/bin/def_keybindings.ini

@@ -247 +247 @@
 MouseLeft="fire"
 MouseMiddle=
-MouseRight=
+MouseRight="altfire"
 MouseWheel1Down=
 MouseWheel1Up=

code/branches/presentation/src/orxonox/OrxonoxPrereqs.h

@@ -72 +72 @@
         };
     }
+
+    //put here all existing munitionTypes
+    namespace MunitionType
+    {
+
+
+
+        enum Enum
+        { laserGunMunition };
+    }
+
+    //put here all weapon fire modes.
+    //they have to be added to Pawn and HumanController, too.
+    namespace WeaponMode
+    {
+        enum Enum
+        {
+            fire     = 0x1,
+            altFire  = 0x2,
+            altFire2 = 0x4
+        };
+    }
+
 
     class GraphicsEngine;
@@ -146 +169 @@
     class WeaponSet;
     class WeaponSlot;
+    class WeaponPack;
     class Weapon;
     class Munition;
+    class LaserGun;
+    class LaserGunMunition;
 
     class EventListener;

code/branches/presentation/src/orxonox/objects/controllers/AIController.cc

@@ -57 +57 @@
         float random;
         float maxrand = 100.0f / ACTION_INTERVAL;
-/*
+
         // search enemy
         random = rnd(maxrand);
@@ -72 +72 @@
         if (random < 10 && (this->target_))
             this->searchNewTarget();
-*/
+
         // fly somewhere
         random = rnd(maxrand);
@@ -87 +87 @@
         if (random < 30 && (this->bHasTargetPosition_ && !this->target_))
             this->searchRandomTargetPosition();
-/*
+
         // shoot
         random = rnd(maxrand);
@@ -97 +97 @@
         if (random < 25 && (this->bShooting_))
             this->bShooting_ = false;
-*/
     }
 
@@ -112 +111 @@
 
         if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(500) && this->isLookingAtTarget(Ogre::Math::PI / 20.0))
-            this->getControllableEntity()->fire();
+            this->getControllableEntity()->fire(WeaponMode::fire);
 
         SUPER(AIController, tick, dt);

code/branches/presentation/src/orxonox/objects/controllers/ArtificialController.cc

@@ -56 +56 @@
 
         Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, this->targetPosition_);
+        float distance = (this->targetPosition_ - this->getControllableEntity()->getPosition()).length();
 
-        float distance = (this->targetPosition_ - this->getControllableEntity()->getPosition()).length();
-        if (this->target_ || distance > 50)
+        if (this->target_ || distance > 10)
         {
             // Multiply with 0.8 to make them a bit slower
-            this->getControllableEntity()->rotateYaw(0.8 * sgn(coord.x) * coord.x*coord.x);
+            this->getControllableEntity()->rotateYaw(-0.8 * sgn(coord.x) * coord.x*coord.x);
             this->getControllableEntity()->rotatePitch(0.8 * sgn(coord.y) * coord.y*coord.y);
         }
 
-        if (this->target_ && distance < 1000 && this->getControllableEntity()->getVelocity().squaredLength() > this->target_->getVelocity().squaredLength())
+        if (this->target_ && distance < 200 && this->getControllableEntity()->getVelocity().squaredLength() > this->target_->getVelocity().squaredLength())
             this->getControllableEntity()->moveFrontBack(-0.5); // They don't brake with full power to give the player a chance
         else
@@ -73 +73 @@
     void ArtificialController::searchRandomTargetPosition()
     {
-        this->targetPosition_ = Vector3(rnd(-5000,5000), rnd(-5000,5000), rnd(-5000,5000));
+        this->targetPosition_ = Vector3(rnd(-2000,2000), rnd(-2000,2000), rnd(-2000,2000));
         this->bHasTargetPosition_ = true;
     }
@@ -88 +88 @@
         {
 //            if (it->getTeamNr() != this->getTeamNr())
+            if ((ControllableEntity*)(*it) != this->getControllableEntity())
             {
                 float speed = this->getControllableEntity()->getVelocity().length();
@@ -113 +114 @@
             return;
 
-        static const float hardcoded_projectile_speed = 500;
+        static const float hardcoded_projectile_speed = 1250;
 
-        this->targetPosition_ = getPredictedPosition(this->getControllableEntity()->getPosition(), hardcoded_projectile_speed, this->target_->getPosition(), this->target_->getOrientation() * this->target_->getVelocity());
+        this->targetPosition_ = getPredictedPosition(this->getControllableEntity()->getPosition(), hardcoded_projectile_speed, this->target_->getPosition(), this->target_->getVelocity());
         this->bHasTargetPosition_ = (this->targetPosition_ != Vector3::ZERO);
     }
@@ -138 +139 @@
     }
 
-    void ArtificialController::shipDied(Pawn* ship)
+    void ArtificialController::destroyedPawn(Pawn* ship)
     {
         if (ship == this->target_)

code/branches/presentation/src/orxonox/objects/controllers/ArtificialController.h

@@ -33 +33 @@
 
 #include "Controller.h"
+#include "objects/worldentities/pawns/Pawn.h"
 #include "util/Math.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport ArtificialController : public Controller
+    class _OrxonoxExport ArtificialController : public Controller, public PawnListener
     {
         public:
@@ -43 +44 @@
             virtual ~ArtificialController();
 
-            void shipDied(Pawn* ship);
+            virtual void destroyedPawn(Pawn* pawn);
 
         protected:

code/branches/presentation/src/orxonox/objects/controllers/HumanController.cc

@@ -110 +110 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->fire();
+            HumanController::localController_s->controllableEntity_->fire(WeaponMode::fire);
     }
 
@@ -116 +116 @@
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->altFire();
+            HumanController::localController_s->controllableEntity_->fire(WeaponMode::altFire);
     }
 

code/branches/presentation/src/orxonox/objects/weaponSystem/CMakeLists.txt

@@ -2 +2 @@
   Munition.cc
   Weapon.cc
+  WeaponPack.cc
   WeaponSet.cc
   WeaponSlot.cc
@@ -7 +8 @@
 )
 
-#ADD_SOURCE_DIRECTORY(SRC_FILES munitions)
-#ADD_SOURCE_DIRECTORY(SRC_FILES projectiles)
-#ADD_SOURCE_DIRECTORY(SRC_FILES weapons)
+ADD_SOURCE_DIRECTORY(SRC_FILES munitions)
+ADD_SOURCE_DIRECTORY(SRC_FILES projectiles)
+ADD_SOURCE_DIRECTORY(SRC_FILES weapons)
 
 ADD_SOURCE_FILES(SRC_FILES)

code/branches/presentation/src/orxonox/objects/weaponSystem/Munition.cc

@@ -37 +37 @@
 namespace orxonox
 {
+    CreateFactory(Munition);
+
     Munition::Munition(BaseObject* creator) : BaseObject(creator)
     {
@@ -46 +48 @@
     }
 
+    unsigned int Munition::bullets()
+    {
+        if (this->bullets_ > 0)
+            return bullets_;
+        else
+            return 0;
+    }
+
+    unsigned int Munition::magazines()
+    {
+        if (this->magazines_ > 0)
+            return magazines_;
+        else
+            return 0;
+    }
+
+    void Munition::setMaxBullets(unsigned int amount)
+    { this->maxBullets_ = amount; }
+
+    void Munition::setMaxMagazines(unsigned int amount)
+    { this->maxMagazines_ = amount; }
+
+    void Munition::removeBullets(unsigned int amount)
+    {
+        if ( this->bullets_ != 0 )
+            this->bullets_ = this->bullets_ - amount;
+    }
+
+    void Munition::removeMagazines(unsigned int amount)
+    {
+        if ( this->magazines_ != 0 )
+            this->magazines_ = this->magazines_ - amount;
+    }
+
+    void Munition::addBullets(unsigned int amount)
+    {
+        if ( this->bullets_ == this->maxBullets_ )
+        {
+            //cannot add bullets to actual magazine
+        }
+        else
+            this->bullets_ = this->bullets_ + amount;
+    }
+
+    void Munition::addMagazines(unsigned int amount)
+    {
+        if ( this->magazines_ == this->maxMagazines_ )
+        {
+            //no more capacity for another magazine
+        }
+        else
+            this->magazines_ = this->magazines_ + amount;
+    }
+
+
+    void Munition::fillBullets()
+    {
+//COUT(0) << "Munition::fillBullets maxBullets_=" << this->maxBullets_ << std::endl;
+        this->bullets_ = this->maxBullets_;
+    }
+
+    void Munition::fillMagazines()
+    {
+        this->magazines_ = this->maxMagazines_;
+    }
+
     void Munition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-
+        SUPER(Munition, XMLPort, xmlelement, mode);
     }
 

code/branches/presentation/src/orxonox/objects/weaponSystem/Munition.h

@@ -34 +34 @@
 #include "core/BaseObject.h"
 
+#include "Weapon.h"
+
 
 namespace orxonox
@@ -45 +47 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
+            void setMaxBullets(unsigned int amount);
+            void setMaxMagazines(unsigned int amount);
+
+            void fillBullets();
+            void fillMagazines();
+
+            unsigned int bullets();
+            unsigned int magazines();
+
+            void removeBullets(unsigned int k);
+            void removeMagazines(unsigned int k);
+            void addBullets(unsigned int k);
+            void addMagazines(unsigned int k);
 
         private:
 
-
+        protected:
+            unsigned int bullets_;
+            unsigned int magazines_;
+            unsigned int maxBullets_;
+            unsigned int maxMagazines_;
     };
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/Weapon.cc

@@ -37 +37 @@
 namespace orxonox
 {
-    Weapon::Weapon(BaseObject* creator) : BaseObject(creator)
+    CreateFactory(Weapon);
+
+    Weapon::Weapon(BaseObject* creator) : StaticEntity(creator)
     {
         RegisterObject(Weapon);
-
-        this->loadingTime_ = 0;
+        this->bulletReadyToShoot_ = true;
+        this->magazineReadyToShoot_ = true;
+        this->parentWeaponSystem_ = 0;
+        this->attachedToWeaponSlot_ = 0;
         this->munition_ = 0;
-
+        this->bulletLoadingTime_ = 0;
+        this->magazineLoadingTime_ = 0;
+        this->bReloading_ = false;
     }
 
@@ -50 +56 @@
     }
 
-    void Weapon::addMunition()
+
+    void Weapon::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
+        SUPER(Weapon, XMLPort, xmlelement, mode);
+        XMLPortParam(Weapon, "munitionType", setMunitionType, getMunitionType, xmlelement, mode);
+        XMLPortParam(Weapon, "bulletLoadingTime", setBulletLoadingTime, getBulletLoadingTime, xmlelement, mode);
+        XMLPortParam(Weapon, "magazineLoadingTime", setMagazineLoadingTime, getMagazineLoadingTime, xmlelement, mode);
+    }
+
+    void Weapon::setWeapon()
+    {
+        this->munition_->fillBullets();
+        this->munition_->fillMagazines();
+    }
+
+
+    void Weapon::fire()
+    {
+//COUT(0) << "LaserGun::fire, this=" << this << std::endl;
+        if ( this->bulletReadyToShoot_ && this->magazineReadyToShoot_ && !this->bReloading_)
+        {
+//COUT(0) << "LaserGun::fire - ready to shoot" << std::endl;
+//COUT(0) << "LaserGun::fire - bullets" << this->munition_->bullets() << std::endl;
+            this->bulletReadyToShoot_ = false;
+            if ( this->munition_->bullets() > 0)
+            {
+                //shoot
+                this->takeBullets();
+                this->createProjectile();
+            }
+            //if there are no bullets, but magazines
+            else if ( this->munition_->magazines() > 0 && this->munition_->bullets() == 0 )
+            {
+//COUT(0) << "LaserGun::fire - no bullets" << std::endl;
+                this->takeMagazines();
+            }
+            else
+            {
+//COUT(0) << "LaserGun::fire - no magazines" << std::endl;
+                //actions
+            }
+        }
+        else
+        {
+//COUT(0) << "LaserGun::fire - weapon not reloaded - bullets remaining:" << this->munition_->bullets() << std::endl;
+            //actions
+        }
 
     }
 
-    void Weapon::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+
+    void Weapon::bulletTimer(float bulletLoadingTime)
     {
-
+//COUT(0) << "Weapon::bulletTimer started" << std::endl;
+        this->bReloading_ = true;
+        this->bulletReloadTimer_.setTimer( bulletLoadingTime , false , this , createExecutor(createFunctor(&Weapon::bulletReloaded)));
+    }
+    void Weapon::magazineTimer(float magazineLoadingTime)
+    {
+//COUT(0) << "Weapon::magazineTimer started" << std::endl;
+        this->bReloading_ = true;
+        this->magazineReloadTimer_.setTimer( magazineLoadingTime , false , this , createExecutor(createFunctor(&Weapon::magazineReloaded)));
     }
 
-    void Weapon::fire()
+    void Weapon::bulletReloaded()
     {
+        this->bReloading_ = false;
+        this->bulletReadyToShoot_ = true;
+    }
 
+    void Weapon::magazineReloaded()
+    {
+        this->bReloading_ = false;
+        this->munition_->fillBullets();
+        this->magazineReadyToShoot_ = true;
+        this->bulletReadyToShoot_ = true;
     }
+
+
+    void Weapon::attachNeededMunition(std::string munitionName)
+    {
+//COUT(0) << "Weapon::attachNeededMunition, parentWeaponSystem=" << this->parentWeaponSystem_ << std::endl;
+        //if munition type already exists attach it, else create a new one of this type and attach it to the weapon and to the WeaponSystem
+        if (this->parentWeaponSystem_)
+        {
+//COUT(0) << "Weapon::attachNeededMunition " << munitionName << std::endl;
+            Munition* munition = this->parentWeaponSystem_->getMunitionType(munitionName);
+            if ( munition )
+                this->munition_ = munition;
+            else
+            {
+                //create new munition with identifier
+//COUT(0) << "Weapon::attachNeededMunition, create new Munition of Type " << munitionName << std::endl;
+                this->munitionIdentifier_ = ClassByString(munitionName);
+                this->munition_ = this->munitionIdentifier_.fabricate(this);
+                this->parentWeaponSystem_->setNewMunition(munitionName, this->munition_);
+            }
+        }
+    }
+
+
+     /*get and set functions
+     *
+     */
+
+    void Weapon::setMunitionType(std::string munitionType)
+    {   this->munitionType_ = munitionType; }
+
+    const std::string Weapon::getMunitionType()
+    {   return this->munitionType_;  }
+
+    void Weapon::setBulletLoadingTime(float loadingTime)
+    {   this->bulletLoadingTime_ = loadingTime; }
+
+    const float Weapon::getBulletLoadingTime()
+    {   return this->bulletLoadingTime_;  }
+
+    void Weapon::setMagazineLoadingTime(float loadingTime)
+    {   this->magazineLoadingTime_ = loadingTime; }
+
+    const float Weapon::getMagazineLoadingTime()
+    {   return this->magazineLoadingTime_;  }
+
+
+    Munition * Weapon::getAttachedMunition(std::string munitionType)
+    {
+//COUT(0) << "Weapon::getAttachedMunition, parentWeaponSystem_="<< this->parentWeaponSystem_ << std::endl;
+        this->munition_ = this->parentWeaponSystem_->getMunitionType(munitionType);
+//COUT(0) << "Weapon::getAttachedMunition, munition_="<< this->munition_ << std::endl;
+        return this->munition_;
+    }
+
+    void Weapon::takeBullets() { };
+    void Weapon::createProjectile() { };
+    void Weapon::takeMagazines() { };
+
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/Weapon.h

@@ -33 +33 @@
 
 #include "core/BaseObject.h"
+#include "tools/BillboardSet.h"
+#include "tools/Timer.h"
+#include "core/Identifier.h"
 
+#include "WeaponSystem.h"
+#include "Munition.h"
+
+#include "objects/worldentities/StaticEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Weapon : public BaseObject
+    class _OrxonoxExport Weapon : public StaticEntity
     {
         public:
@@ -45 +52 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-            void addMunition();
             virtual void fire();
+            void attachNeededMunition(std::string munitionType);
+            Munition * getAttachedMunition(std::string munitiontype);
+
+            //reloading
+            void bulletTimer(float bulletLoadingTime);
+            void magazineTimer(float magazineLoadingTime);
+            void bulletReloaded();
+            void magazineReloaded();
+
+            virtual void setMunitionType(std::string munitionType);
+            virtual const std::string getMunitionType();
+            virtual void setBulletLoadingTime(float loadingTime);
+            virtual const float getBulletLoadingTime();
+            virtual void setMagazineLoadingTime(float loadingTime);
+            virtual const float getMagazineLoadingTime();
+
+            virtual void takeBullets();
+            virtual void takeMagazines();
+            virtual void createProjectile();
+
+            inline void setParentWeaponSystem(WeaponSystem *parentWeaponSystem)
+                { this->parentWeaponSystem_=parentWeaponSystem; };
+            inline WeaponSystem * getParentWeaponSystem()
+                { return this->parentWeaponSystem_; };
+
+            inline void setAttachedToWeaponSlot(WeaponSlot * wSlot)
+                { this->attachedToWeaponSlot_ = wSlot; }
+            inline WeaponSlot * getAttachedToWeaponSlot()
+                { return this->attachedToWeaponSlot_; }
+
+            virtual void setWeapon();
 
         private:
-            int loadingTime_;
-            Munition *munition_;
 
+        protected:
+            bool bReloading_;
+            bool bulletReadyToShoot_;
+            bool magazineReadyToShoot_;
+            float bulletLoadingTime_;
+            float magazineLoadingTime_;
+            std::string munitionType_;
 
+            WeaponSlot * attachedToWeaponSlot_;
+            Munition * munition_;
+            WeaponSystem * parentWeaponSystem_;
 
+            SubclassIdentifier<Munition> munitionIdentifier_;
+
+            Timer<Weapon> bulletReloadTimer_;
+            Timer<Weapon> magazineReloadTimer_;
     };
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/WeaponPack.cc

@@ -63 +63 @@
         for (int i=0; i < (int) this->weapons_.size(); i++)
         {
-COUT(0) << "WeaponPack::fire (attached from WeaponSet)  from Weapon: "<< i << std::endl;
+//COUT(0) << "WeaponPack::fire (attached from WeaponSet)  from Weapon: "<< i << std::endl;
             this->weapons_[i]->getAttachedToWeaponSlot()->fire();
         }
@@ -83 +83 @@
     void WeaponPack::setFireMode(unsigned int firemode)
     {
-COUT(0) << "WeaponPack::setFireMode " << std::endl;
+//COUT(0) << "WeaponPack::setFireMode " << std::endl;
         this->firemode_ = firemode;
     }
@@ -94 +94 @@
     void WeaponPack::addWeapon(Weapon * weapon)
     {
-COUT(0) << "WeaponPack::addWeapon:" << weapon << "   munition " << weapon->getMunitionType() << std::endl;
+//COUT(0) << "WeaponPack::addWeapon:" << weapon << "   munition " << weapon->getMunitionType() << std::endl;
         this->weapons_.push_back(weapon);
     }

code/branches/presentation/src/orxonox/objects/weaponSystem/WeaponSet.cc

@@ -33 +33 @@
 #include "core/XMLPort.h"
 #include "util/Debug.h"
+#include "objects/worldentities/pawns/Pawn.h"
 
 #include "WeaponSet.h"
+#include "WeaponPack.h"
 
 namespace orxonox
 {
+    CreateFactory(WeaponSet);
+
     WeaponSet::WeaponSet(BaseObject* creator, int k) : BaseObject(creator)
     {
@@ -43 +47 @@
 
         this->parentWeaponSystem_ = 0;
-
-        for (int i=0;i<k;i++)
-        {
-            attachWeaponSlot(new WeaponSlot(this));
-        }
+        this->attachedWeaponPack_ = 0;
     }
 
@@ -54 +54 @@
     }
 
-    //Vorwärtsdeklaration
-    WeaponSystem * parentWeaponSystem_;
+    void WeaponSet::attachWeaponPack(WeaponPack *wPack)
+    {
+//COUT(0) << "WeaponSet::attachWeaponPack" << std::endl;
+//COUT(0) << "........ parentWeaponSystem_=" << this->parentWeaponSystem_ << std::endl;
+//COUT(0) << "........ this->parentWeaponSystem_->getWeaponSlotSize()" << this->parentWeaponSystem_->getWeaponSlotSize() << std::endl;
+//COUT(0) << "........ wPack->getSize()" << wPack->getSize() << std::endl;
+        if ( this->parentWeaponSystem_->getWeaponSlotSize()>0 && wPack->getSize()>0 && ( wPack->getSize() <= this->parentWeaponSystem_->getWeaponSlotSize() ) )
+        {
+//COUT(0) << "WeaponSet::attachWeaponPack after if" << std::endl;
+            this->attachedWeaponPack_ = wPack;
+            int wPackWeapon = 0;    //WeaponCounter for Attaching
+            //should be possible to choose which slot to use
+            for (  int i=0; i < wPack->getSize() ; i++  )
+            {
+                //at the moment this function only works for one weaponPack in the entire WeaponSystem...
+                if ( this->parentWeaponSystem_->getWeaponSlotPointer(i)->getAttachedWeapon() == 0 && this->parentWeaponSystem_->getWeaponSlotPointer(i) != 0) //if slot not full
+                {
+//COUT(0) << "WeaponSet::attachWeaponPack attaching Weapon" << std::endl;
+                    this->setWeaponSlots_.push_back( this->parentWeaponSystem_->getWeaponSlotPointer(i) );
+                    this->parentWeaponSystem_->getWeaponSlotPointer(i)->attachWeapon( wPack->getWeaponPointer(wPackWeapon) );
+                    this->parentWeaponSystem_->getParentPawn()->attach( wPack->getWeaponPointer(wPackWeapon) );
+                    wPackWeapon++;
+                }
+                else
+                {
+                    for (int k=0; k < this->parentWeaponSystem_->getWeaponSlotSize(); k++)
+                    {
+                        if ( this->parentWeaponSystem_->getWeaponSlotPointer(k)->getAttachedWeapon() == 0 )
+                        {
+//COUT(0) << "WeaponSet::attachWeaponPack mode 2 k="<< k << std::endl;
+                            this->setWeaponSlots_.push_back( this->parentWeaponSystem_->getWeaponSlotPointer(k) );
+                            this->parentWeaponSystem_->getWeaponSlotPointer(k)->attachWeapon( wPack->getWeaponPointer(wPackWeapon) );
+                            this->parentWeaponSystem_->getParentPawn()->attach( wPack->getWeaponPointer(wPackWeapon) );
+                            wPackWeapon++;
+                        }
+                    }
+                }
+            }
+        }
+    }
 
-    void WeaponSet::attachWeaponSlot(WeaponSlot *wSlot)
-    {
-        this->weaponSlots_.push_back(wSlot);
-    }
 
     void WeaponSet::fire()
     {
-        for (int i=0; i < (int) this->weaponSlots_.size(); i++)
-        {
-            this->weaponSlots_[i]->fire();
-        }
+        //fires all WeaponSlots available for this weaponSet attached from the WeaponPack
+//COUT(0) << "WeaponSet::fire from Pack: " << this->attachedWeaponPack_ << std::endl;
+        if (this->attachedWeaponPack_)
+            this->attachedWeaponPack_->fire();
     }
 
-    WeaponSlot * WeaponSet::getWeaponSlotPointer(unsigned int n)
-    {
-        if (n < this->weaponSlots_.size())
-            return this->weaponSlots_[n];
-        else
-            return 0;
-    }
+    void WeaponSet::setFireMode(const unsigned int firemode)
+    {   this->firemode_ = firemode; }
 
+    const unsigned int WeaponSet::getFireMode() const
+    {   return this->firemode_; }
 
     void WeaponSet::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-
+        SUPER(WeaponSet, XMLPort, xmlelement, mode);
+        XMLPortParam(WeaponSet, "firemode", setFireMode, getFireMode, xmlelement, mode);
     }
 

code/branches/presentation/src/orxonox/objects/weaponSystem/WeaponSet.h

@@ -48 +48 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-            void attachWeaponSlot(WeaponSlot *wSlot);
+            void attachWeaponPack(WeaponPack *wPack);
             void fire();
-            WeaponSlot * getWeaponSlotPointer(unsigned int n);
+
+            void setFireMode(const unsigned int firemode);
+            const unsigned int getFireMode() const;
 
             inline void setParentWeaponSystem(WeaponSystem *parentWeaponSystem)
@@ -58 +60 @@
 
         private:
-            std::vector<WeaponSlot *> weaponSlots_;
             WeaponSystem *parentWeaponSystem_;
+            std::vector<WeaponSlot *> setWeaponSlots_;
+            unsigned int firemode_;
+            WeaponPack * attachedWeaponPack_;
     };
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/WeaponSlot.cc

@@ -36 +36 @@
 
 
-
 namespace orxonox
 {
-    WeaponSlot::WeaponSlot(BaseObject* creator) : BaseObject(creator)
+    CreateFactory(WeaponSlot);
+
+    WeaponSlot::WeaponSlot(BaseObject* creator) : StaticEntity(creator)
     {
         RegisterObject(WeaponSlot);
 
         this->unlimitedAmmo_ = false;
-
         this->attachedWeapon_ = 0;
-        this->parentWeaponSet_ = 0;
+        this->setObjectMode(0x0);
     }
 
@@ -53 +53 @@
     }
 
-    void WeaponSlot::attachWeapon(Weapon *weaponName)
-    {
-
-    }
 
     /*sets the munition type
@@ -67 +63 @@
     }
 
+
     void WeaponSlot::fire()
     {
+        if ( this->attachedWeapon_ )
+//COUT(0) << "WeaponSlot::fire" << std::endl;
+        this->attachedWeapon_->fire();
+    }
 
-    }
 
     void WeaponSlot::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
+        SUPER(WeaponSlot, XMLPort, xmlelement, mode);
+    }
 
+    void WeaponSlot::attachWeapon(Weapon *weapon)
+    {
+        this->attachedWeapon_ = weapon;
+        weapon->setAttachedToWeaponSlot(this);
+//COUT(0) << "WeaponSlot::attachWeapon position=" << this->getWorldPosition() << std::endl;
+        weapon->setPosition(this->getPosition());
+    }
+
+    Weapon * WeaponSlot::getAttachedWeapon() const
+    {
+        return this->attachedWeapon_;
     }
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/WeaponSlot.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include "core/BaseObject.h"
-
-
 #include "Weapon.h"
-
+#include "objects/worldentities/StaticEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport WeaponSlot : public BaseObject
+    class _OrxonoxExport WeaponSlot : public StaticEntity
     {
         public:
@@ -48 +45 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-            void attachWeapon(Weapon *weaponName);
+            void attachWeapon(Weapon *weapon);
+            Weapon * getAttachedWeapon() const;
             void setAmmoType(bool isUnlimited);
             void fire();
 
-            inline void setParentWeaponSet(WeaponSet *parentWeaponSet)
-                { parentWeaponSet_=parentWeaponSet; }
-            inline WeaponSet * getParentWeaponSet()
-                { return parentWeaponSet_; }
-
+            inline void setParentWeaponSystem(WeaponSystem *parentWeaponSystem)
+                { parentWeaponSystem_=parentWeaponSystem; }
+            inline WeaponSystem * getParentWeaponSystem()
+                { return parentWeaponSystem_; }
 
 
@@ -63 +60 @@
             bool unlimitedAmmo_;
 
-            WeaponSet *parentWeaponSet_;
+            WeaponSystem *parentWeaponSystem_;
     };
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/WeaponSystem.cc

@@ -37 +37 @@
 #include "WeaponSystem.h"
 
+
 /* WEAPONSYSTEM
  * creates the WeaponSystem and the ability to use weapons and munition
@@ -45 +46 @@
 namespace orxonox
 {
+    CreateFactory(WeaponSystem);
+
     WeaponSystem::WeaponSystem(BaseObject* creator) : BaseObject(creator)
     {
@@ -50 +53 @@
 
         this->activeWeaponSet_ = 0;
-        this->parentSpaceShip_ = 0;
+        this->parentPawn_ = 0;
     }
 
@@ -57 +60 @@
     }
 
-    //creates empty weaponSet
+    void WeaponSystem::attachWeaponPack(WeaponPack *wPack, unsigned int firemode)
+    {
+        if (firemode < this->weaponSets_.size())
+            this->weaponSets_[firemode]->attachWeaponPack(wPack);
+        this->weaponPacks_.push_back(wPack);
+    }
+
+    void WeaponSystem::attachWeaponSlot(WeaponSlot *wSlot)
+    {
+        wSlot->setParentWeaponSystem(this);
+        this->weaponSlots_.push_back(wSlot);
+    }
+
     void WeaponSystem::attachWeaponSet(WeaponSet *wSet)
     {
+        wSet->setParentWeaponSystem(this);
         this->weaponSets_.push_back(wSet);
-        wSet->setParentWeaponSystem(this);
     }
 
+    void WeaponSystem::setNewMunition(std::string munitionType, Munition * munitionToAdd)
+    {
+        this->munitionSet_[munitionType] = munitionToAdd;
+    }
+
+    //returns the Pointer to the munitionType
+    Munition * WeaponSystem::getMunitionType(std::string munitionType)
+    {
+//COUT(0) << "WeaponSystem::getMunitionType " << munitionType << std::endl;
+        std::map<std::string, Munition *>::const_iterator it = this->munitionSet_.find(munitionType);
+        if (it != this->munitionSet_.end())
+            return it->second;
+        else
+            return 0;
+    }
+
+
+/*
     //the first weaponSet is at n=0
     void WeaponSystem::setActiveWeaponSet(unsigned int n)
@@ -69 +102 @@
         if (n < this->weaponSets_.size())
             this->activeWeaponSet_ = this->weaponSets_[n];
+        else
+            this->activeWeaponSet_ = this->weaponSets_[0];
+    }
+*/
+
+
+    //n is the n'th weaponSet, starting with zero
+    //SpaceShip.cc only needs to have the keybinding to a specific Set-number n
+    void WeaponSystem::fire(WeaponMode::Enum n)
+    {
+        int set = 0;
+        switch (n)
+        {
+            case WeaponMode::fire:
+                set = 0;
+                break;
+            case WeaponMode::altFire:
+                set = 1;
+                break;
+            case WeaponMode::altFire2:
+                set = 2;
+                break;
+        }
+//COUT(0) << "WeaponSystem::fire" << std::endl;
+        if (set < (int)this->weaponSets_.size())
+//COUT(0) << "WeaponSystem::fire - after if" << std::endl;
+            this->weaponSets_[set]->fire();
     }
 
-    //n is the n'th weaponSet, starting with zero
-    //Spaceship.cc only needs to have the keybinding to a specific Set-number n
-    void WeaponSystem::fire(unsigned int n)
-    {
-        if (n < this->weaponSets_.size())
-            this->weaponSets_[n]->fire();
-    }
-
-    void WeaponSystem::fire()
-    {
-        if (this->activeWeaponSet_)
-            this->activeWeaponSet_->fire();
-    }
 
     WeaponSet * WeaponSystem::getWeaponSetPointer(unsigned int n)
@@ -93 +140 @@
     }
 
+    WeaponSlot * WeaponSystem::getWeaponSlotPointer(unsigned int n)
+    {
+        if (n < this->weaponSlots_.size())
+            return this->weaponSlots_[n];
+        else
+            return 0;
+    }
+
+    WeaponPack * WeaponSystem::getWeaponPackPointer(unsigned int n)
+    {
+        if (n < this->weaponPacks_.size())
+            return this->weaponPacks_[n];
+        else
+            return 0;
+    }
+
     void WeaponSystem::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-
+        SUPER(WeaponSystem, XMLPort, xmlelement, mode);
     }
 

code/branches/presentation/src/orxonox/objects/weaponSystem/WeaponSystem.h

@@ -36 +36 @@
 
 #include "WeaponSet.h"
+#include "WeaponPack.h"
 
 namespace orxonox
 {
+
     class _OrxonoxExport WeaponSystem : public BaseObject
     {
@@ -47 +49 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
+            void attachWeaponSlot(WeaponSlot *wSlot);
             void attachWeaponSet(WeaponSet *wSet);
-            void fire();
-            void fire(unsigned int n);
-            void setActiveWeaponSet(unsigned int n);
+            //void fire();
+            void fire(WeaponMode::Enum fireMode);
+            //void setActiveWeaponSet(unsigned int n);
+            void attachWeaponPack(WeaponPack * wPack, unsigned int firemode);
             WeaponSet * getWeaponSetPointer(unsigned int n);
+            WeaponSlot * getWeaponSlotPointer(unsigned int n);
+            WeaponPack * getWeaponPackPointer(unsigned int n);
+            void setNewMunition(std::string munitionType, Munition * munitionToAdd);
+            Munition * getMunitionType(std::string munitionType);
 
-            inline void setParentSpaceShip(SpaceShip *parentSpaceShip)
-                { parentSpaceShip_=parentSpaceShip; }
-            inline SpaceShip * getParentSpaceShip()
-                { return parentSpaceShip_; }
+            inline void setParentPawn(Pawn *parentPawn)
+                { parentPawn_=parentPawn; }
+            inline Pawn * getParentPawn()
+                { return parentPawn_; }
 
+            inline int getWeaponSlotSize()
+                { return this->weaponSlots_.size(); }
 
         private:
             std::vector<WeaponSet *> weaponSets_;
+            std::vector<WeaponSlot *> weaponSlots_;
+            std::vector<WeaponPack *> weaponPacks_;
+            std::map<std::string, Munition *> munitionSet_;
             WeaponSet *activeWeaponSet_;
-
-            SpaceShip *parentSpaceShip_;
+            Pawn *parentPawn_;
     };
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.cc

@@ -37 +37 @@
 namespace orxonox
 {
-    LaserGunMunition::LaserGunMunition(BaseObject* creator) : BaseObject(creator)
+    CreateFactory(LaserGunMunition);
+
+    LaserGunMunition::LaserGunMunition(BaseObject* creator) : Munition(creator)
     {
         RegisterObject(LaserGunMunition);
+
+        this->maxBullets_ = 40;
+        this->maxMagazines_ = 100;
     }
 

code/branches/presentation/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.h

@@ -33 +33 @@
 
 #include "core/BaseObject.h"
-
+#include "../Munition.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport LaserGunMunition : public BaseObject
+    class _OrxonoxExport LaserGunMunition : public Munition
     {
         public:
@@ -47 +47 @@
 
         private:
-            int bullets_;
-            int magazines_;
-            int maxBullets_;
-            int maxMagazines_;
 
 

code/branches/presentation/src/orxonox/objects/weaponSystem/projectiles/BillboardProjectile.cc

@@ -30 +30 @@
 #include "BillboardProjectile.h"
 
-#include <OgreBillboard.h>
+#include <OgreBillboardSet.h>
 
 #include "core/CoreIncludes.h"
+#include "objects/Scene.h"
 
 namespace orxonox
@@ -38 +39 @@
     CreateFactory(BillboardProjectile);
 
-    BillboardProjectile::BillboardProjectile(BaseObject* creator, Weapon* owner) : Projectile(creator, owner)
+    BillboardProjectile::BillboardProjectile(BaseObject* creator) : Projectile(creator)
     {
         RegisterObject(BillboardProjectile);
 
-        this->billboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 1.0, 0.5), 1);
-        this->attachObject(this->billboard_.getBillboardSet());
-        this->scale(0.5);
+        assert(this->getScene()->getSceneManager()); // getScene() was already checked by WorldEntity
+
+        this->billboard_.setBillboardSet(this->getScene()->getSceneManager(), "Examples/Flare", ColourValue(0.5, 0.5, 0.7, 0.8), 1);
+        this->attachOgreObject(this->billboard_.getBillboardSet());
+        this->scale(0.2);
     }
 
     BillboardProjectile::~BillboardProjectile()
     {
-        if (this->isInitialized() && this->owner_)
-            this->detachObject(this->billboard_.getBillboardSet());
+        //if (this->isInitialized() && this->owner_)
+            //this->detachObject(this->billboard_.getBillboardSet());
     }
 
     void BillboardProjectile::setColour(const ColourValue& colour)
     {
-        this->billboard_.getBillboardSet()->getBillboard(0)->setColour(colour);
+        this->billboard_.setColour(colour);
     }
 

code/branches/presentation/src/orxonox/objects/weaponSystem/projectiles/BillboardProjectile.h

@@ -41 +41 @@
     {
         public:
-            BillboardProjectile(BaseObject* creator, Weapon* owner = 0);
+            BillboardProjectile(BaseObject* creator);
             virtual ~BillboardProjectile();
 

code/branches/presentation/src/orxonox/objects/weaponSystem/projectiles/ParticleProjectile.cc

@@ -30 +30 @@
 #include "ParticleProjectile.h"
 
-#include "SpaceShip.h"
+#include <OgreParticleSystem.h>
+#include <OgreParticleEmitter.h>
+
+#include "../../worldentities/pawns/SpaceShip.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "objects/Scene.h"
 
 namespace orxonox
@@ -38 +42 @@
     CreateFactory(ParticleProjectile);
 
-    ParticleProjectile::ParticleProjectile(BaseObject* creator, Weapon* owner) : BillboardProjectile(creator, owner)
+    ParticleProjectile::ParticleProjectile(BaseObject* creator) : BillboardProjectile(creator)
     {
         RegisterObject(ParticleProjectile);
 
-        this->particles_ = new ParticleInterface("Orxonox/shot2", LODParticle::normal);
-        this->particles_->addToSceneNode(this->getNode());
-        this->particles_->setKeepParticlesInLocalSpace(true);
+        this->particles_ = new ParticleInterface(this->getScene()->getSceneManager(), "Orxonox/shot3_small", LODParticle::normal);
+        this->attachOgreObject(this->particles_->getParticleSystem());
+        this->particles_->setKeepParticlesInLocalSpace(0);
+
+        this->particles_->getAllEmitters()->setDirection(-WorldEntity::FRONT);
+        /*
         if (this->owner_)
         {
@@ -52 +59 @@
 //            this->particles_ = 0;
 //        }
+        */
 
         this->setConfigValues();
@@ -59 +67 @@
     {
         if (this->isInitialized() && this->particles_)
+        {
+            this->detachOgreObject(this->particles_->getParticleSystem());
             delete this->particles_;
+        }
     }
 
     void ParticleProjectile::setConfigValues()
     {
-        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback((Projectile*)this, &ParticleProjectile::speedChanged);
+        //SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback((Projectile*)this, &ParticleProjectile::speedChanged);
     }
 
@@ -72 +83 @@
         this->particles_->setEnabled(this->isVisible());
     }
-
-    bool ParticleProjectile::create(){
-      if(!Projectile::create())
-        return false;
-      this->particles_->getAllEmitters()->setDirection(-this->getOrientation()*Vector3(1,0,0));
-      return true;
-    }
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/projectiles/ParticleProjectile.h

@@ -41 +41 @@
     {
         public:
-            ParticleProjectile(BaseObject* creator, Weapon* owner = 0);
+            ParticleProjectile(BaseObject* creator);
             virtual ~ParticleProjectile();
             virtual void changedVisibility();
             void setConfigValues();
-
-            virtual bool create();
 
         private:

code/branches/presentation/src/orxonox/objects/weaponSystem/projectiles/Projectile.cc

@@ -40 +40 @@
 #include "objects/worldentities/Model.h"
 #include "objects/worldentities/ParticleSpawner.h"
-#include "Settings.h"
+#include "core/Core.h"
 
 namespace orxonox
 {
-    float Projectile::speed_s = 5000;
-
-    Projectile::Projectile(BaseObject* creator, Weapon* owner) : MovableEntity(creator), owner_(owner)
+    Projectile::Projectile(BaseObject* creator) : MovableEntity(creator)
     {
         RegisterObject(Projectile);
@@ -54 +52 @@
         this->smokeTemplateName_ = "Orxonox/smoke4";
 
-        this->setStatic(false);
-        this->translate(Vector3(55, 0, 0), Ogre::Node::TS_LOCAL);
+        //this->setStatic(false);
+//        this->translate(Vector3(55, 0, 0), Ogre::Node::TS_LOCAL);
 
         // Get notification about collisions
         this->enableCollisionCallback();
 
+        /*
         if (this->owner_)
         {
@@ -66 +65 @@
             this->setVelocity(this->owner_->getInitialDir() * this->speed_);
         }
+        */
 
-        if(!orxonox::Settings::isClient()) //only if not on client
+        if(!Core::isClient()) //only if not on client
           this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
     }
@@ -79 +79 @@
         SetConfigValue(damage_, 15.0).description("The damage caused by the projectile");
         SetConfigValue(lifetime_, 4.0).description("The time in seconds a projectile stays alive");
-        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback(this, &Projectile::speedChanged);
     }
 
-    void Projectile::speedChanged()
-    {
-        Projectile::speed_s = this->speed_;
-        if (this->owner_)
-            this->setVelocity(this->owner_->getInitialDir() * this->speed_);
-    }
 
     void Projectile::tick(float dt)
@@ -95 +88 @@
         if (!this->isActive())
             return;
-
+/*
         float radius;
         for (ObjectList<Model>::iterator it = ObjectList<Model>::begin(); it; ++it)
@@ -106 +99 @@
                 {
                     // hit
-                    ParticleSpawner* explosion = new ParticleSpawner(this->explosionTemplateName_, LODParticle::low, 2.0);
+                    ParticleSpawner* explosion = new ParticleSpawner(this);
+                    explosion->setSource(this->explosionTemplateName_);
+                    explosion->setLOD(LODParticle::low);
+                    explosion->configure(2.0);
                     explosion->setPosition(this->getPosition());
                     explosion->create();
-                    ParticleSpawner* smoke = new ParticleSpawner(this->smokeTemplateName_, LODParticle::normal, 2.0, 0.0);
+                    ParticleSpawner* smoke = new ParticleSpawner(this);
+                    smoke->setSource(this->smokeTemplateName_);
+                    smoke->setLOD(LODParticle::normal);
+                    smoke->configure(2.0, 0.0);
                     smoke->setPosition(this->getPosition());
 //                    smoke->getParticleInterface()->setSpeedFactor(3.0);
@@ -118 +117 @@
             }
         }
+*/
     }
 
@@ -124 +124 @@
         delete this;
     }
-
-    bool Projectile::create(){
-      return WorldEntity::create();
-    }
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/projectiles/Projectile.h

@@ -42 +42 @@
             virtual ~Projectile();
             void setConfigValues();
-            void speedChanged();
             void destroyObject();
             virtual void tick(float dt);
 
-            virtual bool create();
-
-            static float getSpeed()
-                { return Projectile::speed_s; }
-
         protected:
-            Projectile(BaseObject* creator, Weapon* owner = 0);
-            SpaceShip* owner_;
+            Projectile(BaseObject* creator);
 
         private:
@@ -59 +52 @@
             std::string smokeTemplateName_;
         protected:
-            static float speed_s;
             float speed_;
         private:

code/branches/presentation/src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt

@@ -1 +1 @@
 SET( SRC_FILES
+  Fusion.cc
   LaserGun.cc
-  Missile.cc
+#  Missile.cc
 )
 

code/branches/presentation/src/orxonox/objects/weaponSystem/weapons/Fusion.cc

@@ -44 +44 @@
     {
         RegisterObject(Fusion);
-        
+
         this->speed_ = 1250;
 
@@ -55 +55 @@
     void Fusion::takeBullets()
     {
-COUT(0) << "Fusion::takeBullets" << std::endl;
+//COUT(0) << "Fusion::takeBullets" << std::endl;
         this->munition_->removeBullets(1);
         this->bulletTimer(this->bulletLoadingTime_);
@@ -68 +68 @@
     void Fusion::createProjectile()
     {
-COUT(0) << "Fusion::createProjectile" << std::endl;
+//COUT(0) << "Fusion::createProjectile" << std::endl;
         BillboardProjectile* projectile = new ParticleProjectile(this);
         projectile->setOrientation(this->getWorldOrientation());
         projectile->setPosition(this->getWorldPosition());
-        projectile->setVelocity(WorldEntity::FRONT * this->speed_);
+        projectile->setVelocity(this->getWorldOrientation() * WorldEntity::FRONT * this->speed_);
     }
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/weapons/LaserGun.cc

@@ -34 +34 @@
 #include "util/Debug.h"
 
+#include "LaserGun.h"
+
 
 namespace orxonox
 {
+    CreateFactory(LaserGun);
+
     LaserGun::LaserGun(BaseObject* creator) : Weapon(creator)
     {
         RegisterObject(LaserGun);
 
-        projectileColor_ = ColourValue(1.0, 1.0, 0.5)
+        this->speed_ = 1250;
+
     }
 
@@ -48 +53 @@
     }
 
-    LaserGun::fire()
+    void LaserGun::takeBullets()
     {
-            BillboardProjectile* projectile = new ParticleProjectile(this);
-            projectile->setColour(this->projectileColor_);
-            projectile->create();
-            if (projectile->getClassID() == 0)
-            {
-              COUT(3) << "generated projectile with classid 0" <<  std::endl; // TODO: remove this output
-            }
-
-            projectile->setObjectMode(0x3);
+//COUT(0) << "LaserGun::takeBullets" << std::endl;
+        this->munition_->removeBullets(1);
+        this->bulletTimer(this->bulletLoadingTime_);
     }
 
-    LaserGun::addMunition()
+    void LaserGun::takeMagazines()
     {
-        //this->munition_ = ;
+        this->munition_->removeMagazines(1);
+        this->magazineTimer(this->magazineLoadingTime_);
     }
 
-    void LaserGun::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    void LaserGun::createProjectile()
     {
-
-    }
-
-    ColorValue LaserGun::getProjectileColor()
-    {
-        return projectileColor_;
+//COUT(0) << "LaserGun::createProjectile" << std::endl;
+        BillboardProjectile* projectile = new ParticleProjectile(this);
+        projectile->setOrientation(this->getWorldOrientation());
+        projectile->setPosition(this->getWorldPosition());
+        projectile->setVelocity(this->getWorldOrientation() * WorldEntity::FRONT * this->speed_);
     }
 }

code/branches/presentation/src/orxonox/objects/weaponSystem/weapons/LaserGun.h

@@ -34 +34 @@
 #include "core/BaseObject.h"
 
-#include "LaserGunMunition.h"
-#include "tools/BillboardSet.h"
+#include "../munitions/LaserGunMunition.h"
 #include "util/Math.h"
+#include "../Weapon.h"
+#include "../projectiles/BillboardProjectile.h"
+#include "../projectiles/ParticleProjectile.h"
 
 namespace orxonox
@@ -46 +48 @@
             virtual ~LaserGun();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-            ColourValue LaserGun::getProjectileColour();
+            virtual void takeBullets();
+            virtual void takeMagazines();
+            virtual void createProjectile();
 
         private:
-            ColorValue projectileColor_;
-
-
+            float speed_;
 
     };

code/branches/presentation/src/orxonox/objects/worldentities/ControllableEntity.h

@@ -33 +33 @@
 
 #include "MobileEntity.h"
+#include "objects/weaponSystem/WeaponSystem.h"
 
 namespace orxonox
@@ -81 +82 @@
                 { this->rotateRoll(Vector2(value, 0)); }
 
-            virtual void fire() {}
-            virtual void altFire() {}
+            virtual void fire(WeaponMode::Enum fireMode) {}
+            virtual void altFire(WeaponMode::Enum fireMode) {}
 
             virtual void boost() {}

code/branches/presentation/src/orxonox/objects/worldentities/pawns/Pawn.cc

@@ -37 +37 @@
 #include "objects/infos/PlayerInfo.h"
 #include "objects/gametypes/Gametype.h"
-#include "objects/weaponSystem/WeaponSystem.h"
 #include "objects/worldentities/ParticleSpawner.h"
 #include "objects/worldentities/ExplosionChunk.h"
@@ -52 +51 @@
 
         this->bAlive_ = true;
+        this->fire_ = 0x0;
 
         this->health_ = 0;
@@ -58 +58 @@
 
         this->lastHitOriginator_ = 0;
-        this->weaponSystem_ = 0;
 
         this->spawnparticleduration_ = 3.0f;
 
-        /*
-        //WeaponSystem
-        weaponSystem_ = new WeaponSystem();
-        WeaponSet * weaponSet1 = new WeaponSet(1);
-        this->weaponSystem_->attachWeaponSet(weaponSet1);
-        this->weaponSystem_->getWeaponSetPointer(0)->getWeaponSlotPointer(0)->setAmmoType(true);
-        */
+        if (Core::isMaster())
+        {
+            this->weaponSystem_ = new WeaponSystem(this);
+            this->weaponSystem_->setParentPawn(this);
+        }
+        else
+            this->weaponSystem_ = 0;
 
         this->setRadarObjectColour(ColourValue::Red);
@@ -82 +81 @@
             for (ObjectList<PawnListener>::iterator it = ObjectList<PawnListener>::begin(); it != ObjectList<PawnListener>::end(); ++it)
                 it->destroyedPawn(this);
+
+            if (this->weaponSystem_)
+                delete this->weaponSystem_;
         }
     }
@@ -95 +97 @@
         XMLPortParam(Pawn, "spawnparticleduration", setSpawnParticleDuration, getSpawnParticleDuration, xmlelement, mode).defaultValues(3.0f);
         XMLPortParam(Pawn, "explosionchunks", setExplosionChunks, getExplosionChunks, xmlelement, mode).defaultValues(7);
+
+        XMLPortObject(Pawn, WeaponSlot, "weaponslots", setWeaponSlot, getWeaponSlot, xmlelement, mode);
+        XMLPortObject(Pawn, WeaponSet, "weaponsets", setWeaponSet, getWeaponSet, xmlelement, mode);
+        XMLPortObject(Pawn, WeaponPack, "weapons", setWeaponPack, getWeaponPack, xmlelement, mode);
     }
 
@@ -102 +108 @@
         registerVariable(this->health_,        variableDirection::toclient);
         registerVariable(this->initialHealth_, variableDirection::toclient);
+        registerVariable(this->fire_,          variableDirection::toclient);
     }
 
@@ -107 +114 @@
     {
         SUPER(Pawn, tick, dt);
+
+        if (this->weaponSystem_)
+        {
+            if (this->fire_ & WeaponMode::fire)
+                this->weaponSystem_->fire(WeaponMode::fire);
+            if (this->fire_ & WeaponMode::altFire)
+                this->weaponSystem_->fire(WeaponMode::altFire);
+            if (this->fire_ & WeaponMode::altFire2)
+                this->weaponSystem_->fire(WeaponMode::altFire2);
+        }
+        this->fire_ = 0x0;
 
         if (this->health_ <= 0)
@@ -205 +223 @@
     }
 
-    void Pawn::fire()
-    {
-        if (this->weaponSystem_)
-            this->weaponSystem_->fire();
+    void Pawn::fire(WeaponMode::Enum fireMode)
+    {
+        this->fire_ |= fireMode;
     }
 
@@ -217 +234 @@
             this->spawneffect();
     }
+
+    void Pawn::setWeaponSlot(WeaponSlot * wSlot)
+    {
+        this->attach(wSlot);
+        if (this->weaponSystem_)
+            this->weaponSystem_->attachWeaponSlot(wSlot);
+    }
+
+    WeaponSlot * Pawn::getWeaponSlot(unsigned int index) const
+    {
+        if (this->weaponSystem_)
+            return this->weaponSystem_->getWeaponSlotPointer(index);
+        else
+            return 0;
+    }
+
+    void Pawn::setWeaponPack(WeaponPack * wPack)
+    {
+        if (this->weaponSystem_)
+        {
+            wPack->setParentWeaponSystem(this->weaponSystem_);
+            wPack->setParentWeaponSystemToAllWeapons(this->weaponSystem_);
+            this->weaponSystem_->attachWeaponPack( wPack,wPack->getFireMode() );
+            wPack->attachNeededMunitionToAllWeapons();
+        }
+    }
+
+    WeaponPack * Pawn::getWeaponPack(unsigned int firemode) const
+    {
+        if (this->weaponSystem_)
+            return this->weaponSystem_->getWeaponPackPointer(firemode);
+        else
+            return 0;
+    }
+
+    void Pawn::setWeaponSet(WeaponSet * wSet)
+    {
+        if (this->weaponSystem_)
+            this->weaponSystem_->attachWeaponSet(wSet);
+    }
+
+    WeaponSet * Pawn::getWeaponSet(unsigned int index) const
+    {
+        if (this->weaponSystem_)
+            return this->weaponSystem_->getWeaponSetPointer(index);
+        else
+            return 0;
+    }
+
 
     ///////////////////

code/branches/presentation/src/orxonox/objects/worldentities/pawns/Pawn.h

@@ -34 +34 @@
 #include "objects/worldentities/ControllableEntity.h"
 #include "objects/RadarViewable.h"
+#include "objects/weaponSystem/WeaponSystem.h"
 
 namespace orxonox
@@ -75 +76 @@
             virtual void kill();
 
-            virtual void fire();
+            virtual void fire(WeaponMode::Enum fireMode);
 
             virtual void postSpawn();
+
+            void setWeaponSlot(WeaponSlot * wSlot);
+            WeaponSlot * getWeaponSlot(unsigned int index) const;
+            void setWeaponPack(WeaponPack * wPack);
+            WeaponPack * getWeaponPack(unsigned int firemode) const;
+            void setWeaponSet(WeaponSet * wSet);
+            WeaponSet * getWeaponSet(unsigned int index) const;
 
             inline const WorldEntity* getWorldEntity() const
@@ -111 +119 @@
 
             WeaponSystem* weaponSystem_;
+            unsigned int fire_;
 
             std::string spawnparticlesource_;
@@ -117 +126 @@
     };
 
-    class _OrxonoxExport PawnListener : public OrxonoxClass
+    class _OrxonoxExport PawnListener : virtual public OrxonoxClass
     {
         friend class Pawn;

code/branches/presentation/src/orxonox/objects/worldentities/pawns/Spectator.cc

@@ -196 +196 @@
     }
 
-    void Spectator::fire()
+    void Spectator::fire(WeaponMode::Enum fireMode)
     {
         if (this->getPlayer())

code/branches/presentation/src/orxonox/objects/worldentities/pawns/Spectator.h

@@ -57 +57 @@
             virtual void rotateRoll(const Vector2& value);
 
-            virtual void fire();
+            virtual void fire(WeaponMode::Enum fireMode);
             virtual void greet();
 

code/branches/presentation/src/orxonox/tools/BillboardSet.h

@@ -52 +52 @@
             inline Ogre::BillboardSet* getBillboardSet()
                 { return this->billboardSet_; }
+            inline Ogre::SceneManager* getSceneManager()
+                { return this->scenemanager_; }
 
             const std::string& getName() const;