Orxonox  0.0.5 Codename: Arcturus
Gametype.h
Go to the documentation of this file.
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 #include <set>
36 #include <string>
37 
38 #include "core/BaseObject.h"
41 #include "infos/GametypeInfo.h"
42 #include "tools/Timer.h"
44 
45 namespace orxonox
46 {
47  enum class PlayerState
48  {
50  Joined,
51  Alive,
52  Dead
53  };
54 
55  struct Player
56  {
59  int frags_;
60  int killed_;
61  };
62 
63  class _OrxonoxExport Gametype : public BaseObject, public Tickable, public GSLevelMemento
64  {
65  friend class PlayerInfo;
66 
67  public:
68  Gametype(Context* context);
69  virtual ~Gametype();
70 
71  virtual void init();
72 
73  void setConfigValues();
74 
75  virtual void tick(float dt) override;
76 
77  inline const GametypeInfo* getGametypeInfo() const
78  { return this->gtinfo_; }
79 
80  inline bool hasStarted() const
81  { return this->gtinfo_->hasStarted(); }
82  inline bool hasEnded() const
83  { return this->gtinfo_->hasEnded(); }
84 
85  virtual void start();
86  virtual void end();
87  virtual void playerEntered(PlayerInfo* player);
88  virtual bool playerLeft(PlayerInfo* player);
89  virtual void playerSwitched(PlayerInfo* player, Gametype* newgametype);
90  virtual void playerSwitchedBack(PlayerInfo* player, Gametype* oldgametype);
91  virtual bool playerChangedName(PlayerInfo* player);
92 
93  virtual void playerScored(PlayerInfo* player, int score = 1);
94 
95  virtual bool allowPawnHit(Pawn* victim, Pawn* originator = nullptr);
96  virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr);
97  virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr);
98 
99  virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr);
100  virtual void pawnPreSpawn(Pawn* pawn);
101  virtual void pawnPostSpawn(Pawn* pawn);
102  virtual void playerPreSpawn(PlayerInfo* player);
103  virtual void playerPostSpawn(PlayerInfo* player);
104 
105  virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);
106  virtual void playerStopsControllingPawn(PlayerInfo* player, Pawn* pawn);
107 
108  inline const std::map<PlayerInfo*, Player>& getPlayers() const
109  { return this->players_; }
110 
111  int getScore(PlayerInfo* player) const;
112 
113  inline void registerSpawnPoint(SpawnPoint* spawnpoint)
114  { this->spawnpoints_.insert(spawnpoint); }
115 
116  inline bool isStartCountdownRunning() const
117  { return this->gtinfo_->isStartCountdownRunning(); }
118  inline float getStartCountdown() const
119  { return this->gtinfo_->getStartCountdown(); }
120 
121  inline void setHUDTemplate(const std::string& name)
122  { this->gtinfo_->setHUDTemplate(name); }
123  inline const std::string& getHUDTemplate() const
124  { return this->gtinfo_->getHUDTemplate(); }
125 
126  virtual void addBots(unsigned int amount);
127  void killBots(unsigned int amount = 0);
128 
129  virtual void addTime(float t);
130  virtual void removeTime(float t);
131 
132  inline void startTimer()
133  {
134  this->time_ = this->timeLimit_;
135  this->timerIsActive_ = true;
136  }
137 
138  inline void stopTimer()
139  { this->timerIsActive_ = false; }
140 
141  inline float getTime()
142  { return this->time_; }
143 
144  inline bool getTimerIsActive()
145  { return timerIsActive_; }
146 
147  inline void setTimeLimit(float t)
148  { this->timeLimit_ = t; }
149 
150  //inline bool getForceSpawn()
151  // { return this->bForceSpawn_; }
152 
153  virtual void resetTimer();
154  virtual void resetTimer(float t);
155 
159  inline unsigned int getNumberOfPlayers() const
160  { return this->players_.size(); }
161  void showMenu();
162 
163 
164  protected:
165  virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
166 
167  virtual void assignDefaultPawnsIfNeeded();
168  virtual void checkStart();
169  virtual void spawnPlayer(PlayerInfo* player);
170  virtual void spawnPlayerAsDefaultPawn(PlayerInfo* player);
171  virtual void spawnPlayersIfRequested();
172  virtual void spawnDeadPlayersIfRequested();
173 
174  virtual GSLevelMementoState* exportMementoState() override;
175  virtual void importMementoState(const std::vector<GSLevelMementoState*>& states) override;
176 
178 
181  bool bAutoEnd_;
182 
183  float time_;
184  float timeLimit_;
186 
188  unsigned int numberOfBots_;
190 
191  std::map<PlayerInfo*, Player> players_;
192  std::set<SpawnPoint*> spawnpoints_;
194 
196 
197  // Config Values
199 
201  };
202 
207  {
209  Quaternion cameraOrientation_;
211  };
212 }
213 
214 #endif /* _Gametype_H__ */
bool bForceSpawn_
Definition: Gametype.h:180
The BaseObject is the parent of all classes representing an instance in the game. ...
Definition: BaseObject.h:63
bool isStartCountdownRunning() const
Definition: Gametype.h:116
Everything in Orxonox that has a health attribute is a Pawn.
Definition: Pawn.h:56
Definition of SubclassIdentifier.
Definition: SpawnPoint.h:40
void startTimer()
Definition: Gametype.h:132
Declaration of the Tickable interface.
::std::string string
Definition: gtest-port.h:756
void stopTimer()
Definition: Gametype.h:138
bool bAutoEnd_
Definition: Gametype.h:181
PlayerState
Definition: Gametype.h:47
std::map< PlayerInfo *, Player > players_
Definition: Gametype.h:191
bool hasEnded() const
Definition: Gametype.h:82
float getTime()
Definition: Gametype.h:141
SubclassIdentifier< Bot > botclass_
Definition: Gametype.h:189
int frags_
Definition: Gametype.h:59
std::string sceneName_
Definition: Gametype.h:210
SubclassIdentifier< ControllableEntity > defaultControllableEntity_
Definition: Gametype.h:193
Quaternion cameraOrientation_
Definition: Gametype.h:209
WeakPtr wraps a pointer to an object, which becomes nullptr if the object is deleted.
Definition: CorePrereqs.h:236
bool timerIsActive_
Definition: Gametype.h:185
unsigned int getNumberOfPlayers() const
Get number of Players in game.
Definition: Gametype.h:159
bool hasStarted() const
Definition: Gametype.h:80
std::string scoreboardTemplate_
Definition: Gametype.h:198
Definition of the GametypeInfo class.
const std::string & getHUDTemplate() const
Definition: Gametype.h:123
Declaration of the Timer class, used to call functions after a given time-interval.
Die Wagnis Klasse hat die folgenden Aufgaben:
Definition: ApplicationPaths.cc:66
float timeLimit_
Definition: Gametype.h:184
Keeps position and orientation of the camera, as well as the name of current scene.
Definition: Gametype.h:206
bool getTimerIsActive()
Definition: Gametype.h:144
unsigned int numberOfBots_
Definition: Gametype.h:188
Definition: Gametype.h:63
Shared library macros, enums, constants and forward declarations for the orxonox library ...
Declaration of BaseObject, the base class of all objects in Orxonox.
This class is an interface for all instances that want to maintain a state beyond the reloading of a ...
Definition: GSLevelMemento.h:41
Definition: Context.h:45
OverlayGroup * scoreboard_
Definition: Gametype.h:195
#define _OrxonoxExport
Definition: OrxonoxPrereqs.h:60
const std::map< PlayerInfo *, Player > & getPlayers() const
Definition: Gametype.h:108
OverlayGroup does almost exactly what it says: It groups OrxonoxOverlays together.
Definition: OverlayGroup.h:53
void registerSpawnPoint(SpawnPoint *spawnpoint)
Definition: Gametype.h:113
float time_
Definition: Gametype.h:183
Vector3 cameraPosition_
Definition: Gametype.h:208
float getStartCountdown() const
Definition: Gametype.h:118
const GametypeInfo * getGametypeInfo() const
Definition: Gametype.h:77
Definition: Gametype.h:55
float initialStartCountdown_
Definition: Gametype.h:187
void setHUDTemplate(const std::string &name)
Definition: Gametype.h:121
The GametypeInfo class keeps track of the state of the game and provides facilities to inform the pla...
Definition: GametypeInfo.h:55
int killed_
Definition: Gametype.h:60
Definition: PlayerInfo.h:39
bool bAutoStart_
Definition: Gametype.h:179
PlayerState state_
Definition: Gametype.h:58
The Tickable interface provides a tick(dt) function, that gets called every frame.
Definition: Tickable.h:52
Timer showMenuTimer_
Definition: Gametype.h:200
Timer is a helper class that executes a function after a given amount of seconds in game-time...
Definition: Timer.h:105
Represents the state of a memento.
Definition: GSLevelMemento.h:63
The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
Definition: SubclassIdentifier.h:90
WeakPtr< GametypeInfo > gtinfo_
Definition: Gametype.h:177
std::set< SpawnPoint * > spawnpoints_
Definition: Gametype.h:192
void setTimeLimit(float t)
Definition: Gametype.h:147
PlayerInfo * info_
Definition: Gametype.h:57