Changeset 8998 for code/branches

Timestamp:

Dec 18, 2011, 2:35:02 PM (13 years ago)

Author:

jo

Message:

Merged SpaceraceTwo. Old racelevel does not work anymore.

Location:

code/branches/presentation2011

Files:

• . (modified) (1 prop)
• data/levels/Spacerace2.oxw (copied) (copied from code/branches/spaceraceTwo/data/levels/Spacerace2.oxw)
• src/modules/gametypes/CMakeLists.txt (modified) (1 diff)
• src/modules/gametypes/RaceCheckPoint.cc (modified) (6 diffs)
• src/modules/gametypes/RaceCheckPoint.h (modified) (3 diffs)
• src/modules/gametypes/SpaceRace.cc (modified) (5 diffs)
• src/modules/gametypes/SpaceRace.h (modified) (4 diffs)
• src/modules/gametypes/SpaceRaceManager.cc (copied) (copied from code/branches/spaceraceTwo/src/modules/gametypes/SpaceRaceManager.cc)
• src/modules/gametypes/SpaceRaceManager.h (copied) (copied from code/branches/spaceraceTwo/src/modules/gametypes/SpaceRaceManager.h)
• src/modules/objects/triggers/DistanceMultiTrigger.h (modified) (1 diff)
• src/modules/objects/triggers/MultiTrigger.h (modified) (1 diff)
• src/orxonox/gametypes/Gametype.cc (modified) (8 diffs)
• src/orxonox/gametypes/Gametype.h (modified) (1 diff)
• src/orxonox/infos/GametypeInfo.cc (modified) (2 diffs)
• src/orxonox/infos/PlayerInfo.cc (modified) (1 diff)

code/branches/presentation2011/src/modules/gametypes/CMakeLists.txt

@@ -2 +2 @@
   SpaceRace.cc
   RaceCheckPoint.cc
+  SpaceRaceManager.cc
 )
 

code/branches/presentation2011/src/modules/gametypes/RaceCheckPoint.cc

@@ -34 +34 @@
 #include "chat/ChatManager.h"
 
+#include <infos/PlayerInfo.h>
+#include <worldentities/ControllableEntity.h>
+
 #include "SpaceRace.h"
 
@@ -39 +42 @@
 {
     CreateFactory(RaceCheckPoint);
+    
+     
 
-    RaceCheckPoint::RaceCheckPoint(BaseObject* creator): DistanceTrigger(creator), RadarViewable(creator, static_cast<WorldEntity*>(this))
+    RaceCheckPoint::RaceCheckPoint(BaseObject* creator): DistanceMultiTrigger(creator), RadarViewable(creator, static_cast<WorldEntity*>(this))
     {
         RegisterObject(RaceCheckPoint);
-
-        this->bCheckpointIndex_ = 0;
-        this->bIsLast_ = false;
+        this->setDistance(100);
+        this->setBeaconMode("off");
+        this->setBroadcast(false);
+        this->setSimultaneousTriggerers(100);
         this->bTimeLimit_ = 0;
 
@@ -51 +57 @@
         this->setRadarObjectShape(RadarViewable::Triangle);
         this->setRadarVisibility(false);
+        this->settingsChanged();
+        this->reached_=NULL;
+      
     }
+    
 
-    RaceCheckPoint::~RaceCheckPoint()
-    {
-    }
+   RaceCheckPoint::~RaceCheckPoint()
+   {
+    
+   }
 
     void RaceCheckPoint::tick(float dt)
@@ -63 +74 @@
         SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
         assert(gametype);
-        if (this->getCheckpointIndex() == gametype->getCheckpointsReached())
-            this->setRadarVisibility(true);
-        else
-            this->setRadarVisibility(false);
     }
 
