Changeset 2662 for code/trunk/src/orxonox/objects/weaponSystem

Timestamp:

Feb 14, 2009, 10:17:35 PM (16 years ago)

Author:

rgrieder

Message:

Merged presentation branch back to trunk.

Location:

code/trunk

Files:

• . (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/presentation/src/orxonox/objects/weaponSystem/WeaponPack.cc)
• src/orxonox/objects/weaponSystem/WeaponPack.h (copied) (copied from code/branches/presentation/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) (3 diffs)
• src/orxonox/objects/weaponSystem/projectiles/BillboardProjectile.h (modified) (1 diff)
• src/orxonox/objects/weaponSystem/projectiles/ParticleProjectile.cc (modified) (4 diffs)
• src/orxonox/objects/weaponSystem/projectiles/ParticleProjectile.h (modified) (1 diff)
• src/orxonox/objects/weaponSystem/projectiles/Projectile.cc (modified) (3 diffs)
• src/orxonox/objects/weaponSystem/projectiles/Projectile.h (modified) (1 diff)
• src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt (modified) (1 diff)
• src/orxonox/objects/weaponSystem/weapons/Fusion.cc (copied) (copied from code/branches/presentation/src/orxonox/objects/weaponSystem/weapons/Fusion.cc)
• src/orxonox/objects/weaponSystem/weapons/Fusion.h (copied) (copied from code/branches/presentation/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)

code/trunk/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/trunk/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/trunk/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/trunk/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->bulletReadyToShoot_ = true;
+        this->magazineReadyToShoot_ = true;
+        this->parentWeaponSystem_ = 0;
+        this->attachedToWeaponSlot_ = 0;
+        this->munition_ = 0;
+        this->bulletLoadingTime_ = 0;
+        this->magazineLoadingTime_ = 0;
+        this->bReloading_ = false;
 
-        this->loadingTime_ = 0;
-        this->munition_ = 0;
-
+        this->setObjectMode(0x0);
     }
 
@@ -50 +58 @@
     }
 
-    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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/src/orxonox/objects/weaponSystem/projectiles/BillboardProjectile.cc

@@ -30 +30 @@
 #include "BillboardProjectile.h"
 
-#include <OgreBillboard.h>
+#include <OgreBillboardSet.h>
 
+#include "core/Core.h"
 #include "core/CoreIncludes.h"
+#include "objects/Scene.h"
 
 namespace orxonox
@@ -38 +40 @@
     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);
+        if (Core::showsGraphics())
+        {
+            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->setScale(0.2);
     }
 
     BillboardProjectile::~BillboardProjectile()
     {
-        if (this->isInitialized() && this->owner_)
-            this->detachObject(this->billboard_.getBillboardSet());
+        if (this->isInitialized() && Core::showsGraphics() && this->billboard_.getBillboardSet())
+            this->detachOgreObject(this->billboard_.getBillboardSet());
     }
 
     void BillboardProjectile::setColour(const ColourValue& colour)
     {
-        this->billboard_.getBillboardSet()->getBillboard(0)->setColour(colour);
+        this->billboard_.setColour(colour);
     }
 
@@ -61 +68 @@
     {
         SUPER(BillboardProjectile, changedVisibility);
+
         this->billboard_.setVisible(this->isVisible());
     }

code/trunk/src/orxonox/objects/weaponSystem/projectiles/BillboardProjectile.h

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

code/trunk/src/orxonox/objects/weaponSystem/projectiles/ParticleProjectile.cc

@@ -30 +30 @@
 #include "ParticleProjectile.h"
 
-#include "SpaceShip.h"
+#include <OgreParticleSystem.h>
+#include <OgreParticleEmitter.h>
+
+#include "core/Core.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);
-        if (this->owner_)
+        if (Core::showsGraphics())
         {
+            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);
         }
-//        else
-//        {
-//            this->particles_ = 0;
-//        }
-
-        this->setConfigValues();
+        else
+            this->particles_ = 0;
     }
 
@@ -59 +61 @@
     {
         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);
+        }
     }
 
@@ -70 +70 @@
     {
         SUPER(ParticleProjectile, changedVisibility);
-        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;
+        if (this->particles_)
+            this->particles_->setEnabled(this->isVisible());
     }
 }

code/trunk/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/trunk/src/orxonox/objects/weaponSystem/projectiles/Projectile.cc

@@ -40 +40 @@
 #include "objects/worldentities/Model.h"
 #include "objects/worldentities/ParticleSpawner.h"
-#include "Settings.h"
+#include "objects/collisionshapes/SphereCollisionShape.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);
 
         this->setConfigValues();
-        this->explosionTemplateName_ = "Orxonox/explosion3";
-        this->smokeTemplateName_ = "Orxonox/smoke4";
+        this->bDestroy_ = false;
+        this->owner_ = 0;
 
