Changeset 2428 for code

Timestamp:

Dec 13, 2008, 10:54:26 PM (16 years ago)

Author:

landauf

Message:

• Moved some variables from Gametype to GametypeInfo (Gametype exists only on the Server while GametypeInfo is synchronized)
• Created a new HUD-element, GametypeStatus, based on GametypeInfo (the same effect was formerly achieved by using a hack in Spectator and a TextOverlay)
• HumanController creates a HUD (additionally to the SpaceShips HUD) which includes GametypeStatus and ChatOverlay and even more in the future

Location:

code/branches/objecthierarchy2/src

Files:

• core/BaseObject.h (modified) (2 diffs)
• core/Super.h (modified) (3 diffs)
• network/Synchronisable.h (modified) (1 diff)
• orxonox/OrxonoxPrereqs.h (modified) (1 diff)
• orxonox/objects/controllers/Controller.cc (modified) (2 diffs)
• orxonox/objects/controllers/Controller.h (modified) (1 diff)
• orxonox/objects/gametypes/Gametype.cc (modified) (9 diffs)
• orxonox/objects/gametypes/Gametype.h (modified) (4 diffs)
• orxonox/objects/infos/CMakeLists.txt (modified) (1 diff)
• orxonox/objects/infos/GametypeInfo.cc (added)
• orxonox/objects/infos/GametypeInfo.h (added)
• orxonox/objects/infos/HumanPlayer.cc (modified) (5 diffs)
• orxonox/objects/infos/HumanPlayer.h (modified) (2 diffs)
• orxonox/objects/infos/PlayerInfo.cc (modified) (1 diff)
• orxonox/objects/infos/PlayerInfo.h (modified) (1 diff)
• orxonox/objects/worldentities/ControllableEntity.cc (modified) (5 diffs)
• orxonox/objects/worldentities/ControllableEntity.h (modified) (4 diffs)
• orxonox/objects/worldentities/pawns/Spectator.cc (modified) (4 diffs)
• orxonox/objects/worldentities/pawns/Spectator.h (modified) (2 diffs)
• orxonox/overlays/hud/CMakeLists.txt (modified) (1 diff)
• orxonox/overlays/hud/GametypeStatus.cc (added)
• orxonox/overlays/hud/GametypeStatus.h (added)

code/branches/objecthierarchy2/src/core/BaseObject.h

@@ -135 +135 @@
             inline Scene* getScene() const { return this->scene_; }
 
-            inline void setGametype(Gametype* gametype) { this->oldGametype_ = this->gametype_; this->gametype_ = gametype; this->changedGametype(); }
+            inline void setGametype(Gametype* gametype)
+            {
+                if (gametype != this->gametype_)
+                {
+                    this->oldGametype_ = this->gametype_;
+                    this->gametype_ = gametype;
+                    this->changedGametype();
+                }
+            }
             inline Gametype* getGametype() const { return this->gametype_; }
             inline Gametype* getOldGametype() const { return this->oldGametype_; }
-            virtual inline void changedGametype() {}
+            virtual void changedGametype() {}
 
             void fireEvent();
@@ -197 +205 @@
     SUPER_FUNCTION(6, BaseObject, changedMainState, false);
     SUPER_FUNCTION(9, BaseObject, changedName, false);
+    SUPER_FUNCTION(10, BaseObject, changedGametype, false);
 }
 

code/branches/objecthierarchy2/src/core/Super.h

@@ -265 +265 @@
     #define SUPER_changedName(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
+
+    #define SUPER_changedGametype(classname, functionname, ...) \
+        SUPER_NOARGS(classname, functionname)
     // (1/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 
