Changeset 9241 for code/branches/presentation2012/src

Timestamp:

May 24, 2012, 8:49:19 PM (13 years ago)

Author:

decapitb

Message:

tower defense update

Location:

code/branches/presentation2012

Files:

• . (modified) (1 prop)
• src (modified) (1 prop)
• src/modules (modified) (1 prop)
• src/modules/CMakeLists.txt (modified) (1 prop)
• src/modules/designtools (modified) (1 prop)
• src/modules/docking (modified) (1 prop)
• src/modules/gametypes (modified) (1 prop)
• src/modules/gametypes/CaptureTheFlag.cc (copied) (copied from code/branches/captureTheFlag/src/modules/gametypes/CaptureTheFlag.cc) (16 diffs)
• src/modules/gametypes/CaptureTheFlag.h (copied) (copied from code/branches/captureTheFlag/src/modules/gametypes/CaptureTheFlag.h) (2 diffs)
• src/modules/notifications (modified) (1 prop)
• src/modules/objects (modified) (1 prop)
• src/modules/overlays (modified) (1 prop)
• src/modules/pickup (modified) (1 prop)
• src/modules/pickup/PickupPrereqs.h (modified) (1 diff)
• src/modules/pickup/items/FlagPickup.cc (copied) (copied from code/branches/captureTheFlag/src/modules/pickup/items/FlagPickup.cc) (4 diffs)
• src/modules/pickup/items/FlagPickup.h (copied) (copied from code/branches/captureTheFlag/src/modules/pickup/items/FlagPickup.h) (3 diffs)
• src/modules/pong (modified) (1 prop)
• src/modules/portals (modified) (1 prop)
• src/modules/questsystem (modified) (1 prop)
• src/modules/tetris (modified) (1 prop)
• src/modules/weapons (modified) (1 prop)

code/branches/presentation2012/src/modules/gametypes/CaptureTheFlag.cc

@@ -28 +28 @@
 #include "CaptureTheFlag.h"
 
