Changeset 8706 for code/trunk/src/orxonox/infos

Timestamp:

Jun 14, 2011, 8:53:28 PM (13 years ago)

Author:

dafrick

Message:

Merging presentation branch back into trunk.
There are many new features and also a lot of other changes and bugfixes, if you want to know, digg through the svn log.
Not everything is yet working as it should, but it should be fairly stable. If you habe any bug reports, just send me an email.

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/orxonox/infos/GametypeInfo.cc (modified) (4 diffs)
• src/orxonox/infos/GametypeInfo.h (modified) (4 diffs)
• src/orxonox/infos/PlayerInfo.cc (modified) (5 diffs)
• src/orxonox/infos/PlayerInfo.h (modified) (2 diffs)

code/trunk/src/orxonox/infos/GametypeInfo.cc

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Damian 'Mozork' Frick
  *
  */
+
+/**
+    @file GametypeInfo.cc
+    @brief Implementation of the GametypeInfo class
+*/
 
 #include "GametypeInfo.h"
@@ -31 +36 @@
 #include "core/CoreIncludes.h"
 #include "core/GameMode.h"
+#include "network/Host.h"
 #include "network/NetworkFunction.h"
-#include "network/Host.h"
+#include "util/Convert.h"
+
+#include "controllers/HumanController.h"
 #include "interfaces/GametypeMessageListener.h"
+#include "interfaces/NotificationListener.h"
+
+#include "PlayerInfo.h"
 
 namespace orxonox
@@ -45 +56 @@
     registerMemberNetworkFunction(GametypeInfo, dispatchFadingMessage);
 
+    registerMemberNetworkFunction(GametypeInfo, changedReadyToSpawn);
+    registerMemberNetworkFunction(GametypeInfo, changedSpawned);
+
+    /*static*/ const std::string GametypeInfo::NOTIFICATION_SENDER("gameinfo");
+
+    /**
+    @brief
+        Registers and initializes the object.
+    */
     GametypeInfo::GametypeInfo(BaseObject* creator) : Info(creator)
     {
         RegisterObject(GametypeInfo);
-
+        
         this->bStarted_ = false;
         this->bEnded_ = false;
-        this->startCountdown_ = 0;
+        this->startCountdown_ = 0.0f;
         this->bStartCountdownRunning_ = false;
+        this->counter_ = 0;
+        this->spawned_ = false;
+        this->readyToSpawn_ = false;
 
         this->registerVariables();
@@ -63 +86 @@
     void GametypeInfo::registerVariables()
     {
-        registerVariable(this->bStarted_,               VariableDirection::ToClient);
-        registerVariable(this->bEnded_,                 VariableDirection::ToClient);
+        registerVariable(this->bStarted_,               VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedStarted));
+        registerVariable(this->bEnded_,                 VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedEnded));
+        registerVariable(this->bStartCountdownRunning_, VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedStartCountdownRunning));
         registerVariable(this->startCountdown_,         VariableDirection::ToClient);
-        registerVariable(this->bStartCountdownRunning_, VariableDirection::ToClient);
+        registerVariable(this->counter_,                VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedCountdownCounter));
         registerVariable(this->hudtemplate_,            VariableDirection::ToClient);
     }
