Changeset 6518 for code/branches/pickup3/src/modules/pickup

Timestamp:

Mar 12, 2010, 8:56:04 AM (15 years ago)

Author:

dafrick

Message:

Renamed TestPickup to MetaPickup.

Location:

code/branches/pickup3/src/modules/pickup

Files:

• PickupPrereqs.h (modified) (1 diff)
• items/CMakeLists.txt (modified) (1 diff)
• items/MetaPickup.cc (moved) (moved from code/branches/pickup3/src/modules/pickup/items/TestPickup.cc) (5 diffs)
• items/MetaPickup.h (moved) (moved from code/branches/pickup3/src/modules/pickup/items/TestPickup.h) (4 diffs)

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

@@ -76 +76 @@
     //items
     class HealthPickup;
-    class TestPickup;
+    class MetaPickup;
     
 }

code/branches/pickup3/src/modules/pickup/items/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(PICKUP_SRC_FILES
   HealthPickup.cc
-  TestPickup.cc
+  MetaPickup.cc
 )

code/branches/pickup3/src/modules/pickup/items/MetaPickup.cc

@@ -32 +32 @@
 #include "pickup/PickupIdentifier.h"
 
-#include "TestPickup.h"
+#include "MetaPickup.h"
 
 namespace orxonox {
  
-    CreateFactory(TestPickup);
+    CreateFactory(MetaPickup);
     
-    /*static*/ const std::string TestPickup::testTypeNone_s = "none";
-    /*static*/ const std::string TestPickup::testTypeUse_s = "use";
-    /*static*/ const std::string TestPickup::testTypeDrop_s = "drop";
+    /*static*/ const std::string MetaPickup::metaTypeNone_s = "none";
+    /*static*/ const std::string MetaPickup::metaTypeUse_s = "use";
+    /*static*/ const std::string MetaPickup::metaTypeDrop_s = "drop";
     
-    TestPickup::TestPickup(BaseObject* creator) : Pickup(creator)
+    MetaPickup::MetaPickup(BaseObject* creator) : Pickup(creator)
     {
-        RegisterObject(TestPickup);
+        RegisterObject(MetaPickup);
         
         this->addTarget(ClassIdentifier<PickupCarrier>::getIdentifier());
         this->setActivationTypeDirect(pickupActivationType::immediate);
         this->setDurationTypeDirect(pickupDurationType::once);
-        this->testType_ = pickupTestType::none;
+        this->metaType_ = pickupMetaType::none;
     }
     
-    TestPickup::~TestPickup()
+    MetaPickup::~MetaPickup()
     {
         
     }
     
-    void TestPickup::initializeIdentifier(void)
+    void MetaPickup::initializeIdentifier(void)
     {
-        std::string val = this->getTestType();
-        std::string type = "testType";
+        std::string val = this->getMetaType();
+        std::string type = "metaType";
         this->pickupIdentifier_->addParameter(type, val);
     }
     
-    void TestPickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
+    void MetaPickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
     {
-        SUPER(TestPickup, XMLPort, xmlelement, mode);
+        SUPER(MetaPickup, XMLPort, xmlelement, mode);
         
-        XMLPortParam(TestPickup, "testType", setTestType, getTestType, xmlelement, mode);
+        XMLPortParam(MetaPickup, "metaType", setMetaType, getMetaType, xmlelement, mode);
         
         this->initializeIdentifier();
     }
     
-    void TestPickup::changedUsed(void)
+    void MetaPickup::changedUsed(void)
     {
-        SUPER(TestPickup, changedUsed);
+        SUPER(MetaPickup, changedUsed);
         
         if(this->isUsed())
         {
             PickupCarrier* carrier = this->getCarrier();
-            if(this->getTestTypeDirect() != pickupTestType::none && carrier != NULL)
+            if(this->getMetaTypeDirect() != pickupMetaType::none && carrier != NULL)
             {
                 std::set<Pickupable*> pickups = carrier->getPickups();
@@ -86 +86 @@
                 {
                     Pickup* pickup = dynamic_cast<Pickup*>(*it);
-                    if(this->getTestTypeDirect() == pickupTestType::use)
+                    if(this->getMetaTypeDirect() == pickupMetaType::use)
                     {
                         if(pickup != NULL && pickup != this && pickup->isOnUse() && !pickup->isUsed())
@@ -93 +93 @@
                         }
                     }
-                    if(this->getTestTypeDirect() == pickupTestType::drop)
+                    if(this->getMetaTypeDirect() == pickupMetaType::drop)
                     {
                         if(pickup != NULL && pickup != this)
@@ -106 +106 @@
     }
     
-    const std::string& TestPickup::getTestType(void)
+    const std::string& MetaPickup::getMetaType(void)
     {
-        switch(this->getTestTypeDirect())
+        switch(this->getMetaTypeDirect())
         {
-            case pickupTestType::none:
-                return TestPickup::testTypeNone_s;
-            case pickupTestType::use:
-                return TestPickup::testTypeUse_s;
-            case pickupTestType::drop:
-                return TestPickup::testTypeDrop_s;
+            case pickupMetaType::none:
+                return MetaPickup::metaTypeNone_s;
+            case pickupMetaType::use:
+                return MetaPickup::metaTypeUse_s;
+            case pickupMetaType::drop:
+                return MetaPickup::metaTypeDrop_s;
             default:
                 return BLANKSTRING;
@@ -121 +121 @@
     }
     
-    void TestPickup::setTestType(const std::string& type)
+    void MetaPickup::setMetaType(const std::string& type)
     {
-        if(type == TestPickup::testTypeNone_s)
+        if(type == MetaPickup::metaTypeNone_s)
         {
-            this->setTestTypeDirect(pickupTestType::none);
+            this->setMetaTypeDirect(pickupMetaType::none);
         }
-        else if(type == TestPickup::testTypeUse_s)
+        else if(type == MetaPickup::metaTypeUse_s)
         {
-            this->setTestTypeDirect(pickupTestType::use);
+            this->setMetaTypeDirect(pickupMetaType::use);
         }
-        else if(type == TestPickup::testTypeDrop_s)
+        else if(type == MetaPickup::metaTypeDrop_s)
         {
-            this->setTestTypeDirect(pickupTestType::drop);
+            this->setMetaTypeDirect(pickupMetaType::drop);
         }
     }
     
-    void TestPickup::clone(OrxonoxClass*& item)
+    void MetaPickup::clone(OrxonoxClass*& item)
     {
         if(item == NULL)
-            item = new TestPickup(this);
+            item = new MetaPickup(this);
         
-        SUPER(TestPickup, clone, item);
+        SUPER(MetaPickup, clone, item);
         
-        TestPickup* pickup = dynamic_cast<TestPickup*>(item);
-        pickup->setTestTypeDirect(this->getTestTypeDirect());
+        MetaPickup* pickup = dynamic_cast<MetaPickup*>(item);
+        pickup->setMetaTypeDirect(this->getMetaTypeDirect());
         
         pickup->initializeIdentifier();

code/branches/pickup3/src/modules/pickup/items/MetaPickup.h

@@ -27 +27 @@
 */
 
-#ifndef _TestPickup_H__
-#define _TestPickup_H__
+#ifndef _MetaPickup_H__
+#define _MetaPickup_H__
 
 #include "pickup/PickupPrereqs.h"
@@ -36 +36 @@
 namespace orxonox {
 
-    namespace pickupTestType
+    namespace pickupMetaType
     {
         enum Value
@@ -46 +46 @@
     }
     
-    class _PickupExport TestPickup : public Pickup
+    class _PickupExport MetaPickup : public Pickup
     {
         friend class PickupCarrier;
         
         public:
-            TestPickup(BaseObject* creator);
-            virtual ~TestPickup();
+            MetaPickup(BaseObject* creator);
+            virtual ~MetaPickup();
             
             virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a HealthPickup object through XML.
@@ -59 +59 @@
             virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             
-            inline pickupTestType::Value getTestTypeDirect(void)
-                { return this->testType_; }
-            const std::string& getTestType(void);
+            inline pickupMetaType::Value getMetaTypeDirect(void)
+                { return this->metaType_; }
+            const std::string& getMetaType(void);
             
         protected:
             void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
             
-            inline void setTestTypeDirect(pickupTestType::Value type)
-                { this->testType_ =  type; }
-            void setTestType(const std::string& type);
+            inline void setMetaTypeDirect(pickupMetaType::Value type)
+                { this->metaType_ =  type; }
+            void setMetaType(const std::string& type);
             
         private:
             void initialize(void); //!< Initializes the member variables.
             
-            pickupTestType::Value testType_;
-            static const std::string testTypeNone_s;
-            static const std::string testTypeUse_s;
-            static const std::string testTypeDrop_s;
+            pickupMetaType::Value metaType_;
+            static const std::string metaTypeNone_s;
+            static const std::string metaTypeUse_s;
+            static const std::string metaTypeDrop_s;