-#include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 #include "interfaces/TeamColourable.h"
@@ -39 +38 @@
 {
     CreateUnloadableFactory(CaptureTheFlag);
-
+    
     CaptureTheFlag::CaptureTheFlag(BaseObject* creator) : TeamBaseMatch(creator)
     {
@@ -47 +46 @@
         this->pointsTeam1_ = 0;
         this->pointsTeam2_ = 0;
-        
-        //this->flagTeamBlue = new FlagPickup(this);
-        //this->flagTeamRed = new FlagPickup(this);
-
+                
+//      this->flagTeamBlue = new FlagPickup(this);
+//      this->flagTeamRed = new FlagPickup(this);
+        
         this->setConfigValues();
     }
-
+    
     void CaptureTheFlag::tick(float dt){
+        
+        SUPER(CaptureTheFlag, tick, dt);
+        
         if(this->flagTeamBlue->isPickedUp()){
-                if(getTeam(this->flagTeamBlue->pickedUpBy()->getPlayer()) == 1){
+            teamnr = getTeam(this->flagTeamBlue->pickedUpBy()->getPlayer());
+                if(teamnr == 1){
                     this->flagTeamBlue->ignorePickedUp();
                     
                         if(this->flagTeamBlue->pickedUpBy()->hasFlag()){
-                                pointsTeam1_ += 1000;
+                    this->addTeamPoints(teamnr, 1000);
                                 this->flagTeamBlue->pickedUpBy()->setHasFlag(false);
                         }
@@ -70 +73 @@
         }
         if(this->flagTeamRed->isPickedUp()){
-                if(getTeam(this->flagTeamRed->pickedUpBy()->getPlayer()) == 0){
+            teamnr = getTeam(this->flagTeamBlue->pickedUpBy()->getPlayer());
+                if(teamnr == 0){
                     this->flagTeamRed->ignorePickedUp();
                     
                         if(this->flagTeamRed->pickedUpBy()->hasFlag()){
-                                pointsTeam1_ += 1000;
+                    this->addTeamPoints(teamnr, 1000);
                                 this->flagTeamRed->pickedUpBy()->setHasFlag(false);
                         }
@@ -83 +87 @@
                 }
         }
+        
     }
     void CaptureTheFlag::setConfigValues()
     {
         SetConfigValue(teams_, 2);
-
+        
         static ColourValue colours[] =
         {
@@ -96 +101 @@
         };
         static std::vector<ColourValue> defaultcolours(colours, colours + sizeof(colours) / sizeof(ColourValue));
-
+        
         SetConfigValue(teamcolours_, defaultcolours);
     }
-
+    
     void CaptureTheFlag::playerEntered(PlayerInfo* player)
     {
-        Deathmatch::playerEntered(player);
-
+        TeamBaseMatch::playerEntered(player);
+        
         std::vector<unsigned int> playersperteam(this->teams_, 0);
-
+        
         for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
             if (it->second < static_cast<int>(this->teams_) && it->second >= 0)
                 playersperteam[it->second]++;
-
+        
         unsigned int minplayers = static_cast<unsigned int>(-1);
         size_t minplayersteam = 0;
@@ -120 +125 @@
             }
         }
-
+        
         this->teamnumbers_[player] = minplayersteam;
     }
-
+    
     bool CaptureTheFlag::playerLeft(PlayerInfo* player)
     {
         bool valid_player = Deathmatch::playerLeft(player);
-
+        
         if (valid_player)
             this->teamnumbers_.erase(player);
-
+        
         return valid_player;
     }
-
+    
     bool CaptureTheFlag::allowPawnHit(Pawn* victim, Pawn* originator)
     {
         return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
     }
-
+    
     bool CaptureTheFlag::allowPawnDamage(Pawn* victim, Pawn* originator)
     {
         return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
     }
-
+    
     bool CaptureTheFlag::allowPawnDeath(Pawn* victim, Pawn* originator)
     {
         return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
     }
-
+    
     // collect Points for killing oppenents
-        void CaptureTheFlag::playerScored(PlayerInfo* player)
-        {
-            int teamnr = this->getTeam(player);
-            this->addTeamPoints(teamnr, 5);
-        }
-        
-        
-        // show points or each interval of time
-        void CaptureTheFlag::showPoints()
-        {
-            if (!this->hasStarted() || this->hasEnded())
-                return;
-
-            orxout(message) << "Points standing:" << '\n' << "Team Blue: "<< pointsTeam1_ << '\n' << "Team Red: " << pointsTeam2_ << endl;
-            if(pointsTeam1_ >=1700 && pointsTeam1_ < 2000) orxout(message) << "Team Blue is near victory!" << endl;
-            if(pointsTeam2_ >=1700 && pointsTeam2_ < 2000) orxout(message) << "Team Red is near victory!" << endl;
-        }
-        
-        // end game if one team reaches 2000 points
-        void CaptureTheFlag::endGame()
-        {
-            if (this->pointsTeam1_ >= 2000 || this->pointsTeam2_ >= 2000)
-            {
-                int winningteam = -1;
-
-                if (this->pointsTeam1_ > this->pointsTeam2_)
-                {
-                    orxout(message) << "Team Blue has won the match" << endl;
-                    winningteam = 0;
-                }
+    void CaptureTheFlag::playerScored(PlayerInfo* player)
+    {
+        int teamnr = this->getTeam(player);
+        this->addTeamPoints(teamnr, 5);
+    }
+    
+    
+    // show points or each interval of time
+    void CaptureTheFlag::showPoints()
+    {
+        if (!this->hasStarted() || this->hasEnded())
+            return;
+        
+        orxout(message) << "Points standing:" << '\n' << "Team Blue: "<< pointsTeam1_ << '\n' << "Team Red: " << pointsTeam2_ << endl;
+        if(pointsTeam1_ >=1700 && pointsTeam1_ < 2000) orxout(message) << "Team Blue is near victory!" << endl;
+        if(pointsTeam2_ >=1700 && pointsTeam2_ < 2000) orxout(message) << "Team Red is near victory!" << endl;
+    }
+    
+    // end game if one team reaches 2000 points
+    void CaptureTheFlag::endGame()
+    {
+        if (this->pointsTeam1_ >= 2000 || this->pointsTeam2_ >= 2000)
+        {
+            int winningteam = -1;
+            
+            if (this->pointsTeam1_ > this->pointsTeam2_)
+            {
+                orxout(message) << "Team Blue has won the match" << endl;
+                winningteam = 0;
+            }
+            else
+            {
+                orxout(message) << "Team Red has won the match" << endl;
+                winningteam = 1;
+            }
+            
+            for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+            {
+                if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                    continue;
+                
+                if (it->second == winningteam)
+                    this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
                 else
-                {
-                    orxout(message) << "Team Red has won the match" << endl;
-                    winningteam = 1;
-                }
-
-                for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
-                {
-                    if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
-                        continue;
-
-                    if (it->second == winningteam)
-                        this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
-                    else
-                        this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
-                }
-
-                this->end();
-                this->scoreTimer_.stopTimer();
-                this->outputTimer_.stopTimer();
-            }
-        }
-        
-        // this function is called by the function winPoints() which adds points to the teams for every base and killed openents at a certain time
-        void CaptureTheFlag::addTeamPoints(int team, int points)
-        {
-            if(team == 0)
-            {
-                this->pointsTeam1_ += points;
-            }
-            if(team == 1)
-            {
-                this->pointsTeam2_ += points;
-            }
-
-            this->endGame();
-        }
-
-        int TeamBaseMatch::getTeamPoints(int team)
-        {
-            if(team == 0)
-            {
-                return this->pointsTeam1_;
-            }
-            if(team == 1)
-            {
-                return this->pointsTeam2_;
-            }
-
-            return 0;
-        }
-        
+                    this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+            }
+            
+            this->end();
+            this->scoreTimer_.stopTimer();
+            this->outputTimer_.stopTimer();
+        }
+    }
+    
+    // this function is called by the function winPoints() which adds points to the teams for every base and killed openents at a certain time
+    void CaptureTheFlag::addTeamPoints(int team, int points)
+    {
+        if(team == 0)
+        {
+            this->pointsTeam1_ += points;
+        }
+        if(team == 1)
+        {
+            this->pointsTeam2_ += points;
+        }
+        
+        this->endGame();
+    }
+    
+    int TeamBaseMatch::getTeamPoints(int team)
+    {
+        if(team == 0)
+        {
+            return this->pointsTeam1_;
+        }
+        if(team == 1)
+        {
+            return this->pointsTeam2_;
+        }
+        
+        return 0;
+    }
+    
     SpawnPoint* CaptureTheFlag::getBestSpawnPoint(PlayerInfo* player) const
     {
@@ -238 +243 @@
         if (it_player != this->teamnumbers_.end())
             desiredTeamNr = it_player->second;
-
+        
         // Only use spawnpoints of the own team (or non-team-spawnpoints)
         std::set<SpawnPoint*> teamSpawnPoints = this->spawnpoints_;
@@ -252 +257 @@
                 }
             }
-
+            
             ++it;
         }