+
+    /**
+    @brief
+        Is called when the game has changed to started.
+    */
+    void GametypeInfo::changedStarted(void)
+    {
+        NotificationListener::sendCommand("clear", GametypeInfo::NOTIFICATION_SENDER);
+    }
+
+    /**
+    @brief
+        Is called when the game has changed to ended.
+    */
+    void GametypeInfo::changedEnded(void)
+    {
+        // If the game has ended, a "Game has ended" notification is displayed.
+        if(this->hasEnded())
+            NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER);
+    }
+
+    /**
+    @brief
+        Is called when the start countdown has been either started or stopped.
+    */
+    void GametypeInfo::changedStartCountdownRunning(void)
+    {
+        // Send first countdown notification if the countdown has started.
+        if(this->isReadyToSpawn() && !this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
+    }
+
+    /**
+    @brief
+        Is called when the start countdown counter has changed.
+    */
+    void GametypeInfo::changedCountdownCounter(void)
+    {
+        // Send countdown notification if the counter has gone down.
+        if(this->isReadyToSpawn() &&  !this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo that the local player has changed its ready to spawn status.
+    @param ready
+        Whether the player has become ready to spawn or not.
+    */
+    void GametypeInfo::changedReadyToSpawn(bool ready)
+    {
+        if(this->readyToSpawn_ == ready)
+            return;
+
+        this->readyToSpawn_ = ready;
+
+        // Send "Waiting for other players" if the player is ready to spawn but the game has not yet started nor is the countdown running.
+        if(this->readyToSpawn_ && !this->hasStarted() && !this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendNotification("Waiting for other players", GametypeInfo::NOTIFICATION_SENDER);
+        // Send current countdown if the player is ready to spawn and the countdown has already started.
+        else if(this->readyToSpawn_ && !this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo that the game has started.
+    */
+    void GametypeInfo::start(void)
+    {
+        if(this->bStarted_)
+            return;
+        
+        this->bStarted_ = true;
+        this->changedStarted();
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo that the game has ended.
+    */
+    void GametypeInfo::end(void)
+    {
+        if(this->bEnded_)
+            return;
+
+        this->bEnded_ = true;
+        this->changedEnded();
+    }
+
+    /**
+    @brief
+        Set the start countdown to the input value.
+    @param countdown
+        The countdown to be set.
+    */
+    void GametypeInfo::setStartCountdown(float countdown)
+    {
+        if(this->startCountdown_ == countdown || countdown < 0.0f)
+            return;
+        
+        this->startCountdown_ = countdown;
+        // Set the counter to the ceiling of the current countdown.
+        this->counter_ = std::ceil(countdown);
+        this->changedCountdownCounter();
+    }
+
+    /**
+    @brief
+        Count down the start countdown by the specified value.
+    @param countDown
+        The amount by which we count down.
+    */
+    void GametypeInfo::countdownStartCountdown(float countDown)
+    {
+        float newCountdown = this->startCountdown_ - countDown;
+        // If we have switched integers or arrived at zero, we also count down the start countdown counter.
+        if(ceil(newCountdown) != ceil(this->startCountdown_) || newCountdown <= 0.0f)
+            this->countDown();
+        this->startCountdown_ = newCountdown;
+    }
+
+    /**
+    @brief
+        Count down the start countdown counter.
+    */
+    void GametypeInfo::countDown()
+    {
+        if(this->counter_ == 0)
+            return;
+        
+        this->counter_--;
+        this->changedCountdownCounter();
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo about the start of the start countdown.
+    */
+    void GametypeInfo::startStartCountdown(void)
+    {
+        if(GameMode::isMaster())
+        {
+            if(this->bStartCountdownRunning_)
+                return;
+
+            this->bStartCountdownRunning_ = true;
+            this->changedStartCountdownRunning();
+        }
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo about the stop of the start countdown.
+    */
+    void GametypeInfo::stopStartCountdown(void)
+    {
+        if(GameMode::isMaster())
+        {
+            if(!this->bStartCountdownRunning_)
+                return;
+
+            this->bStartCountdownRunning_ = false;
+            this->changedStartCountdownRunning();
+        }
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo about a player that is ready to spawn.
+    @param player
+        The player that is ready to spawn.
+    */
+    void GametypeInfo::playerReadyToSpawn(PlayerInfo* player)
+    {
+        if(GameMode::isMaster())
+        {
+            // If the player has spawned already.
+            if(this->spawnedPlayers_.find(player) != this->spawnedPlayers_.end())
+                return;
+
+            this->spawnedPlayers_.insert(player);
+            this->setReadyToSpawnHelper(player, true);
+        }
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo about a player whose Pawn has been killed.
+    @param player
+        The player whose Pawn has been killed.
+    */
+    void GametypeInfo::pawnKilled(PlayerInfo* player)
+    {
+        if(GameMode::isMaster())
+        {
+            NotificationListener::sendNotification("Press [Fire] to respawn", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+            // Remove the player from the list of players that have spawned, since it currently is not.
+            this->spawnedPlayers_.erase(player);
+            this->setReadyToSpawnHelper(player, false);
+            this->setSpawnedHelper(player, false);
+        }
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo about a player that has spawned.
+    @param player
+        The player that has spawned.
+    */
+    void GametypeInfo::playerSpawned(PlayerInfo* player)
+    {
+        if(GameMode::isMaster())
+        {
+            if(this->hasStarted() && !this->hasEnded())
+
+                this->setSpawnedHelper(player, true);
+        }
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo that the local player has changed its spawned status.
+    @param spawned
+        Whether the local player has changed to spawned or to not spawned.
+    */
+    void GametypeInfo::changedSpawned(bool spawned)
+    {
+        if(this->spawned_ == spawned)
+            return;
+        
+        this->spawned_ = spawned;
+        // Clear the notifications if the Player has spawned.
+        if(this->spawned_ && !this->hasEnded())
+            NotificationListener::sendCommand("clear", GametypeInfo::NOTIFICATION_SENDER);
+    }
+
+    /**
+    @brief
+        Inform the GametypeInfo about a player that has entered,
+    @param player
+        The player that has entered.
+    */
+    void GametypeInfo::playerEntered(PlayerInfo* player)
+    {
+        if(GameMode::isMaster())
+        {
+            if( player->isHumanPlayer() )
+            {
+                // Display "Press [Fire] to start the match" if the game has not yet ended.
+                if(!this->hasEnded())
+                    NotificationListener::sendNotification("Press [Fire] to start the match", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+                // Else display "Game has ended".
+                else
+                    NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+            }
+        }
+    }
+
+    /**
+    @brief
+        Helper method. Sends changedReadyToSpawn notifiers over the network.
+    @param player
+        The player that has changed its ready to spawn status.
+    @param ready
+        The new ready to spawn status.
+    */
+    void GametypeInfo::setReadyToSpawnHelper(PlayerInfo* player, bool ready)
+    {
+        if(GameMode::isMaster())
+        {
+            if(player->getClientID() == CLIENTID_SERVER)
+                this->changedReadyToSpawn(ready);
+            else
+                callMemberNetworkFunction(GametypeInfo, changedReadyToSpawn, this->getObjectID(), player->getClientID(), ready);
+        }
+    }
+
+    /**
+    @brief
+        Helper method. Sends changedSpawned notifiers over the network.
+    @param player
+        The player that has changed its spawned status.
+    @param ready
+        The new spawned status.
+    */
+    void GametypeInfo::setSpawnedHelper(PlayerInfo* player, bool spawned)
+    {
+        if(GameMode::isMaster())
+        {
+            if(player->getClientID() == CLIENTID_SERVER)
+                    this->changedSpawned(spawned);
+            else
+                callMemberNetworkFunction(GametypeInfo, changedSpawned, this->getObjectID(), player->getClientID(), spawned);
+        }
+    }
+
+    // Announce messages.
+    // TODO: Replace with notifications.
 
     void GametypeInfo::sendAnnounceMessage(const std::string& message)

code/trunk/src/orxonox/infos/GametypeInfo.h

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Damian 'Mozork' Frick
  *
  */
+
+/**
+    @file GametypeInfo.h
+    @brief Definition of the GametypeInfo class
+*/
 
 #ifndef _GametypeInfo_H__
@@ -33 +38 @@
 
 #include <string>
+
 #include "Info.h"
 
 namespace orxonox
 {
+
+    /**
+    @brief
+        The GametypeInfo class keeps track of the state of the game and provides facilities to inform the player about it.
+
+    @author
+        Fabian 'x3n' Landau
+    @author
+        Damian 'Mozork' Frick
+    */
     class _OrxonoxExport GametypeInfo : public Info
     {
@@ -45 +61 @@
             virtual ~GametypeInfo();
 
+            /**
+            @brief Get whether the game has started yet.
+            @return Returns true if the game has started, false if not.
+            */
             inline bool hasStarted() const
                 { return this->bStarted_; }
+            void changedStarted(void); // Is called when the game has changed to started.
+            
+            /**
+            @brief Get whether the game has ended yet.
+            @return Returns true if the game has ended, false if not.
+            */
             inline bool hasEnded() const
                 { return this->bEnded_; }
+            void changedEnded(void); // Is called when the game has changed to ended.
 
+            /**
+            @brief Get whether the start countdown is currently running.
+            @return Returns true if the countdown is running, false if not.
+            */
             inline bool isStartCountdownRunning() const
                 { return this->bStartCountdownRunning_; }
+            void changedStartCountdownRunning(void); // Is called when the start countdown has been either started or stopped.
+
+            /**
+            @brief Get the current value of the start countdown.
+            @return Returns the current value of the start countdown.
+            */
             inline float getStartCountdown() const
                 { return this->startCountdown_; }
+
+            /**
+            @brief Get the current start countdown counter.
+                   The start countdown counter only has integer values that correspond to the actually displayed countdown.
+            @return Returns the current integer countdown counter.
+            */
+            inline unsigned int getStartCountdownCounter() const
+                { return this->counter_; }
+            void changedCountdownCounter(void); // Is called when the start countdown counter has changed.
+
+            /**
+            @brief Get whether the local player is ready to spawn.
+            @return Returns true if the player is ready to spawn, false if not.
+            */
+            inline bool isReadyToSpawn() const
+                { return this->readyToSpawn_; }
+            void changedReadyToSpawn(bool ready); // Inform the GametypeInfo that the local player has changed its spawned status.
+            
+            /**
+            @brief Get whether the local player is spawned.
+            @return Returns true if the local player is currently spawned, false if not.
+            */
+            inline bool isSpawned() const
+                { return this->spawned_; }
+            void changedSpawned(bool spawned); // Inform the GametypeInfo that the local player has changed its spawned status.
 
             inline const std::string& getHUDTemplate() const
@@ -70 +132 @@
             void dispatchStaticMessage(const std::string& message,const ColourValue& colour);
             void dispatchFadingMessage(const std::string& message);
+            
+        protected:
+            void start(void); // Inform the GametypeInfo that the game has started.
+            void end(void); // Inform the GametypeInfo that the game has ended.
+            void setStartCountdown(float countdown); // Set the start countdown to the input value.
+            void countdownStartCountdown(float countDown); // Count down the start countdown by the specified value.
+            void countDown(); // Count down the start countdown counter.
+            void startStartCountdown(void); // Inform the GametypeInfo about the start of the start countdown.
+            void stopStartCountdown(void); // Inform the GametypeInfo about the stop of the start countdown.
+            void playerReadyToSpawn(PlayerInfo* player); // Inform the GametypeInfo about a player that is ready to spawn.
+            void pawnKilled(PlayerInfo* player); // Inform the GametypeInfo about a player whose Pawn has been killed.
+            void playerSpawned(PlayerInfo* player); // Inform the GametypeInfo about a player that has spawned.
+            void playerEntered(PlayerInfo* player); // Inform the GametypeInfo about a player that has entered,
+
+            inline void setHUDTemplate(const std::string& templateName)
+                { this->hudtemplate_ = templateName; };
 
         private:
             void registerVariables();
+            void setSpawnedHelper(PlayerInfo* player, bool spawned); // Helper method. Sends changedReadyToSpawn notifiers over the network.
+            void setReadyToSpawnHelper(PlayerInfo* player, bool ready); // Helper method. Sends changedSpawned notifiers over the network.
 
-            bool bStarted_;
-            bool bEnded_;
-            bool bStartCountdownRunning_;
-            float startCountdown_;
+            static const std::string NOTIFICATION_SENDER; //!< The name of the sender for the sending of notifications.
+
+            bool bStarted_; //!< Whether the game has started,
+            bool bEnded_; //!< Whether the game has ended.
+            bool bStartCountdownRunning_; //!< Whether the start countdown is running.
+            float startCountdown_; //!< The current value of the start countdown.
+            unsigned int counter_; //!< The current integer value of the start countdown, the start countdown counter.
             std::string hudtemplate_;
+            
+            std::set<PlayerInfo*> spawnedPlayers_; //!< A set of players that are currently spawned.
+            bool spawned_; //!< Whether the local Player is currently spawned.
+            bool readyToSpawn_; //!< Whether the local Player is ready to spawn.
     };
 }

code/trunk/src/orxonox/infos/PlayerInfo.cc

@@ -51 +51 @@
         this->controllableEntity_ = 0;
         this->controllableEntityID_ = OBJECTID_UNKNOWN;
-        this->oldControllableEntity_ = 0;
 
         this->gtinfo_ = 0;
@@ -151 +150 @@
             return;
 
-        if (this->oldControllableEntity_)
+        while (this->previousControllableEntity_.size() > 0)
             this->stopTemporaryControl();
+        
         if (this->controllableEntity_)
             this->stopControl();
@@ -177 +177 @@
             return;
 
-        assert( this->oldControllableEntity_==0 );
-
-        this->oldControllableEntity_ = this->controllableEntity_;
+        this->controllableEntity_->destroyHud(); // HACK-ish
+        this->previousControllableEntity_.push_back(WeakPtr<ControllableEntity>(this->controllableEntity_));
         this->controllableEntity_ = entity;
         this->controllableEntityID_ = entity->getObjectID();
@@ -194 +193 @@
     void PlayerInfo::stopControl()
     {
-        if ( this->oldControllableEntity_ )
+        while ( this->previousControllableEntity_.size() > 0)
             this->stopTemporaryControl();
 
@@ -215 +214 @@
     }
 
+    void PlayerInfo::pauseControl()
+    {
+        ControllableEntity* entity = this->controllableEntity_;
+
+        if (!entity)
+            return;
+
+        this->controllableEntity_->getController()->setActive(false);
+        //this->controllableEntity_->getController()->setControllableEntity(NULL);
+        this->controllableEntity_->setController(0);
+    }
+
     void PlayerInfo::stopTemporaryControl()
     {
         ControllableEntity* entity = this->controllableEntity_;
 
-        assert( this->controllableEntity_ && this->oldControllableEntity_ );
-        if( !entity || !this->oldControllableEntity_ )
+        assert(this->controllableEntity_ != NULL);
+        if( !entity || this->previousControllableEntity_.size() == 0 )
             return;
 
         this->controllableEntity_->setController(0);
+        this->controllableEntity_->destroyHud(); // HACK-ish
         
-        this->controllableEntity_ = this->oldControllableEntity_;
+//        this->controllableEntity_ = this->previousControllableEntity_.back();
+        do {
+            this->controllableEntity_ = this->previousControllableEntity_.back();
+        } while(this->controllableEntity_ == NULL && this->previousControllableEntity_.size() > 0);
         this->controllableEntityID_ = this->controllableEntity_->getObjectID();
-        this->oldControllableEntity_ = 0;
-
-        if ( this->controllableEntity_ && this->controller_)
+        this->previousControllableEntity_.pop_back();
+
+        if ( this->controllableEntity_ != NULL && this->controller_ != NULL)
             this->controller_->setControllableEntity(this->controllableEntity_);
+
+         // HACK-ish
+        if(this->controllableEntity_ != NULL)
+            this->controllableEntity_->createHud();
 
         if ( GameMode::isMaster() )

code/trunk/src/orxonox/infos/PlayerInfo.h

@@ -68 +68 @@
             void startControl(ControllableEntity* entity);
             void stopControl();
+            void pauseControl();
             void startTemporaryControl(ControllableEntity* entity);
             void stopTemporaryControl();
@@ -98 +99 @@
             Controller* controller_;
             ControllableEntity* controllableEntity_;
-            ControllableEntity* oldControllableEntity_;
+            std::vector< WeakPtr<ControllableEntity> > previousControllableEntity_; //!< List of the previous ControllableEntities if repeatedly startTemporary control was called. The ControllableEntity at the back is the most recent.
             unsigned int controllableEntityID_;