@@ -72 +79 @@
     {
         SUPER(RaceCheckPoint, XMLPort, xmlelement, mode);
-
+        Vector3 v= Vector3(0,0,0);
         XMLPortParam(RaceCheckPoint, "checkpointindex", setCheckpointIndex, getCheckpointIndex, xmlelement, mode).defaultValues(0);
         XMLPortParam(RaceCheckPoint, "islast", setLast, getLast, xmlelement, mode).defaultValues(false);
         XMLPortParam(RaceCheckPoint, "timelimit", setTimelimit, getTimeLimit, xmlelement, mode).defaultValues(0);
+    XMLPortParamTemplate(RaceCheckPoint, "nextcheckpoints", setNextcheckpoint, getNextcheckpoint, xmlelement, mode,const Vector3&).defaultValues(v);
     }
 
-    void RaceCheckPoint::triggered(bool bIsTriggered)
+    void RaceCheckPoint::fire(bool bIsTriggered,BaseObject* player)
     {
-        DistanceTrigger::triggered(bIsTriggered);
-
+        DistanceMultiTrigger::fire((bool)bIsTriggered,player);
+        
         SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
-        if (gametype && this->getCheckpointIndex() == gametype->getCheckpointsReached() && bIsTriggered)
-        {
-            gametype->clock_.capture();
-            float time = gametype->clock_.getSecondsPrecise();
-            if (this->bTimeLimit_!=0 && time > this->bTimeLimit_)
-            {
-                gametype->timeIsUp();
-                gametype->end();
-            }
-            else if (this->getLast())
-                gametype->end();
-            else
-            {
-                gametype->newCheckpointReached();
-                this->setRadarObjectColour(ColourValue::Green); //sets the radar colour of the checkpoint to green if it is reached, else it is red.
-            }
-        }
+        assert(gametype);
+        ControllableEntity* entity = (ControllableEntity*) player;
+     
+        PlayerInfo* player2 = entity->getPlayer();
+     
+        if(bIsTriggered)
+            this->reached_=player2;
     }
 