-
+        
         SpawnPoint* fallbackSpawnPoint = NULL;
         if (teamSpawnPoints.size() > 0)
@@ -269 +274 @@
                     break;
                 }
-
+                
                 ++index;
             }
-
+            
             // Remove all inactive SpawnPoints from the list.
             for (std::set<SpawnPoint*>::iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); )
@@ -281 +286 @@
                     continue;
                 }
-
+                
                 ++it;
             }
-
+            
             randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
             index = 0;
@@ -291 +296 @@
                 if (index == randomspawn)
                     return (*it);
-
+                
                 ++index;
             }
-
+            
             return fallbackSpawnPoint;
         }
-
+        
         return 0;
     }
-
+    
     void CaptureTheFlag::playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn)
     {
         if (!player)
             return;
-
+        
         // Set the team colour
         std::map<PlayerInfo*, int>::const_iterator it_player = this->teamnumbers_.find(player);
@@ -313 +318 @@
             {
                 pawn->setRadarObjectColour(this->teamcolours_[it_player->second]);
-
+                
                 std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
                 for (std::set<WorldEntity*>::iterator it = pawnAttachments.begin(); it != pawnAttachments.end(); ++it)
@@ -326 +331 @@
         }
     }
-
+    
     bool CaptureTheFlag::pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2)
     {
@@ -333 +338 @@
             std::map<PlayerInfo*, int>::const_iterator it1 = this->teamnumbers_.find(pawn1->getPlayer());
             std::map<PlayerInfo*, int>::const_iterator it2 = this->teamnumbers_.find(pawn2->getPlayer());
-
+            
             if (it1 != this->teamnumbers_.end() && it2 != this->teamnumbers_.end())
                 return (it1->second == it2->second);
@@ -339 +344 @@
         return false;
     }
