Changeset 9024

Timestamp:

Feb 26, 2012, 10:36:04 PM (12 years ago)

Author:

jo

Message:

I restructured the inheritance of gametypes: The base class of teamgametypes is now the class 'TeamGametype'. Now it is possible to create teamgametypes without needing the messages contained in TeamDeathmatch. By doing so the class 'TeamDeathmatch' exactly does the same as the Deathmatch class.

Location:

code/branches/pCuts/src/orxonox

Files:

• OrxonoxPrereqs.h (modified) (1 diff)
• gametypes/TeamDeathmatch.cc (modified) (2 diffs)
• gametypes/TeamDeathmatch.h (modified) (2 diffs)

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

@@ -109 +109 @@
     class TeamDeathmatch;
     class UnderAttack;
+    class TeamGametype;
 
     // graphics

code/branches/pCuts/src/orxonox/gametypes/TeamDeathmatch.cc

@@ -31 +31 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "chat/ChatManager.h"
 #include "interfaces/TeamColourable.h"
+#include "infos/PlayerInfo.h"
 #include "worldentities/TeamSpawnPoint.h"
 #include "worldentities/pawns/Pawn.h"
@@ -39 +41 @@
     CreateUnloadableFactory(TeamDeathmatch);
 
-    TeamDeathmatch::TeamDeathmatch(BaseObject* creator) : Deathmatch(creator)
+    TeamDeathmatch::TeamDeathmatch(BaseObject* creator) : TeamGametype(creator)
     {
         RegisterObject(TeamDeathmatch);
-
-        this->teams_ = 2;
-
-        this->setConfigValues();
     }
 
-    void TeamDeathmatch::setConfigValues()
+    void TeamDeathmatch::start()
     {
-        SetConfigValue(teams_, 2);
+        TeamGametype::start();
 
-        static ColourValue colours[] =
-        {
-            ColourValue(1.0f, 0.3f, 0.3f),
-            ColourValue(0.3f, 0.3f, 1.0f),
-            ColourValue(0.3f, 1.0f, 0.3f),
-            ColourValue(1.0f, 1.0f, 0.0f)
-        };
-        static std::vector<ColourValue> defaultcolours(colours, colours + sizeof(colours) / sizeof(ColourValue));
+        std::string message("The match has started!");
+        ChatManager::message(message);
+    }
 
-        SetConfigValue(teamcolours_, defaultcolours);
+    void TeamDeathmatch::end()
+    {
+        TeamGametype::end();
+
+        std::string message("The match has ended.");
+        ChatManager::message(message);
     }
 
     void TeamDeathmatch::playerEntered(PlayerInfo* player)
     {
-        Deathmatch::playerEntered(player);
+        TeamGametype::playerEntered(player);
 
-        std::vector<unsigned int> playersperteam(this->teams_, 0);
-
-        for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
-            if (it->second < static_cast<int>(this->teams_) && it->second >= 0)
-                playersperteam[it->second]++;
-
-        unsigned int minplayers = static_cast<unsigned int>(-1);
-        size_t minplayersteam = 0;
-        for (size_t i = 0; i < this->teams_; ++i)
-        {
-            if (playersperteam[i] < minplayers)
-            {
-                minplayers = playersperteam[i];
-                minplayersteam = i;
-            }
-        }
-
-        this->teamnumbers_[player] = minplayersteam;
+        const std::string& message = player->getName() + " entered the game";
+        ChatManager::message(message);
     }
 
     bool TeamDeathmatch::playerLeft(PlayerInfo* player)
     {
-        bool valid_player = Deathmatch::playerLeft(player);
+        bool valid_player = TeamGametype::playerLeft(player);
 
         if (valid_player)
-            this->teamnumbers_.erase(player);
+        {
+            const std::string& message = player->getName() + " left the game";
+            ChatManager::message(message);
+        }
+
+        return valid_player;
+    }
+    bool TeamDeathmatch::playerChangedName(PlayerInfo* player)
+    {
+        bool valid_player = TeamGametype::playerChangedName(player);
+
+        if (valid_player)
+        {
+            const std::string& message = player->getOldName() + " changed name to " + player->getName();
+            ChatManager::message(message);
+        }
 
         return valid_player;
     }
 
-    bool TeamDeathmatch::allowPawnHit(Pawn* victim, Pawn* originator)
+    void TeamDeathmatch::pawnKilled(Pawn* victim, Pawn* killer)
     {
-        return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
+        if (victim && victim->getPlayer())
+        {
+            std::string message;
+            if (killer)
+            {
+                if (killer->getPlayer())
+                    message = victim->getPlayer()->getName() + " was killed by " + killer->getPlayer()->getName();
+                else
+                    message = victim->getPlayer()->getName() + " was killed";
+            }
+            else
+                message = victim->getPlayer()->getName() + " died";
+
+            ChatManager::message(message);
+        }
+
+        Gametype::pawnKilled(victim, killer);
     }
 
-    bool TeamDeathmatch::allowPawnDamage(Pawn* victim, Pawn* originator)
+    void TeamDeathmatch::playerScored(PlayerInfo* player)
     {
-        return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
-    }
+        TeamGametype::playerScored(player);
 