@@ -108 +106 @@
         {
             SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
+            assert(gametype);
             if (gametype)
             {

code/branches/presentation2011/src/modules/gametypes/RaceCheckPoint.h

@@ -32 +32 @@
 #include "gametypes/GametypesPrereqs.h"
 
-#include "objects/triggers/DistanceTrigger.h"
+
+
+#include "objects/triggers/DistanceMultiTrigger.h"
 #include "interfaces/RadarViewable.h"
 
@@ -40 +42 @@
     @brief
         The RaceCheckPoint class enables the creation of a check point to use in a SpaceRace level.
-        !!! Don't forget to control the indexes of your check points and to set one last check point!!!
+         Don't forget to control the indexes of your check points and to set one last check point
     */
-    class _GametypesExport RaceCheckPoint : public DistanceTrigger, public RadarViewable
+    class _GametypesExport RaceCheckPoint : public DistanceMultiTrigger, public RadarViewable
     {
         public:
@@ -50 +52 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
+            inline void setCheckpointIndex(int checkpointIndex)
+                { this->bCheckpointIndex_ = checkpointIndex; }
+            inline int getCheckpointIndex()
+                { return this->bCheckpointIndex_; }
 
-            protected:
-            virtual void triggered(bool bIsTriggered);
+            inline void setNextcheckpoint(const Vector3& checkpoints)
+                { this->nextcheckpoints_=checkpoints; }
+            inline void setNextcheckpoint(float x, float y, float z)
+                { this->setNextcheckpoint(Vector3(x, y, z)); }
+            inline const Vector3& getNextcheckpoint() const
+                { return this->nextcheckpoints_; }
             inline void setLast(bool isLast)
                 { this->bIsLast_ = isLast; }
             inline bool getLast()
                 { return this->bIsLast_; }
-            inline void setCheckpointIndex(int checkpointIndex)
-                { this->bCheckpointIndex_ = checkpointIndex; }
-            inline int getCheckpointIndex()
-                { return this->bCheckpointIndex_; }
+
+            bool bIsLast_; //True if this check point is the last of the level. There can be only one last check point for each level and there must be a last check point in the level.
+            float bTimeLimit_; //The time limit (from the start of the level) to reach this check point. If the check point is reached after this time, the game ends and the player looses.
+            PlayerInfo* reached_;
+                
+            inline float getTimeLimit()
+                { return this->bTimeLimit_; }
+    
+        protected:
+            virtual void fire(bool bIsTriggered,BaseObject* player);
             virtual void setTimelimit(float timeLimit);
-            inline float getTimeLimit()
-                { return this->bTimeLimit_;}
+            
             inline const WorldEntity* getWorldEntity() const
                 { return this; }
 
         private:
-            int bCheckpointIndex_; //The index of this check point. This value will be compared with the number of check points reached in the level. The check points must be indexed in ascending order beginning from zero and without any jumps between the indexes.
-            bool bIsLast_; //True if this check point is the last of the level. There can be only one last check point for each level and there must be a last check point in the level.
-            float bTimeLimit_; //The time limit (from the start of the level) to reach this check point. If the check point is reached after this time, the game ends and the player looses.
-      
+            int bCheckpointIndex_; //The index of this check point. The race starts with the check point with the index 0
+            Vector3 nextcheckpoints_; //the indexes of the next check points
+            
     };
 }

code/branches/presentation2011/src/modules/gametypes/SpaceRace.cc

@@ -29 +29 @@
 #include "SpaceRace.h"
 
+
+#include "items/Engine.h"
+
 #include "core/CoreIncludes.h"
 #include "chat/ChatManager.h"
 #include "util/Convert.h"
 #include "util/Math.h"
+
+#include "items/Engine.h"
 
 namespace orxonox
@@ -41 +46 @@
     {
         RegisterObject(SpaceRace);
-        this->checkpointsReached_ = 0;
+        
         this->bTimeIsUp_ = false;
         this->numberOfBots_ = 0;
+        this->cantMove_=false;
+        
     }
+       
+    
+  // void SpaceRace::SetConfigValues(){
+    //SUPER(Gametype,setConfigValues);
+    //this->Gametype::SetConfigValue(initialStartCountdown_, 3.0f);}
 
     void SpaceRace::end()
@@ -56 +68 @@
             int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
             const std::string& message = multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms) + " seconds !!\n"
-                        + "You didn't reach the check point " + multi_cast<std::string>(this->checkpointsReached_+1)
-                        + " before the time limit. You lose!";
+                        + "You didn't reach the check point  before the time limit. You lose!";
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
             ChatManager::message(message);
@@ -70 +81 @@
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
             ChatManager::message(message);
-/*
+
             float time = this->clock_.getSecondsPrecise();
             this->scores_.insert(time);
             std::set<float>::iterator it;
-            for (it=this->scores_.begin(); it!=this->scores_.end(); it++)
-                orxout(level::message) << multi_cast<std::string>(*it) << endl;
-*/
+            
+
         }
     }
@@ -82 +92 @@
     void SpaceRace::start()
     {
-        Gametype::start();
 
-        std::string message("The match has started! Reach the check points as quickly as possible!");
+        this->spawnPlayersIfRequested();
+        Gametype::checkStart(); 
+        this->cantMove_=true; 
+        
+        for(ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it) 
+        {
+            it->setActive(false);
+            
+        } 
+        this->addBots(this->numberOfBots_); 
+    }
+    
+    void SpaceRace::tick(float dt)
+    {
+        SUPER(SpaceRace,tick,dt);
+    
+        if(!this->isStartCountdownRunning() && this->cantMove_)
+        {
+            for(ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it) 
+            { 
+                it->setActive(true);
+                
+            }
+            this->cantMove_= false;
+            
+            std::string message("The match has started! Reach the check points as quickly as possible!");
+            const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+            ChatManager::message(message);            
+        }
+   
+    }
+
+    
+    
+    void SpaceRace::newCheckpointReached(SpaceRaceManager* p, int index,PlayerInfo* pl)
+    {
+        this->checkpointReached_[pl]=index;
+        this->clock_.capture();
+        int s = this->clock_.getSeconds();
+        int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
+        const std::string& message = "Checkpoint " + multi_cast<std::string>(index)
+            + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
+            + " seconds.";// Message is too long for a normal screen.
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
         ChatManager::message(message);
     }
