Changeset 9232 for code/branches/captureTheFlag/src/modules

Timestamp:

May 23, 2012, 5:56:57 PM (13 years ago)

Author:

decapitb

Message:

safety checkin

Location:

code/branches/captureTheFlag

Files:

• . (modified) (1 prop)
• src/modules/overlays/hud/HUDNavigation.cc (modified) (6 diffs)
• src/modules/overlays/hud/HUDNavigation.h (modified) (3 diffs)
• src/modules/pickup/items/FlagPickup.cc (copied) (copied from code/branches/captureTheFlag/src/modules/pickup/items/FlagPickup.cc) (8 diffs)
• src/modules/pickup/items/FlagPickup.h (copied) (copied from code/branches/captureTheFlag/src/modules/pickup/items/FlagPickup.h) (5 diffs)

code/branches/captureTheFlag/src/modules/overlays/hud/HUDNavigation.cc

@@ -36 +36 @@
 #include <OgreTextAreaOverlayElement.h>
 #include <OgrePanelOverlayElement.h>
+#include <OgreEntity.h>
 
 #include "util/Math.h"
@@ -45 +46 @@
 #include "Radar.h"
 #include "graphics/Camera.h"
+#include "graphics/Model.h"
+#include "worldentities/MovableEntity.h"
 #include "controllers/HumanController.h"
 #include "worldentities/pawns/Pawn.h"
@@ -80 +83 @@
     this->setNavMarkerSize ( 0.05f );
     this->setDetectionLimit( 10000.0f ); 
+
+    //Ogre::Entity* ent = this->getScene()->getSceneManager()->createEntity("Arrow3D", "Arrow3D.mesh");
+
+    Model* arrow = new Model(this);
+    this->arrowEntity = new MovableEntity(this);
+    arrow->setMeshSource("Arrow3D.mesh");
+    arrow->setSyncMode(0);
+    this->arrowEntity->attach(arrow);
+    this->arrowEntity->scale(1);
+    this->arrowEntity->setVisible(true);
+    this->arrowEntity->setPosition(0, +30, -100);
+    this->arrowEntity->setSyncMode(0);
+    this->arrowEntity->attachToNode(this->overlay3d_);
+    //this->add3DMesh(arrowEntity);
+
+    //this->overlay3d_->setPosition(0, 0, 0);
+    //this->overlay3d_->setVisible(false, true);
+    this->overlay_->setZOrder(0);
+    this->overlay_->show();
+    hideArrow3D();
 }
 
@@ -178 +201 @@
     unsigned int markerCount_ = 0;
     bool closeEnough_ = false; //only display objects that are close enough to be relevant for the player
+
+    //for the first element of sortedObjectList_ / the closest waypoint show the Arrow3D
+    //set the direction of the arrow to the closest waypoint
+    if(!sortedObjectList_.empty())
+    {
+        showArrow3D();
+                sortedList::iterator firstIt = sortedObjectList_.begin();
+
+                Ogre::Vector3 pos1 = camTransform * firstIt->first->getRVWorldPosition();
+                orxout(user_info, context::events()) << pos1 << endl;
+                this->arrowEntity->setDirection(1-pos1.x, 1 - pos1.y, 1 - pos1.z);
+
+                //this->arrowEntity->rotate(quat);
+                //this->overlay3d_->setDirection(pos1);
+    }
+    else{hideArrow3D();}
+
 
 //         for (ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); ++it)
@@ -382 +422 @@
     this->background_->addChild ( text );
 
-    sortedObjectList_.push_front ( std::make_pair ( object, ( unsigned int ) 0 ) );
+    Ogre::Vector3 temp = object->getWorldEntity()->getPosition();
+    unsigned int distance = sqrt(temp.x*temp.x+temp.y*temp.y+temp.z*temp.z);
+
+
+
+    sortedObjectList_.push_front ( std::make_pair ( object, distance ) );
 
 
@@ -445 +490 @@
     }
 }
-
-}
+void HUDNavigation::showArrow3D()
+                { this->overlay3d_->setVisible(true, true);}
+void HUDNavigation::hideArrow3D()
+                { this->overlay3d_->setVisible(false, true);}
+
+
+}

code/branches/captureTheFlag/src/modules/overlays/hud/HUDNavigation.h

@@ -42 +42 @@
 #include "overlays/OrxonoxOverlay.h"
 
+
 namespace orxonox
 {
@@ -51 +52 @@
 
     void setConfigValues();
+
+
 
     virtual void XMLPort ( Element& xmlelement, XMLPort::Mode mode );
@@ -80 +83 @@
 
     };
+
+    void showArrow3D();
+    void hideArrow3D();
+
+    orxonox::MovableEntity* arrowEntity;
 
     bool showObject( RadarViewable* rv );

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

@@ -39 +39 @@
 
 #include "pickup/PickupIdentifier.h"