@@ -513 +516 @@
 
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(9, changedName, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(10, changedGametype, false)
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
@@ -568 +575 @@
     SUPER_INTRUSIVE_DECLARATION(changedOverlayGroup);
     SUPER_INTRUSIVE_DECLARATION(changedName);
+    SUPER_INTRUSIVE_DECLARATION(changedGametype);
     // (3/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 

code/branches/objecthierarchy2/src/network/Synchronisable.h

@@ -111 +111 @@
     static unsigned int popDeletedObject(){ unsigned int i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
 
-    inline unsigned int getObjectID(){return objectID;}
-    inline unsigned int getClassID(){return classID;}
+    inline unsigned int getObjectID() const { return objectID; }
+    inline unsigned int getClassID() const { return classID; }
   protected:
     Synchronisable(BaseObject* creator);

code/branches/objecthierarchy2/src/orxonox/OrxonoxPrereqs.h

@@ -187 +187 @@
     class OverlayGroup;
     class OverlayText;
+    class GametypeStatus;
 
     //gui

code/branches/objecthierarchy2/src/orxonox/objects/controllers/Controller.cc

@@ -31 +31 @@
 
 #include "core/CoreIncludes.h"
+#include "overlays/OverlayGroup.h"
 
 namespace orxonox
@@ -42 +43 @@
         this->player_ = 0;
         this->controllableEntity_ = 0;
+        this->hud_ = 0;
+        this->bUpdateHUD_ = false;
     }
 
     Controller::~Controller()
     {
+        if (this->isInitialized() && this->hud_)
+            delete this->hud_;
+    }
+
+    void Controller::changedControllableEntity()
+    {
+        if (this->bUpdateHUD_)
+        {
+            this->updateHUD();
+            this->bUpdateHUD_ = false;
+        }
+
+        if (this->hud_)
+            this->hud_->setOwner(this->getControllableEntity());
+    }
+
+    void Controller::updateHUD()
+    {
+        if (this->hud_)
+        {
+            delete this->hud_;
+            this->hud_ = 0;
+        }
+
+        if (this->hudtemplate_ != "")
+        {
+            this->hud_ = new OverlayGroup(this);
+            this->hud_->addTemplate(this->hudtemplate_);
+            this->hud_->setOwner(this->getControllableEntity());
+        }
     }
 }

code/branches/objecthierarchy2/src/orxonox/objects/controllers/Controller.h

@@ -57 +57 @@
             inline ControllableEntity* getControllableEntity() const
                 { return this->controllableEntity_; }
-            virtual void changedControllableEntity() {}
+            virtual void changedControllableEntity();
+
+            inline void setHUDTemplate(const std::string& name)
+            {
+                if (name != this->hudtemplate_)
+                {
+                    this->hudtemplate_ = name;
+                    if (this->controllableEntity_)
+                        this->updateHUD();
+                    else
+                        this->bUpdateHUD_ = true;
+                }
+            }
+            inline const std::string& getHUDTemplate() const
+                { return this->hudtemplate_; }
+
+            inline OverlayGroup* getHUD() const
+                { return this->hud_; }
 
         protected:
+            void updateHUD();
+
             PlayerInfo* player_;
             ControllableEntity* controllableEntity_;
+            std::string hudtemplate_;
+            OverlayGroup* hud_;
+            bool bUpdateHUD_;
     };
 }

code/branches/objecthierarchy2/src/orxonox/objects/gametypes/Gametype.cc

@@ -34 +34 @@
 
 #include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
 #include "objects/infos/PlayerInfo.h"
 #include "objects/worldentities/pawns/Spectator.h"
@@ -44 +45 @@
     CreateUnloadableFactory(Gametype);
 
-    Gametype::Gametype(BaseObject* creator) : BaseObject(creator)
+    Gametype::Gametype(BaseObject* creator) : BaseObject(creator), gtinfo_(creator)
     {
         RegisterObject(Gametype);
@@ -50 +51 @@
         this->defaultControllableEntity_ = Class(Spectator);
 
-        this->bStarted_ = false;
-        this->bEnded_ = false;
         this->bAutoStart_ = false;
         this->bForceSpawn_ = false;
 
         this->initialStartCountdown_ = 3;
-        this->startCountdown_ = 0;
-        this->bStartCountdownRunning_ = false;
+
+        this->setConfigValues();
+    }
+
+    void Gametype::setConfigValues()
+    {
+        SetConfigValue(initialStartCountdown_, 3.0f);
     }
 
@@ -64 +68 @@
         SUPER(Gametype, tick, dt);
 
-        if (this->bStartCountdownRunning_ && !this->bStarted_)
-            this->startCountdown_ -= dt;
-
-        if (!this->bStarted_)
+        if (this->gtinfo_.bStartCountdownRunning_ && !this->gtinfo_.bStarted_)
+            this->gtinfo_.startCountdown_ -= dt;
+
+        if (!this->gtinfo_.bStarted_)
             this->checkStart();
         else