-
-    void SpaceRace::newCheckpointReached()
-    {
-        this->checkpointsReached_++;
+   
+    void SpaceRace::newCheckpointReached(RaceCheckPoint* p, PlayerInfo* pl)
+    {   
+        int index = p->getCheckpointIndex();
+        this->checkpointReached_[pl]=index;
         this->clock_.capture();
         int s = this->clock_.getSeconds();
         int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
-        const std::string& message = "Checkpoint " + multi_cast<std::string>(this->getCheckpointsReached())
-                        + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
-                        + " seconds.";
+        const std::string& message = "Checkpoint " + multi_cast<std::string>(index)
+            + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
+            + " seconds.";
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
         ChatManager::message(message);
     }
+        
+    
+    void SpaceRace::playerEntered(PlayerInfo* player)
+    {
+        Gametype::playerEntered(player);
+    
+        this->checkpointReached_[player]=-1;
+        //this->playersAlive_++;
+    }
+    
+    bool SpaceRace::playerLeft(PlayerInfo* player)
+    {
+        return Gametype::playerLeft(player);
+        // bool valid_player = true;
+        //if (valid_player)
+       // {
+        //    this->playersAlive_--;
+        //}
 
+       // return valid_player;
+    }
+    
+    bool SpaceRace::allowPawnHit(Pawn* victim, Pawn* originator)
+    {
+        return false;
+    }
+
+    bool SpaceRace::allowPawnDamage(Pawn* victim, Pawn* originator)
+    {
+        return false;
+    }
+
+    bool SpaceRace::allowPawnDeath(Pawn* victim, Pawn* originator)
+    {
+        return false;
+    }
 }

code/branches/presentation2011/src/modules/gametypes/SpaceRace.h

@@ -34 +34 @@
 #include <set>
 #include <string>
+# include <vector>
 
 #include <util/Clock.h>
@@ -39 +40 @@
 #include "gametypes/Gametype.h"
 
-#include "RaceCheckPoint.h"
+#include "SpaceRaceManager.h"
 
 namespace orxonox
@@ -50 +51 @@
     {
         friend class RaceCheckPoint;
+       
 
         public:
@@ -58 +60 @@
             virtual void end();
 
-            virtual void newCheckpointReached();
+            virtual void newCheckpointReached(SpaceRaceManager* p, int index,PlayerInfo* pl);
+            virtual void newCheckpointReached(RaceCheckPoint* p, PlayerInfo* pl);
 
-            inline void setCheckpointsReached(int n)
-                { this->checkpointsReached_ = n;}
-            inline int getCheckpointsReached()
-                { return this->checkpointsReached_; }
+            inline void setCheckpointReached(int n, PlayerInfo* p)
+                { this->checkpointReached_[p] = n;}
+            inline int getCheckpointReached(PlayerInfo* p)
+                { return this->checkpointReached_[p]; }
+
             inline void timeIsUp()
                 { this->bTimeIsUp_ = true;}
+            void tick(float dt);
+            Clock clock_; //The clock starts running at the beginning of the game. It is used to give the time at each check point, the give the time at the end of the game, and to stop the game if a check point is reached too late.
 
+
+            bool allowPawnHit(Pawn* victim, Pawn* originator);
+
+            bool allowPawnDamage(Pawn* victim, Pawn* originator);
+
+            bool allowPawnDeath(Pawn* victim, Pawn* originator);
         protected:
-
+            virtual void playerEntered(PlayerInfo* player); //!< Initializes values.
+            virtual bool playerLeft(PlayerInfo* player); //!< Manages all local variables.
         private:
-            int checkpointsReached_; //The current number of check points reached by the player.
+            bool cantMove_;
+            std::map<PlayerInfo*, int>checkpointReached_; //The number of the last check point reached by each player.
             std::set<float> scores_; //The times of the players are saved in a set.
             bool bTimeIsUp_; //True if one of the check points is reached too late.
-            Clock clock_; //The clock starts running at the beginning of the game. It is used to give the time at each check point, the give the time at the end of the game, and to stop the game if a check point is reached too late.
+            
+            int playersAlive_;
     };
 }

