Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/pch/src/orxonox/objects/gametypes/Gametype.h @ 3177

Last change on this file since 3177 was 3177, checked in by rgrieder, 15 years ago

Moved interface classes to orxonox/interfaces.
This resolves certain identity problems, for instance Tickable technically isn't an object.
Furthermore this saves the compilation of 6 files by using InterfaceCompilation.cc ;)

  • Property svn:eol-style set to native
File size: 5.9 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _Gametype_H__
30#define _Gametype_H__
31
32#include "OrxonoxPrereqs.h"
33
34#include <map>
35
36#include "core/BaseObject.h"
37#include "core/Identifier.h"
38#include "objects/worldentities/ControllableEntity.h"
39#include "interfaces/Tickable.h"
40#include "objects/infos/GametypeInfo.h"
41
42namespace orxonox
43{
44    namespace PlayerState
45    {
46        enum Enum
47        {
48            Uninitialized,
49            Joined,
50            Alive,
51            Dead
52        };
53    }
54
55    struct Player
56    {
57        PlayerInfo* info_;
58        PlayerState::Enum state_;
59        int frags_;
60        int killed_;
61    };
62
63    class _OrxonoxExport Gametype : public BaseObject, public Tickable
64    {
65        friend class PlayerInfo;
66
67        public:
68            Gametype(BaseObject* creator);
69            virtual ~Gametype() {}
70
71            void setConfigValues();
72
73            virtual void tick(float dt);
74
75            inline const GametypeInfo* getGametypeInfo() const
76                { return &this->gtinfo_; }
77
78            inline bool hasStarted() const
79                { return this->gtinfo_.bStarted_; }
80            inline bool hasEnded() const
81                { return this->gtinfo_.bEnded_; }
82
83            virtual void start();
84            virtual void end();
85            virtual void playerEntered(PlayerInfo* player);
86            virtual bool playerLeft(PlayerInfo* player);
87            virtual void playerSwitched(PlayerInfo* player, Gametype* newgametype);
88            virtual void playerSwitchedBack(PlayerInfo* player, Gametype* oldgametype);
89            virtual bool playerChangedName(PlayerInfo* player);
90
91            virtual void playerScored(PlayerInfo* player);
92
93            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
94            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
95            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
96
97            virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
98            virtual void pawnPreSpawn(Pawn* pawn);
99            virtual void pawnPostSpawn(Pawn* pawn);
100            virtual void playerPreSpawn(PlayerInfo* player);
101            virtual void playerPostSpawn(PlayerInfo* player);
102
103            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);
104            virtual void playerStopsControllingPawn(PlayerInfo* player, Pawn* pawn);
105
106            inline const std::map<PlayerInfo*, Player>& getPlayers() const
107                { return this->players_; }
108
109            int getScore(PlayerInfo* player) const;
110
111            inline void registerSpawnPoint(SpawnPoint* spawnpoint)
112                { this->spawnpoints_.insert(spawnpoint); }
113
114            inline bool isStartCountdownRunning() const
115                { return this->gtinfo_.bStartCountdownRunning_; }
116            inline float getStartCountdown() const
117                { return this->gtinfo_.startCountdown_; }
118
119            inline void setHUDTemplate(const std::string& name)
120                { this->gtinfo_.hudtemplate_ = name; }
121            inline const std::string& getHUDTemplate() const
122                { return this->gtinfo_.hudtemplate_; }
123
124            void addBots(unsigned int amount);
125            void killBots(unsigned int amount = 0);
126
127            inline unsigned int getNumberOfPlayers() const
128                { return this->players_.size(); }
129
130            virtual void addTime(float t);
131            virtual void removeTime(float t);
132
133            inline  void startTimer()
134            { 
135                this->time_ = this->timeLimit_;
136                this->timerIsActive_ = true;
137            }
138
139            inline void stopTimer()
140              { this->timerIsActive_ = false; }
141
142            inline float getTime()
143              { return this->time_; }
144
145            inline bool getTimerIsActive()
146              { return timerIsActive_; }
147
148            inline void setTimeLimit(float t)
149              { this->timeLimit_ = t; }
150
151            virtual void resetTimer();
152            virtual void resetTimer(float t);
153
154        protected:
155            virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
156
157            virtual void assignDefaultPawnsIfNeeded();
158            virtual void checkStart();
159            virtual void spawnPlayer(PlayerInfo* player);
160            virtual void spawnPlayerAsDefaultPawn(PlayerInfo* player);
161            virtual void spawnPlayersIfRequested();
162            virtual void spawnDeadPlayersIfRequested();
163
164            GametypeInfo gtinfo_;
165
166            bool bAutoStart_;
167            bool bForceSpawn_;
168
169            float time_;
170            float timeLimit_;
171            bool timerIsActive_;
172
173            float initialStartCountdown_;
174            unsigned int numberOfBots_;
175            SubclassIdentifier<Bot> botclass_;
176
177            std::map<PlayerInfo*, Player> players_;
178            std::set<SpawnPoint*> spawnpoints_;
179            SubclassIdentifier<ControllableEntity> defaultControllableEntity_;
180
181            OverlayGroup* scoreboard_;
182
183            // Config Values
184            std::string scoreboardTemplate_;
185    };
186}
187
188#endif /* _Gametype_H__ */
Note: See TracBrowser for help on using the repository browser.