@@ -78 +82 @@
     {
         COUT(0) << "game started" << std::endl;
-        this->bStarted_ = true;
+        this->gtinfo_.bStarted_ = true;
 
         this->spawnPlayersIfRequested();
@@ -86 +90 @@
     {
         COUT(0) << "game ended" << std::endl;
-        this->bEnded_ = true;
+        this->gtinfo_.bEnded_ = true;
     }
 
@@ -173 +177 @@
                 it->second = PlayerState::Dead;
 
-                if (!it->first->isReadyToSpawn() || !this->bStarted_)
+                if (!it->first->isReadyToSpawn() || !this->gtinfo_.bStarted_)
                 {
                     SpawnPoint* spawn = this->getBestSpawnPoint(it->first);
@@ -196 +200 @@
     void Gametype::checkStart()
     {
-        if (!this->bStarted_)
-        {
-            if (this->bStartCountdownRunning_)
-            {
-                if (this->startCountdown_ <= 0)
-                {
-                    this->bStartCountdownRunning_ = false;
-                    this->startCountdown_ = 0;
+        if (!this->gtinfo_.bStarted_)
+        {
+            if (this->gtinfo_.bStartCountdownRunning_)
+            {
+                if (this->gtinfo_.startCountdown_ <= 0)
+                {
+                    this->gtinfo_.bStartCountdownRunning_ = false;
+                    this->gtinfo_.startCountdown_ = 0;
                     this->start();
                 }
@@ -226 +230 @@
                     if (allplayersready && hashumanplayers)
                     {
-                        this->startCountdown_ = this->initialStartCountdown_;
-                        this->bStartCountdownRunning_ = true;
+                        this->gtinfo_.startCountdown_ = this->initialStartCountdown_;
+                        this->gtinfo_.bStartCountdownRunning_ = true;
                     }
                 }

code/branches/objecthierarchy2/src/orxonox/objects/gametypes/Gametype.h

@@ -38 +38 @@
 #include "objects/worldentities/ControllableEntity.h"
 #include "objects/Tickable.h"
+#include "objects/infos/GametypeInfo.h"
 
 namespace orxonox
@@ -60 +61 @@
             virtual ~Gametype() {}
 
+            void setConfigValues();
+
             virtual void tick(float dt);
 
+            inline const GametypeInfo* getGametypeInfo() const
+                { return &this->gtinfo_; }
+
             inline bool hasStarted() const
-                { return this->bStarted_; }
+                { return this->gtinfo_.bStarted_; }
             inline bool hasEnded() const
-                { return this->bEnded_; }
+                { return this->gtinfo_.bEnded_; }
 
             virtual void start();
@@ -88 +94 @@
 
             inline bool isStartCountdownRunning() const
-                { return this->bStartCountdownRunning_; }
+                { return this->gtinfo_.bStartCountdownRunning_; }
             inline float getStartCountdown() const
-                { return this->startCountdown_; }
+                { return this->gtinfo_.startCountdown_; }
 
         private:
@@ -104 +110 @@
             void spawnDeadPlayersIfRequested();
 
-            bool bStarted_;
-            bool bEnded_;
+            GametypeInfo gtinfo_;
+
             bool bAutoStart_;
             bool bForceSpawn_;
 
             float initialStartCountdown_;
-            float startCountdown_;
-            bool bStartCountdownRunning_;
 
             std::map<PlayerInfo*, PlayerState::Enum> players_;

code/branches/objecthierarchy2/src/orxonox/objects/infos/CMakeLists.txt

@@ -4 +4 @@
   PlayerInfo.cc
   HumanPlayer.cc
+  GametypeInfo.cc
 )
 

code/branches/objecthierarchy2/src/orxonox/objects/infos/HumanPlayer.cc

@@ -37 +37 @@
 #include "objects/controllers/HumanController.h"
 #include "objects/gametypes/Gametype.h"
+#include "overlays/OverlayGroup.h"
 
 namespace orxonox
@@ -63 +64 @@
     {
         SetConfigValue(nick_, "Player").callback(this, &HumanPlayer::configvaluecallback_changednick);
+        SetConfigValue(hudtemplate_, "defaultHUD").callback(this, &HumanPlayer::configvaluecallback_changedHUDTemplate);
     }
 
@@ -69 +71 @@
         REGISTERSTRING(this->synchronize_nick_, direction::toserver, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_changednick));
 
-        REGISTERDATA(this->clientID_,     direction::toclient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_clientIDchanged));
+        REGISTERDATA(this->clientID_,           direction::toclient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_clientIDchanged));
         REGISTERDATA(this->server_initialized_, direction::toclient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_server_initialized));
         REGISTERDATA(this->client_initialized_, direction::toserver, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_client_initialized));
@@ -83 +85 @@
                 this->setName(this->nick_);
         }