-#include "worldentities/pawns/Pawn.h"
 
 namespace orxonox
 {
-
-    /*static*/ const std::string FlagPickup::flagTypeBlue_s = "blue";
-    /*static*/ const std::string FlagPickup::flagTypeRed_s = "red";
-    /*static*/ const std::string FlagPickup::flagTypeNeutral_s = "neutral";
 
     CreateFactory(FlagPickup);
@@ -76 +71 @@
     void FlagPickup::initialize(void)
     {
-        this->flagType_ = pickupFlagType::0;
+        this->flagType_ = 0;
 
         this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
@@ -87 +82 @@
     void FlagPickup::initializeIdentifier(void)
     {
-        std::string val1 = this->getFlagType();
+        std::stringstream stream;
+        int type = this->getFlagType();
+        stream << type;
+                std::string val = stream.str();
+                
         std::string type1 = "flagType";
-        this->pickupIdentifier_->addParameter(type1, val1);
+        this->pickupIdentifier_->addParameter(type1, val);
     }
 
@@ -113 +112 @@
         Returns the falg type as a string.
     */
-    const std::string& FlagPickup::getFlagType(void) const
+    const int FlagPickup::getFlagType(void) const
     {
-        switch(this->getFlagTypeDirect())
-        {
-            case pickupFlagType::blue:
-                return FlagPickup::flagTypeBlue_s;
-            case pickupFlagType::red:
-                return FlagPickup::flagTypeRed_s;
-            case pickupFlagType::neutral:
-                return FlagPickup::flagTypeNeutral_s;
-            default:
-                orxout(internal_error, context::pickups) << "Invalid flagType in FlagPickup." << endl;
-                return BLANKSTRING;
-        }
-    }
+                return this->flagType_;
+        }
 
     /**
@@ -135 +123 @@
         The type as a string.
     */
-    void FlagPickup::setFlagType(std::string type)
+    void FlagPickup::setFlagType(int type)
     {
-        if(type == FlagPickup::flagTypeRed_s)
-            this->setFlagTypeDirect(pickupFlagType::2);
-        else if(type == FlagPickup::flagTypeBlue_s)
-            this->setFlagTypeDirect(pickupFlagType::1);
-        else if(type == FlagPickup::flagTypeNeutral_s)
-            this->setFlagTypeDirect(pickupFlagType::0);
-        else
+        if(type<3){
+                this->flagType_ = type;
+        }
+        
+        else{
             orxout(internal_error, context::pickups) << "Invalid flagType '" << type << "' in FlagPickup." << endl;
+        }
     }
 
@@ -163 +150 @@
            if(this->isUsed())
            {
-               int team = getTeam(pawn->getPlayer);
-
-               if(this->flagType_ == team){
-                   if(pawn->hasFlag_){
-                           teamScore_ = TeamScore_ + 1000;
-                           pawn->hasFlag_ = false;
-                   }
-               this->Pickupable::destroy();
-               }else{
-                   pawn->hasFlag_ = true;
-               }
+                 this->bPickedUp_ = true;
+                 this->pickedUpBy_ = pawn;
            }
        }
-
-
 
        /**
@@ -196 +172 @@
        }
 
-    int FlagPickup::getTeam(PlayerInfo* player)
-    {
-        std::map<PlayerInfo*, int>::const_iterator it_player = this->teamnumbers_.find(player);
-        if (it_player != this->teamnumbers_.end())
-            return it_player->second;
-        else
-            return -1;
-    }
 
-}
 
         void FlagPickup::tick(float dt)
@@ -213 +180 @@
                Pawn* pawn = this->carrierToPawnHelper();
 
-                   if(pawn->isAlive() && pawn->hasFlag_){
+                   if(pawn->isAlive() && pawn->hasFlag()){
                this->Pickupable::destroy();
                    }
 
            }
+}

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

@@ -37 +37 @@
 
 #include "pickup/PickupPrereqs.h"
+#include "worldentities/pawns/Pawn.h"
 
 #include <string>
@@ -42 +43 @@
 #include "pickup/Pickup.h"
 #include "tools/Timer.h"
+#include "tools/interfaces/Tickable.h"
 
 
@@ -47 +49 @@
 /*
     @ingroup PickupItems
-    */
-    namespace pickupFlagType
-    {
-        enum Value
-        {
-            blue, //!< Means that the @ref orxonox::FlagPickup "FlagPickup" is the flag of the blue team.
-            red, //!< Means that the @ref orxonox::FlagPickup "FlagPickup" is the flag of the red team.
-                neutral //!< Means that the @ref orxonox::FlagPickup "FlagPickup" is a neutral flag.
-        };
-    }
-
-    /**
+    
 
     @author
@@ -76 +67 @@
             virtual void tick(float dt);
 
-            const std::string& getFlagType(void) const; //!< Get the flag type of this pickup.
-
-        int teamScore_;
-
+            const int getFlagType(void) const; //!< Get the flag type of this pickup.
+            
+                inline bool isPickedUp() const
+                        { return this->bPickedUp_; }
+                inline Pawn* pickedUpBy() const
+                        { return this->pickedUpBy_; }
+                        
+                inline void setPickedUp(bool pickedUp)
+                { this->bPickedUp_ = pickedUp; }
+                
+                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.
 
@@ -89 +89 @@
             @param type The type of this pickup as an enum.
             */
-            inline void setFlagTypeDirect(pickupFlagType::Value type)
+            inline void setFlagTypeDirect(int type)
                 { this->flagType_ = type; }
-            void setFlagType(std::string type); //!< Set the type of the FlagPickup.
+            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.
-            int getTeam(PlayerInfo* player);
             void initialize(void); //!< Initializes the member variables.
-
-            pickupFlagType::Value flagType_; //!< The type of the FlagPickup.
-
-
-            //! Strings for the flag types.
-            static const std::string flagTypeBlue_s;
-            static const std::string flagTypeRed_s;
-                static const std::string flagTypeNeutral_s;
-
+            Pawn* pickedUpBy_;
+                        int flagType_;
+                        
+                        bool bPickedUp_;
+                        
     };
 }