code/branches/presentation2011/src/modules/objects/triggers/DistanceMultiTrigger.h

@@ -91 +91 @@
     @ingroup MultiTrigger
     */
-    class _ObjectsExport DistanceMultiTrigger : public MultiTrigger
+    class _ObjectsExport DistanceMultiTrigger : public MultiTrigger 
     {
 

code/branches/presentation2011/src/modules/objects/triggers/MultiTrigger.h

@@ -157 +157 @@
             bool isTriggered(BaseObject* triggerer = NULL); //!< Get whether the MultiTrigger is triggered for a given object.
 
-            void fire(bool status, BaseObject* originator = NULL);  //!< Helper method. Creates an Event for the given status and originator and fires it.
+            virtual void fire(bool status, BaseObject* originator = NULL);  //!< Helper method. Creates an Event for the given status and originator and fires it.
             void broadcast(bool status); //!< Helper method. Broadcasts an Event for every object that is a target.
 

code/branches/presentation2011/src/orxonox/gametypes/Gametype.cc

@@ -85 +85 @@
         this->dedicatedKillBots_ = createConsoleCommand( "dedicatedKillBots", createExecutor( createFunctor(&Gametype::killBots, this) ) );
         /* HACK HACK HACK */
-        //this->numberOfPlayers_ = 0;
     }
 
@@ -124 +123 @@
         if (this->gtinfo_->isStartCountdownRunning() && !this->gtinfo_->hasStarted())
             this->gtinfo_->countdownStartCountdown(dt);
-
+                        
         if (!this->gtinfo_->hasStarted())
         {
@@ -132 +131 @@
                 if(it->first->isHumanPlayer() && it->first->isReadyToSpawn())
                     this->gtinfo_->playerReadyToSpawn(it->first);
-            }
-
+                   
+                
+            }
             this->checkStart();
         }
@@ -144 +144 @@
     void Gametype::start()
     {
+         
         this->addBots(this->numberOfBots_);
 
@@ -149 +150 @@
 
         this->spawnPlayersIfRequested();
+        
+        
     }
 
@@ -377 +380 @@
                 {
                     this->gtinfo_->stopStartCountdown();
-                    this->gtinfo_->setStartCountdown(0.0f);;
+                    this->gtinfo_->setStartCountdown(0.0f);
                     this->start();
                 }
@@ -398 +401 @@
                             hashumanplayers = true;
                     }
+                         
                     if (allplayersready && hashumanplayers)
                     {
@@ -409 +413 @@
                 }
             }
+            
         }
     }

code/branches/presentation2011/src/orxonox/gametypes/Gametype.h

@@ -155 +155 @@
               { return this->gtinfo_->getNumberOfPlayers(); }
 
+        
+
         protected:
             virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;

code/branches/presentation2011/src/orxonox/infos/GametypeInfo.cc

@@ -71 +71 @@
         this->bStarted_ = false;
         this->bEnded_ = false;
-        this->startCountdown_ = 0.0f;
+        this->startCountdown_ = 10.0f;
         this->bStartCountdownRunning_ = false;
-        this->counter_ = 0;
+        this->counter_ = 10;
         this->spawned_ = false;
         this->readyToSpawn_ = false;
@@ -164 +164 @@
     {
         if(this->bStarted_)
-            return;
+           { return;}
         
         this->bStarted_ = true;
         this->changedStarted();
+        
+       
     }
 

code/branches/presentation2011/src/orxonox/infos/PlayerInfo.cc

@@ -58 +58 @@
 
         this->registerVariables();
+        
     }