+    }
+
+    void HumanPlayer::configvaluecallback_changedHUDTemplate()
+    {
+        this->changedController();
     }
 
@@ -138 +145 @@
         this->networkcallback_clientIDchanged();
     }
+
+    void HumanPlayer::changedController()
+    {
+        if (this->getController())
+        {
+            this->getController()->setHUDTemplate(this->hudtemplate_);
+
+            if (this->getController() && this->getController()->getHUD())
+                this->getController()->getHUD()->setOwner(this->getControllableEntity());
+        }
+    }
 }

code/branches/objecthierarchy2/src/orxonox/objects/infos/HumanPlayer.h

@@ -51 +51 @@
             void setClientID(unsigned int clientID);
 
+            virtual void changedController();
+
         protected:
             void configvaluecallback_changednick();
+            void configvaluecallback_changedHUDTemplate();
             void networkcallback_changednick();
             void networkcallback_clientIDchanged();
@@ -60 +63 @@
             std::string nick_;
             std::string synchronize_nick_;
+            std::string hudtemplate_;
             bool server_initialized_;
             bool client_initialized_;

code/branches/objecthierarchy2/src/orxonox/objects/infos/PlayerInfo.cc

@@ -112 +112 @@
         if (this->controllableEntity_)
             this->controller_->setControllableEntity(this->controllableEntity_);
+        this->changedController();
     }
 
     void PlayerInfo::startControl(ControllableEntity* entity)
     {
+        if (entity == this->controllableEntity_)
+            return;
+
         if (this->controllableEntity_)
             this->stopControl(this->controllableEntity_);

code/branches/objecthierarchy2/src/orxonox/objects/infos/PlayerInfo.h

@@ -71 +71 @@
                 { return this->controllableEntity_; }
 
+            inline Controller* getController() const
+                { return this->controller_; }
+            virtual void changedController() {}
+
         protected:
             void createController();

code/branches/objecthierarchy2/src/orxonox/objects/worldentities/ControllableEntity.cc

@@ -38 +38 @@
 #include "objects/worldentities/Camera.h"
 #include "objects/worldentities/CameraPosition.h"
+#include "objects/gametypes/Gametype.h"
 #include "overlays/OverlayGroup.h"
 
@@ -59 +60 @@
         this->bDestroyWhenPlayerLeft_ = false;
 
+        this->gtinfo_ = 0;
+        this->gtinfoID_ = OBJECTID_UNKNOWN;
+        this->changedGametype();
+
         this->velocity_ = Vector3::ZERO;
         this->acceleration_ = Vector3::ZERO;
@@ -98 +103 @@
 
         XMLPortObject(ControllableEntity, CameraPosition, "camerapositions", addCameraPosition, getCameraPosition, xmlelement, mode);
+    }
+
+    void ControllableEntity::changedGametype()
+    {
+        SUPER(ControllableEntity, changedGametype);
+
+        this->gtinfo_ = 0;
+        this->gtinfoID_ = OBJECTID_UNKNOWN;
+
+        if (this->getGametype() && this->getGametype()->getGametypeInfo())
+        {
+            this->gtinfo_ = this->getGametype()->getGametypeInfo();
+            this->gtinfoID_ = this->gtinfo_->getObjectID();
+        }
     }
 
@@ -199 +218 @@
     }
 
+    void ControllableEntity::networkcallback_changedgtinfoID()
+    {
+        if (this->gtinfoID_ != OBJECTID_UNKNOWN)
+        {
+            this->gtinfo_ = dynamic_cast<GametypeInfo*>(Synchronisable::getSynchronisable(this->gtinfoID_));
+
+            if (!this->gtinfo_)
+                this->gtinfoID_ = OBJECTID_UNKNOWN;
+        }
+    }
+
     void ControllableEntity::startLocalHumanControl()
     {
@@ -268 +298 @@
 
         REGISTERDATA(this->playerID_, direction::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
+        REGISTERDATA(this->gtinfoID_, direction::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedgtinfoID));
     }
 

code/branches/objecthierarchy2/src/orxonox/objects/worldentities/ControllableEntity.h