-
+    
     int CaptureTheFlag::getTeam(PlayerInfo* player)
     {

code/branches/presentation2012/src/modules/gametypes/CaptureTheFlag.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 #include <set>
+#include "core/CoreIncludes.h"
+
 #include "tools/Timer.h"
 #include "gametypes/TeamBaseMatch.h"
 #include "infos/PlayerInfo.h"
 #include "pickup/items/FlagPickup.h"
+#include "pickup/PickupPrereqs.h"
 
 namespace orxonox
@@ -42 +45 @@
     {
     public:
-                        CaptureTheFlag(BaseObject* creator);
-                virtual ~CaptureTheFlag() {}
-
-                void tick(float dt);
-
-                void setConfigValues();
-
-                virtual void playerEntered(PlayerInfo* player);
-                virtual bool playerLeft(PlayerInfo* player);
-
-                virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
-                virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
-                virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
-
-                virtual void playerScored(PlayerInfo* player);
-                virtual void showPoints();
-                virtual void endGame();
-
-                void addTeamPoints(int team, int points);
-                int getTeamPoints(int team);
-
-                virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);
-
-                int getTeam(PlayerInfo* player);
-                inline const ColourValue& getTeamColour(int teamnr) const
-                    { return this->teamcolours_[teamnr]; }
-
-            protected:
-                virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
-                bool pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2);
-
-                std::map<PlayerInfo*, int> teamnumbers_;
-                std::vector<ColourValue> teamcolours_;
-                unsigned int teams_;
-
-                FlagPickup* flagTeamBlue;
-                FlagPickup* flagTeamRed;
-                //points for each team
-                int pointsTeam1_;
-                int pointsTeam2_;
-
+        CaptureTheFlag(BaseObject* creator);
+        virtual ~CaptureTheFlag() {}
+        
+        void tick(float dt);
+        
+        void setConfigValues();
+        
+        virtual void playerEntered(PlayerInfo* player);
+        virtual bool playerLeft(PlayerInfo* player);
+        
+        virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
+        virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
+        virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
+        
+        virtual void playerScored(PlayerInfo* player);
+        virtual void showPoints();
+        virtual void endGame();
+        
+        void addTeamPoints(int team, int points);
+        int getTeamPoints(int team);
+        
+        virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);
+        
+        int getTeam(PlayerInfo* player);
+        inline const ColourValue& getTeamColour(int teamnr) const
+        { return this->teamcolours_[teamnr]; }
+        
+    protected:
+        virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
+        bool pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2);
+        
+        std::map<PlayerInfo*, int> teamnumbers_;
+        std::vector<ColourValue> teamcolours_;
+        unsigned int teams_;
+        
+        FlagPickup* flagTeamBlue;
+        FlagPickup* flagTeamRed;
+        
+        //points for each team
+        int pointsTeam1_;
+        int pointsTeam2_;
+        int teamnr;
+        
     };
 }

code/branches/presentation2012/src/modules/pickup/PickupPrereqs.h

