Changeset 7549 for code/trunk/src/modules

Timestamp:

Oct 16, 2010, 2:18:45 PM (14 years ago)

Author:

dafrick

Message:

Resolving some more TODO's.

Location:

code/trunk/src/modules/pickup

Files:

• DroppedPickup.cc (modified) (1 diff)
• DroppedPickup.h (modified) (1 diff)
• PickupManager.cc (modified) (2 diffs)
• PickupSpawner.cc (modified) (5 diffs)
• PickupSpawner.h (modified) (3 diffs)

code/trunk/src/modules/pickup/DroppedPickup.cc

@@ -70 +70 @@
 
         this->setPosition(carrier->getCarrierPosition());
-        this->setActive(false);
-
-        //TODO: Do more elegantly.
-        this->startRespawnTimer();
+        this->block(carrier, DEFAULT_BLOCKED_TIME);
     }
 

code/trunk/src/modules/pickup/DroppedPickup.h

@@ -64 +64 @@
             virtual Pickupable* getPickup(void); //!< Creates the Pickupable that is going to get picked up.
 
+        private:
+            static const unsigned int DEFAULT_BLOCKED_TIME = 10; //!< The default time a PickupCarrier is blocked from picking up the pickupable again, after it has dropped it.
+
     };
 }

code/trunk/src/modules/pickup/PickupManager.cc

@@ -75 +75 @@
         RegisterObject(PickupManager);
 
-        //TODO: Only create if isMaster().
         this->defaultRepresentation_ = new PickupRepresentation();
 
@@ -356 +355 @@
 
         // If we're either in standalone mode or this is the host whom the change of the pickup's status concerns.
-        //TODO: Needs to be added to server even if is was not picked up by it?
         if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
         {

code/trunk/src/modules/pickup/PickupSpawner.cc

@@ -108 +108 @@
     {
         this->triggerDistance_ = 10;
-        this->respawnTime_ = 0; //TODO: Smart? Shouldn't we have a better mechanism to prevent unwanted multiple pickups?
+        this->respawnTime_ = 5.0f;
         this->maxSpawnedItems_ = INF;
         this->spawnsRemaining_ = INF;
@@ -151 +151 @@
             PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
             this->attach(representation->getSpawnerRepresentation(this));
-            this->setActive(true); //TODO: Needed?
+            this->setActive(true);
         }
     }
@@ -183 +183 @@
             SmartPtr<PickupSpawner> temp = this; //Create a smart pointer to keep the PickupSpawner alive until we iterated through all Pawns (in case a Pawn takes the last pickup)
 
+            // Remove PickupCarriers from the blocked list if they have exceeded their time.
+            for(std::map<PickupCarrier*, std::time_t>::iterator it = this->blocked_.begin(); it != this->blocked_.end(); )
+            {
+                std::map<PickupCarrier*, std::time_t>::iterator temp = it;
+                it++;
+                if(temp->second < std::time(0))
+                    this->blocked_.erase(temp);
+            }
+
             // Iterate trough all Pawns.
-            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+            for(ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
             {
                 Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
                 PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(*it);
-                // If a Pawn, that fits the target-range of the item spawned by this Pickup, is in trigger-distance.
-                if (distance.length() < this->triggerDistance_ && carrier != NULL)
+                // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawnder, is in trigger-distance and the carrier is not blocked.
+                if(distance.length() < this->triggerDistance_ && carrier != NULL && this->blocked_.find(carrier) == this->blocked_.end())
                 {
                     if(carrier->isTarget(this->pickup_))
@@ -292 +301 @@
 
             PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
-            if(carrier == NULL)
-            {
-                COUT(1) << "This is bad. Pawn isn't PickupCarrier." << std::endl;
-                return;
-            }
-
+            assert(carrier);
+
+            // If the Pawn isn't a target of the Pickupable.
             if(!carrier->isTarget(this->pickup_))
             {
@@ -307 +313 @@
             Pickupable* pickup = this->getPickup();
 
+            this->block(carrier);
+
             assert(pickup);
             assert(target);

code/trunk/src/modules/pickup/PickupSpawner.h

@@ -38 +38 @@
 #include "PickupPrereqs.h"
 
+#include <map>
 #include <string>
 #include "tools/Timer.h"
@@ -102 +103 @@
             inline int getMaxSpawnedItems(void) const
                 { return this->maxSpawnedItems_; }
-            
 
         protected:
             void decrementSpawnsRemaining(void); //!< Decrements the number of remaining spawns.
-            void startRespawnTimer(void);
+            void startRespawnTimer(void); //!< Invoked by the timer, re-activates the PickupSpawner.
+
+            /**
+            @brief Helper method. Adds a PickupCarrier to the list of PickupCarrier that are blocked form getting a Pickupable from the PickupSpawner for a specified time.
+            @param carrier A pointer to the PickupCarrier to be blocked.
+            @param time The time for which the Pawn is blocked. Default is 5.
+            */
+            void block(PickupCarrier* carrier, unsigned int time = DEFAULT_BLOCKED_TIME)
+                { this->blocked_.insert(std::pair<PickupCarrier*, std::time_t>(carrier, std::time(0)+time)); }
 
             /**
@@ -142 +150 @@
             float respawnTime_; //!< Time after which this gets re-actived.
             Timer respawnTimer_; //!< Timer used for re-activating.
+            std::map<PickupCarrier*, std::time_t> blocked_;
 
             bool selfDestruct_; //!< True if the PickupSpawner is selfdestructing.
 
             static const int INF = -1; //!< Constant for infinity.
+            static const unsigned int DEFAULT_BLOCKED_TIME = 5; //!< The default time a PickupCarrier is blocked after picking up a Pickupable.
     };
 }