@@ -46 +46 @@
             virtual void tick(float dt);
             void registerVariables();
+
+            virtual void changedGametype();
 
             virtual void setPlayer(PlayerInfo* player);
@@ -143 +145 @@
                 { return this->bHasHumanController_; }
 
+            inline const GametypeInfo* getGametypeInfo() const
+                { return this->gtinfo_; }
+
         protected:
             virtual void startLocalHumanControl();
@@ -165 +170 @@
 
             void networkcallback_changedplayerID();
+            void networkcallback_changedgtinfoID();
 
             unsigned int server_overwrite_;
@@ -190 +196 @@
             std::list<CameraPosition*> cameraPositions_;
             std::string cameraPositionTemplate_;
+
+            const GametypeInfo* gtinfo_;
+            unsigned int gtinfoID_;
     };
 }

code/branches/objecthierarchy2/src/orxonox/objects/worldentities/pawns/Spectator.cc

@@ -57 +57 @@
         this->roll_ = 0;
         this->setHudTemplate("spectatorhud");
-        this->hudmode_ = 0;
 
         this->setDestroyWhenPlayerLeft(true);
@@ -96 +95 @@
         REGISTERDATA(this->bGreetingFlareVisible_, direction::toclient, new NetworkCallback<Spectator>(this, &Spectator::changedFlareVisibility));
         REGISTERDATA(this->bGreeting_,             direction::toserver, new NetworkCallback<Spectator>(this, &Spectator::changedGreeting));
-        REGISTERDATA(this->hudmode_,               direction::toclient);
     }
 
@@ -112 +110 @@
     void Spectator::tick(float dt)
     {
-        this->updateHUD();
-
         if (this->hasLocalController())
         {
@@ -193 +189 @@
         }
     }
-
-    void Spectator::updateHUD()
-    {
-        // <hack>
-        if (Core::isMaster())
-        {
-            if (this->getPlayer() && this->getGametype())
-            {
-                if (!this->getGametype()->hasStarted() && !this->getGametype()->isStartCountdownRunning())
-                {
-                    if (!this->getPlayer()->isReadyToSpawn())
-                        this->hudmode_ = 0;
-                    else
-                        this->hudmode_ = 1;
-                }
-                else if (!this->getGametype()->hasEnded())
-                {
-                    if (this->getGametype()->isStartCountdownRunning())
-                        this->hudmode_ = 2 + 10*(int)ceil(this->getGametype()->getStartCountdown());
-                    else
-                        this->hudmode_ = 3;
-                }
-                else
-                    this->hudmode_ = 4;
-            }
-            else
-                return;
-        }
-
-        if (this->getHUD())
-        {
-            std::string text;
-            int hudmode = this->hudmode_ % 10;
-
-            switch (hudmode)
-            {
-                case 0:
-                    text = "Press [Fire] to start the match";
-                    break;
-                case 1:
-                    text = "Waiting for other players";
-                    break;
-                case 2:
-                    text = convertToString((this->hudmode_ - 2) / 10);
-                    break;
-                case 3:
-                    text = "Press [Fire] to respawn";
-                    break;
-                case 4:
-                    text = "Game has ended";
-                    break;
-                default:;
-            }
-
-            std::map<std::string, OrxonoxOverlay*>::const_iterator it = this->getHUD()->getOverlays().begin();
-            for (; it != this->getHUD()->getOverlays().end(); ++it)
-            {
-                if (it->second->isA(Class(OverlayText)) && it->second->getName() == "state")
-                {
-                    OverlayText* overlay = dynamic_cast<OverlayText*>(it->second);
-                    if (overlay)
-                        overlay->setCaption(text);
-                    break;
-                }
-            }
-        }
-        // </hack>
-    }
 }

code/branches/objecthierarchy2/src/orxonox/objects/worldentities/pawns/Spectator.h

@@ -63 +63 @@
             void changedGreeting();
             void changedFlareVisibility();
-            void updateHUD();
 
             BillboardSet* greetingFlare_;
@@ -75 +74 @@
             float pitch_;
             float roll_;
-
-            int hudmode_;
     };
 }

code/branches/objecthierarchy2/src/orxonox/overlays/hud/CMakeLists.txt

@@ -6 +6 @@
   HUDHealthBar.cc
   ChatOverlay.cc
+  GametypeStatus.cc
 )