@@ -68 +68 @@
 namespace orxonox
 {
-
     class CollectiblePickup;
     class DroppedPickup;

code/branches/presentation2012/src/modules/pickup/items/FlagPickup.cc

@@ -28 +28 @@
 
 /**
-    @file FlagPickup.cc
-    @brief Implementation of the FlagPickup class.
-*/
+ @file FlagPickup.cc
+ @brief Implementation of the FlagPickup class.
+ */
 
 #include "FlagPickup.h"
@@ -37 +37 @@
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
-
 #include "pickup/PickupIdentifier.h"
 
 namespace orxonox
 {
-
+    
     CreateFactory(FlagPickup);
-
+    
     /**
-    @brief
-        Constructor. Registers the object and initializes the member variables.
-    */
+     @brief
+     Constructor. Registers the object and initializes the member variables.
+     */
     FlagPickup::FlagPickup(BaseObject* creator) : Pickup(creator)
     {
         RegisterObject(FlagPickup);
-
+        
         this->initialize();
     }
-
+    
     /**
-    @brief
-        Destructor.
-    */
+     @brief
+     Destructor.
+     */
     FlagPickup::~FlagPickup()
     {
-
+        
     }
-
+    
     /**
-    @brief
-        Initializes the member variables.
-    */
+     @brief
+     Initializes the member variables.
+     */
     void FlagPickup::initialize(void)
     {
         this->flagType_ = 0;
-
+        
         this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
     }
-
+    
     /**
-    @brief
-        Initializes the PickupIdentifier of this pickup.
-    */
+     @brief
+     Initializes the PickupIdentifier of this pickup.
+     */
     void FlagPickup::initializeIdentifier(void)
     {
@@ -90 +89 @@
         this->pickupIdentifier_->addParameter(type1, val);
     }
-
+    
     /**
-    @brief
-        Method for creating a FlagPickup object through XML.
-    */
+     @brief
+     Method for creating a FlagPickup object through XML.
+     */
     void FlagPickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
     {
         SUPER(FlagPickup, XMLPort, xmlelement, mode);
-
+        
         XMLPortParam(FlagPickup, "flagType", setFlagType, getFlagType, xmlelement, mode);
         //XMLPortParam(FlagPickup, "teamNumber", setTeamNumber, getTeamNumber, xmlelement, mode);
-
+        
         this->initializeIdentifier();
     }
-
-
+    
+    
     /**
-    @brief
-        Get the flag type of this pickup.
-    @return
-        Returns the falg type as a string.
-    */
+     @brief
+     Get the flag type of this pickup.
+     @return
+     Returns the falg type as a string.
+     */
     const int FlagPickup::getFlagType(void) const
     {
                 return this->flagType_;
         }
-
+    
     /**
-    @brief
-        Set the type of the HealthPickup.
-    @param type
-        The type as a string.
-    */
+     @brief
+     Set the type of the FlagPickup.
+     @param type
+     The type as a string.
+     */
     void FlagPickup::setFlagType(int type)
     {
@@ -133 +132 @@
         }
     }
+    
+    /**
+     @brief
+     Is called when the pickup has transited from used to unused or the other way around.
+     */
+    void FlagPickup::changedUsed(void)
+    {
+        SUPER(FlagPickup, changedUsed);
+        
+        Pawn* pawn = this->carrierToPawnHelper();
+        
+        if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+            this->Pickupable::destroy();
+        
+        // If the pickup has transited to used.
+        if(this->isUsed())
+        {
+            this->bPickedUp_ = true;
+            this->pickedUpBy_ = pawn;
+            orxout(internal_error, context::pickups) << "flag picked up." << endl;
 
+        }
+    }
+    
     /**
-       @brief
-           Is called when the pickup has transited from used to unused or the other way around.
-       */
-       void FlagPickup::changedUsed(void)
-       {
-           SUPER(FlagPickup, changedUsed);
-
-           Pawn* pawn = this->carrierToPawnHelper();
-
-           if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
-               this->Pickupable::destroy();
-
-           // If the pickup has transited to used.
-           if(this->isUsed())
-           {
-                 this->bPickedUp_ = true;
-                 this->pickedUpBy_ = pawn;
-           }
-       }
-
-       /**
-       @brief
-           Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
-       @return
-           A pointer to the Pawn, or NULL if the conversion failed.
-       */
-       Pawn* FlagPickup::carrierToPawnHelper(void)
-       {
-           PickupCarrier* carrier = this->getCarrier();
-           Pawn* pawn = dynamic_cast<Pawn*>(carrier);
-
-           if(pawn == NULL)
-               orxout(internal_error, context::pickups) << "Invalid PickupCarrier in HealthPickup." << endl;
-
-           return pawn;
-       }
-
-
-
+     @brief
+     Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
+     @return
+     A pointer to the Pawn, or NULL if the conversion failed.
+     */
+    Pawn* FlagPickup::carrierToPawnHelper(void)
+    {
+        PickupCarrier* carrier = this->getCarrier();
+        Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+        
+        if(pawn == NULL)
+            orxout(internal_error, context::pickups) << "Invalid PickupCarrier in Flag Pickup." << endl;
+        
+        return pawn;
+    }
+    
+    
+    
         void FlagPickup::tick(float dt)
-           {
-                   SUPER(FlagPickup, tick, dt);
-
-               Pawn* pawn = this->carrierToPawnHelper();
-
-                   if(pawn->isAlive() && pawn->hasFlag()){
-               this->Pickupable::destroy();
-                   }
-
-           }
+    {
+        SUPER(FlagPickup, tick, dt);
+        
+        //Pawn* pawn = this->carrierToPawnHelper();
+        
+//        if(pawn->isAlive() && pawn->hasFlag()){
+//            this->Pickupable::destroy();
+//        }
+        
+    }
 }