-    bool TeamDeathmatch::allowPawnDeath(Pawn* victim, Pawn* originator)
-    {
-        return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
-    }
-
-    SpawnPoint* TeamDeathmatch::getBestSpawnPoint(PlayerInfo* player) const
-    {
-        int desiredTeamNr = -1;
-        std::map<PlayerInfo*, int>::const_iterator it_player = this->teamnumbers_.find(player);
-        if (it_player != this->teamnumbers_.end())
-            desiredTeamNr = it_player->second;
-
-        // Only use spawnpoints of the own team (or non-team-spawnpoints)
-        std::set<SpawnPoint*> teamSpawnPoints = this->spawnpoints_;
-        for (std::set<SpawnPoint*>::iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); )
+        if (player)
         {
-            if ((*it)->isA(Class(TeamSpawnPoint)))
-            {
-                TeamSpawnPoint* tsp = orxonox_cast<TeamSpawnPoint*>(*it);
-                if (tsp && static_cast<int>(tsp->getTeamNumber()) != desiredTeamNr)
-                {
-                    teamSpawnPoints.erase(it++);
-                    continue;
-                }
-            }
-
-            ++it;
-        }
-
-        SpawnPoint* fallbackSpawnPoint = NULL;
-        if (teamSpawnPoints.size() > 0)
-        {
-            unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
-            unsigned int index = 0;
-            // Get random fallback spawnpoint in case there is no active SpawnPoint.
-            for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); ++it)
-            {
-                if (index == randomspawn)
-                {
-                    fallbackSpawnPoint = (*it);
-                    break;
-                }
-
-                ++index;
-            }
-
-            // Remove all inactive SpawnPoints from the list.
-            for (std::set<SpawnPoint*>::iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); )
-            {
-                if(!(*it)->isActive())
-                {
-                    teamSpawnPoints.erase(it++);
-                    continue;
-                }
-
-                ++it;
-            }
-
-            randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
-            index = 0;
-            for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); ++it)
-            {
-                if (index == randomspawn)
-                    return (*it);
-
-                ++index;
-            }
-
-            return fallbackSpawnPoint;
-        }
-
-        return 0;
-    }
-
-    void TeamDeathmatch::playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn)
-    {
-        if (!player)
-            return;
-
-        // Set the team colour
-        std::map<PlayerInfo*, int>::const_iterator it_player = this->teamnumbers_.find(player);
-        if (it_player != this->teamnumbers_.end() && it_player->second >= 0 && it_player->second < static_cast<int>(this->teamcolours_.size()))
-        {
-            if (pawn)
-            {
-                pawn->setRadarObjectColour(this->teamcolours_[it_player->second]);
-
-                std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
-                for (std::set<WorldEntity*>::iterator it = pawnAttachments.begin(); it != pawnAttachments.end(); ++it)
-                {
-                    if ((*it)->isA(Class(TeamColourable)))
-                    {
-                        TeamColourable* tc = orxonox_cast<TeamColourable*>(*it);
-                        tc->setTeamColour(this->teamcolours_[it_player->second]);
-                    }
-                }
-            }
+            const std::string& message = player->getName() + " scores!";
+            ChatManager::message(message);
         }
     }
 
-    bool TeamDeathmatch::pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2)
-    {
-        if (pawn1 && pawn2)
-        {
-            std::map<PlayerInfo*, int>::const_iterator it1 = this->teamnumbers_.find(pawn1->getPlayer());
-            std::map<PlayerInfo*, int>::const_iterator it2 = this->teamnumbers_.find(pawn2->getPlayer());
-
-            if (it1 != this->teamnumbers_.end() && it2 != this->teamnumbers_.end())
-                return (it1->second == it2->second);
-        }
-        return false;
-    }
-
-    int TeamDeathmatch::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;
-    }
 }

code/branches/pCuts/src/orxonox/gametypes/TeamDeathmatch.h

@@ -31 +31 @@
 
 #include "OrxonoxPrereqs.h"
-
-#include <map>
-#include <vector>
-#include "Deathmatch.h"
+#include "TeamGametype.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport TeamDeathmatch : public Deathmatch
+    class _OrxonoxExport TeamDeathmatch : public TeamGametype
     {
         public:
@@ -44 +41 @@
             virtual ~TeamDeathmatch() {}
 
-            void setConfigValues();
-
+            virtual void start();
+            virtual void end();
             virtual void playerEntered(PlayerInfo* player);
             virtual bool playerLeft(PlayerInfo* player);
+            virtual bool playerChangedName(PlayerInfo* player);
 
-            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
-            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
-            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
-
-            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);
-
-            int getTeam(PlayerInfo* player);
-            inline const ColourValue& getTeamColour(int teamnr) const
-                { return this->teamcolours_[teamnr]; }
-
-        protected:
-            virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
-            bool pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2);
-
-            std::map<PlayerInfo*, int> teamnumbers_;
-            std::vector<ColourValue> teamcolours_;
-            unsigned int teams_;
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
+            virtual void playerScored(PlayerInfo* player);
     };
 }