-        this->setStatic(false);
-        this->translate(Vector3(55, 0, 0), Ogre::Node::TS_LOCAL);
+        // Get notification about collisions
 
-        if (this->owner_)
+        if (Core::isMaster())
         {
-            this->setOrientation(this->owner_->getOrientation());
-            this->setPosition(this->owner_->getPosition());
-            this->setVelocity(this->owner_->getInitialDir() * this->speed_);
+            this->enableCollisionCallback();
+
+            this->setCollisionType(Kinematic);
+
+            SphereCollisionShape* shape = new SphereCollisionShape(this);
+            shape->setRadius(10);
+            this->attachCollisionShape(shape);
+
+            this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
         }
-
-        if(!orxonox::Settings::isClient()) //only if not on client
-          this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
     }
 
@@ -76 +77 @@
         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)
@@ -93 +87 @@
             return;
 
-        float radius;
-        for (ObjectList<Model>::iterator it = ObjectList<Model>::begin(); it; ++it)
-        {
-//            if ((*it) != this->owner_)
-            {
-                radius = it->getScale3D().x * 3.0;
-
-                if (this->getPosition().squaredDistance(it->getPosition()) <= (radius*radius))
-                {
-                    // hit
-                    ParticleSpawner* explosion = new ParticleSpawner(this->explosionTemplateName_, LODParticle::low, 2.0);
-                    explosion->setPosition(this->getPosition());
-                    explosion->create();
-                    ParticleSpawner* smoke = new ParticleSpawner(this->smokeTemplateName_, LODParticle::normal, 2.0, 0.0);
-                    smoke->setPosition(this->getPosition());
-//                    smoke->getParticleInterface()->setSpeedFactor(3.0);
-                    smoke->create();
-                    delete this;
-                    return;
-                }
-            }
-        }
+        if (this->bDestroy_)
+            delete this;
     }
 
     void Projectile::destroyObject()
     {
-        delete this;
+        if (Core::isMaster())
+            delete this;
     }
 
-    bool Projectile::create(){
-      return WorldEntity::create();
+    bool Projectile::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
+    {
+        if (!this->bDestroy_ && Core::isMaster())
+        {
+            this->bDestroy_ = true;
+
+            if (this->owner_)
+            {
+                {
+                    ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
+                    effect->setPosition(this->getPosition());
+                    effect->setOrientation(this->getOrientation());
+                    effect->setDestroyAfterLife(true);
+                    effect->setSource("Orxonox/explosion3");
+                    effect->setLifetime(2.0f);
+                }
+                {
+                    ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
+                    effect->setPosition(this->getPosition());
+                    effect->setOrientation(this->getOrientation());
+                    effect->setDestroyAfterLife(true);
+                    effect->setSource("Orxonox/smoke4");
+                    effect->setLifetime(3.0f);
+                }
+            }
+
+            Pawn* victim = dynamic_cast<Pawn*>(otherObject);
+            if (victim)
+                victim->damage(this->damage_, this->owner_);
+        }
+        return false;
+    }
+
+    void Projectile::destroyedPawn(Pawn* pawn)
+    {
+        if (this->owner_ == pawn)
+            this->owner_ = 0;
     }
 }

code/trunk/src/orxonox/objects/weaponSystem/projectiles/Projectile.h

@@ -33 +33 @@
 
 #include "objects/worldentities/MovableEntity.h"
+#include "objects/worldentities/pawns/Pawn.h"
 #include "tools/Timer.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Projectile : public MovableEntity
+    class _OrxonoxExport Projectile : public MovableEntity, public PawnListener
     {
         public:
+            Projectile(BaseObject* creator);
             virtual ~Projectile();
+
             void setConfigValues();
-            void speedChanged();
             void destroyObject();
+
             virtual void tick(float dt);
+            virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            virtual void destroyedPawn(Pawn* pawn);
 
-            virtual bool create();
-
-            static float getSpeed()
-                { return Projectile::speed_s; }
-
-        protected:
-            Projectile(BaseObject* creator, Weapon* owner = 0);
-            SpaceShip* owner_;
+            inline void setOwner(Pawn* owner)
+                { this->owner_ = owner; }
+            inline Pawn* getOwner() const
+                { return this->owner_; }
 
         private:
-            std::string explosionTemplateName_;
-            std::string smokeTemplateName_;
-        protected:
-            static float speed_s;
-            float speed_;
-        private:
+            Pawn* owner_;
             float lifetime_;
             float damage_;
+            bool bDestroy_;
             Timer<Projectile> destroyTimer_;
     };

code/trunk/src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt

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

code/trunk/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_);
+        projectile->setOwner(this->getParentWeaponSystem()->getParentPawn());
     }
 }

code/trunk/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_;
 
     };