code/branches/presentation2012/src/modules/pickup/items/FlagPickup.h

@@ -28 +28 @@
 
 /**
-    @file FlagPickup.h
-    @brief Declaration of the FlagPickup class.
-    @ingroup PickupItems
-*/
+ @file FlagPickup.h
+ @brief Declaration of the FlagPickup class.
+ @ingroup PickupItems
+ */
 
 #ifndef _FlagPickup_H__
@@ -47 +47 @@
 
 namespace orxonox {
-/*
-    @ingroup PickupItems
-    
-
-    @author
-        Nino Weingart
-
-    @ingroup PickupItems
-    */
+    /*
+     @ingroup PickupItems
+     
+     
+     @author
+     Nino Weingart
+     
+     @ingroup PickupItems
+     */
     class _PickupExport FlagPickup : public Pickup, public Tickable
     {
-        public:
-
-            FlagPickup(BaseObject* creator); //!< Constructor.
-            virtual ~FlagPickup(); //!< Destructor.
-
-            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a FlagPickup object through XML.
-
-            virtual void tick(float dt);
-
+    public:
+        
+        FlagPickup(BaseObject* creator); //!< Constructor.
+        ~FlagPickup(); //!< Destructor.
+        
+        virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a FlagPickup object through XML.
+        
+        virtual void tick(float dt);
+        
             const int getFlagType(void) const; //!< Get the flag type of this pickup.
             
                 inline bool isPickedUp() const
-                        { return this->bPickedUp_; }
+        { return this->bPickedUp_; }
                 inline Pawn* pickedUpBy() const
-                        { return this->pickedUpBy_; }
-                        
+        { return this->pickedUpBy_; }
+        
                 inline void setPickedUp(bool pickedUp)
                 { this->bPickedUp_ = pickedUp; }
@@ -79 +79 @@
                 inline void ignorePickedUp()
                 { this->Pickupable::destroy(); }
-                        
+        
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-
-        protected:
-            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
-
-            /**
-            @brief Set the flag type of this pickup.
-            @param type The type of this pickup as an enum.
-            */
-            inline void setFlagTypeDirect(int type)
-                { this->flagType_ = type; }
-            void setFlagType(int type); //!< Set the type of the FlagPickup.
-
-        private:
-            Pawn* carrierToPawnHelper(void); //!< Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
-            void initialize(void); //!< Initializes the member variables.
-            Pawn* pickedUpBy_;
-                        int flagType_;
-                        
-                        bool bPickedUp_;
-                        
+        
+    protected:
+        void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
+        
+        /**
+         @brief Set the flag type of this pickup.
+         @param type The type of this pickup as an enum.
+         */
+        inline void setFlagTypeDirect(int type)
+        { this->flagType_ = type; }
+        
+        void setFlagType(int type); //!< Set the type of the FlagPickup.
+        
+    private:
+        Pawn* carrierToPawnHelper(void); //!< Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
+        void initialize(void); //!< Initializes the member variables.
+        Pawn* pickedUpBy_;
+        int flagType_;
+        
+        bool bPickedUp_;
+        
     };
 }