SuperTuxKart
world.hpp
1 //
2 // SuperTuxKart - a fun racing game with go-kart
3 // Copyright (C) 2004-2015 SuperTuxKart-Team
4 //
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 3
8 // of the License, or (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 
19 #ifndef HEADER_WORLD_HPP
20 #define HEADER_WORLD_HPP
21 
28 #include <cstring>
29 #include <limits>
30 #include <map>
31 #include <memory>
32 #include <vector>
33 #include <stdexcept>
34 
35 #include "graphics/weather.hpp"
36 #include "modes/world_status.hpp"
37 #include "race/highscores.hpp"
38 #include "states_screens/race_gui_base.hpp"
39 #include "states_screens/state_manager.hpp"
40 #include "utils/random_generator.hpp"
41 #include "utils/stk_process.hpp"
42 
43 #include "LinearMath/btTransform.h"
44 
45 class AbstractKart;
46 class BareNetworkString;
47 class btRigidBody;
48 class Controller;
49 class ItemState;
50 class PhysicalObject;
51 class STKPeer;
52 
53 namespace Scripting
54 {
55  class ScriptEngine;
56 }
57 
58 namespace irr
59 {
60  namespace scene { class ISceneNode; }
61 }
62 
63 class AbortWorldUpdateException : public std::runtime_error
64 {
65 public:
66  AbortWorldUpdateException() : std::runtime_error("race abort") { };
67 };
68 
87 class World : public WorldStatus
88 {
89 public:
90  typedef std::vector<std::shared_ptr<AbstractKart> > KartList;
91 private:
93  static World *m_world[PT_COUNT];
94  // ------------------------------------------------------------------------
95  void setAITeam();
96  // ------------------------------------------------------------------------
97  std::shared_ptr<AbstractKart> createKartWithTeam
98  (const std::string &kart_ident, int index, int local_player_id,
99  int global_player_id, RaceManager::KartType type,
100  HandicapLevel handicap);
101 
102 protected:
103 
104 #ifdef DEBUG
105  unsigned int m_magic_number;
106 #endif
107 
108  /* Team related variables. */
109  int m_red_ai;
110  int m_blue_ai;
111  std::map<int, KartTeam> m_kart_team_map;
112  std::map<int, unsigned int> m_kart_position_map;
113 
115  KartList m_karts;
116  RandomGenerator m_random;
117 
118  AbstractKart* m_fastest_kart;
125 
126  bool m_faster_music_active; // true if faster music was activated
127 
128  bool m_stop_music_when_dialog_open;
129 
130  bool m_unfair_team;
131 
136 
137  void updateHighscores (int* best_highscore_rank);
138  void resetAllKarts ();
139  Controller*
140  loadAIController (AbstractKart *kart);
141 
142  virtual std::shared_ptr<AbstractKart> createKart
143  (const std::string &kart_ident, int index, int local_player_id,
144  int global_player_id, RaceManager::KartType type,
145  HandicapLevel handicap);
146 
149 
156 
163 
170 
171  bool m_schedule_exit_race;
172 
173  bool m_schedule_tutorial;
174 
175  Phase m_scheduled_pause_phase;
176 
181 
184 
185  bool m_ended_early;
186 
187  virtual void onGo() OVERRIDE;
189  virtual bool isRaceOver() = 0;
190  virtual void update(int ticks) OVERRIDE;
191  virtual void createRaceGUI();
192  void updateTrack(int ticks);
193  // ------------------------------------------------------------------------
201  virtual float estimateFinishTimeForKart(AbstractKart* kart)
202  {return getTime(); }
203  void updateAchievementDataEndRace();
204  void updateAchievementModeCounters(bool start);
205 
206 public:
207  World();
208  virtual ~World();
209  // Static functions to access world:
210  // =================================
211  // ------------------------------------------------------------------------
213  static World* getWorld()
214  {
215  ProcessType type = STKProcess::getType();
216  return m_world[type];
217  }
218  // ------------------------------------------------------------------------
222  static void deleteWorld()
223  {
224  ProcessType type = STKProcess::getType();
225  delete m_world[type];
226  m_world[type] = NULL;
227  }
228  // ------------------------------------------------------------------------
231  static void setWorld(World *world)
232  {
233  ProcessType type = STKProcess::getType();
234  m_world[type] = world;
235  }
236  // ------------------------------------------------------------------------
237  static void clear() { memset(m_world, 0, sizeof(m_world)); }
238  // ------------------------------------------------------------------------
239 
240  // Pure virtual functions
241  // ======================
242 
245  virtual const std::string& getIdent() const = 0;
246  // ------------------------------------------------------------------------
249  virtual unsigned int getNumberOfRescuePositions() const;
250  // ------------------------------------------------------------------------
252  virtual unsigned int getRescuePositionIndex(AbstractKart *kart) = 0;
253  // ------------------------------------------------------------------------
255  virtual btTransform getRescueTransform(unsigned int index) const;
256  // ------------------------------------------------------------------------
257  virtual void moveKartAfterRescue(AbstractKart* kart);
258  // ------------------------------------------------------------------------
261  virtual bool raceHasLaps() = 0;
262  // ------------------------------------------------------------------------
264  virtual bool showLapsTarget() { return false; }
265  // ------------------------------------------------------------------------
268  virtual int getFinishedLapsOfKart(unsigned int kart_index) const
269  {
270  assert(false); return -1; // remove compiler warning
271  } // getFinishedLapsOfKart
272  // ------------------------------------------------------------------------
275  virtual void getKartsDisplayInfo(
276  std::vector<RaceGUIBase::KartIconDisplayInfo> *info)= 0;
277  // ------------------------------------------------------------------------
278 
279  // Virtual functions
280  // =================
281  virtual void init();
282  virtual void updateGraphics(float dt);
283  virtual void terminateRace() OVERRIDE;
284  virtual void reset(bool restart=false) OVERRIDE;
285  virtual void pause(Phase phase) OVERRIDE;
286  virtual void unpause() OVERRIDE;
287  virtual void getDefaultCollectibles(int *collectible_type,
288  int *amount );
289  // ------------------------------------------------------------------------
291  virtual void collectedItem(const AbstractKart *kart,
292  const ItemState *item ) {}
293  // ------------------------------------------------------------------------
294  virtual void endRaceEarly() { return; }
295  // ------------------------------------------------------------------------
296  virtual bool hasRaceEndedEarly() const { return m_ended_early; }
297  // ------------------------------------------------------------------------
299  virtual bool haveBonusBoxes() { return true; }
300  // ------------------------------------------------------------------------
302  virtual bool useFastMusicNearEnd() const { return true; }
303  // ------------------------------------------------------------------------
306  virtual void kartAdded(AbstractKart* kart, scene::ISceneNode* node) {}
307  // ------------------------------------------------------------------------
311  virtual void newLap(unsigned int kart_index) {}
312  // ------------------------------------------------------------------------
314  virtual bool kartHit(int kart_id, int hitter = -1) { return false; }
315  // ------------------------------------------------------------------------
316  virtual void onMouseClick(int x, int y) {};
317 
318  // Other functions
319  // ===============
320  Highscores *getHighscores() const;
321  Highscores *getGPHighscores() const;
322  void schedulePause(Phase phase);
323  void scheduleUnpause();
324  void scheduleExitRace() { m_schedule_exit_race = true; }
325  void scheduleTutorial();
326  void updateWorld(int ticks);
327  void handleExplosion(const Vec3 &xyz, AbstractKart *kart_hit,
328  PhysicalObject *object);
329  AbstractKart* getPlayerKart(unsigned int player) const;
330  AbstractKart* getLocalPlayerKart(unsigned int n) const;
331  virtual const btTransform &getStartTransform(int index);
332  void moveKartTo(AbstractKart* kart, const btTransform &t);
333  void updateTimeTargetSound();
334  // ------------------------------------------------------------------------
336  RaceGUIBase *getRaceGUI() const { return m_race_gui;}
337  // ------------------------------------------------------------------------
339  unsigned int getNumKarts() const { return (unsigned int) m_karts.size(); }
340  // ------------------------------------------------------------------------
342  AbstractKart *getKart(int kartId) const {
343  assert(kartId >= 0 && kartId < int(m_karts.size()));
344  return m_karts[kartId].get(); }
345  // ------------------------------------------------------------------------
347  const KartList & getKarts() const { return m_karts; }
348  // ------------------------------------------------------------------------
350  unsigned int getCurrentNumKarts() const { return (int)m_karts.size() -
351  m_eliminated_karts; }
352  // ------------------------------------------------------------------------
354  unsigned int getCurrentNumPlayers() const { return m_num_players -
355  m_eliminated_players;}
356  // ------------------------------------------------------------------------
357  void resetElimination()
358  {
359  m_eliminated_karts = 0;
360  m_eliminated_players = 0;
361  }
362  // ------------------------------------------------------------------------
363  virtual void addReservedKart(int kart_id)
364  {
365  if (m_eliminated_karts > 0)
366  m_eliminated_karts--;
367  }
368  // ------------------------------------------------------------------------
369  virtual void saveCompleteState(BareNetworkString* bns, STKPeer* peer) {}
370  // ------------------------------------------------------------------------
371  virtual void restoreCompleteState(const BareNetworkString& buffer) {}
372  // ------------------------------------------------------------------------
375  virtual bool shouldDrawTimer() const
376  { return isActiveRacePhase() && getClockMode() != CLOCK_NONE; }
377  // ------------------------------------------------------------------------
379  bool useHighScores() const { return m_use_highscores; }
380  // ------------------------------------------------------------------------
382  virtual void onFirePressed(Controller* who) {}
383  // ------------------------------------------------------------------------
386  virtual bool useChecklineRequirements() const { return false; }
387  // ------------------------------------------------------------------------
388  virtual void escapePressed();
389  // ------------------------------------------------------------------------
390  virtual void loadCustomModels() {}
391  // ------------------------------------------------------------------------
392  void eliminateKart(int kart_number, bool notify_of_elimination = true);
393  // ------------------------------------------------------------------------
394  void setUnfairTeam(bool val) { m_unfair_team = val; }
395  // ------------------------------------------------------------------------
396  virtual bool hasTeam() const { return false; }
397  // ------------------------------------------------------------------------
399  KartTeam getKartTeam(unsigned int kart_id) const;
400  // ------------------------------------------------------------------------
401  int getTeamNum(KartTeam team) const;
402  // ------------------------------------------------------------------------
404  void setNetworkWorld(bool is_networked) { m_is_network_world = is_networked; }
405  // ------------------------------------------------------------------------
406  bool isNetworkWorld() const { return m_is_network_world; }
407  // ------------------------------------------------------------------------
409  void initTeamArrows(AbstractKart* k);
410  // ------------------------------------------------------------------------
414  virtual std::pair<uint32_t, uint32_t> getGameStartedProgress() const
415  {
416  return std::make_pair(std::numeric_limits<uint32_t>::max(),
417  std::numeric_limits<uint32_t>::max());
418  }
419  // ------------------------------------------------------------------------
420  virtual bool isGoalPhase() const { return false; }
421 }; // World
422 
423 #endif
424 
425 /* EOF */
A random number generator.
Definition: random_generator.hpp:33
HandicapLevel
Handicap per player.
Definition: remote_kart_info.hpp:39
This is the base class for kart controller - that can be a player or a a robot.
Definition: controller.hpp:45
virtual int getFinishedLapsOfKart(unsigned int kart_index) const
Returns the number of laps for a given kart.
Definition: world.hpp:268
static World * getWorld()
Returns a pointer to the (singleton) world object.
Definition: world.hpp:213
An abstract base class for the two race guis (race_gui and race_result gui)
Definition: race_gui_base.hpp:49
A wrapper around bullets btVector3 to include conventient conversion functions (e.g.
Definition: vec3.hpp:34
bool m_use_highscores
Whether highscores should be used for this kind of race.
Definition: world.hpp:135
virtual void onFirePressed(Controller *who)
Override if you want to know when a kart presses fire.
Definition: world.hpp:382
base class for all game modes This class is responsible for running the actual race.
Definition: world.hpp:87
RaceGUIBase * getRaceGUI() const
Returns a pointer to the race gui.
Definition: world.hpp:336
RaceGUIBase * m_race_gui
Pointer to the race GUI.
Definition: world.hpp:148
virtual void collectedItem(const AbstractKart *kart, const ItemState *item)
Receives notification if an item is collected.
Definition: world.hpp:291
KartType
Different kart types: A local player, a player connected via network, an AI kart, the leader kart (cu...
Definition: race_manager.hpp:241
unsigned int getCurrentNumPlayers() const
Returns the number of currently active (i.e.
Definition: world.hpp:354
KartList m_karts
The list of all karts.
Definition: world.hpp:115
Definition: three_d_animation.hpp:32
virtual bool useChecklineRequirements() const
Whether to compute checkline requirements for each world on the quadgraph.
Definition: world.hpp:386
virtual bool shouldDrawTimer() const
The code that draws the timer should call this first to know whether the game mode wants a timer draw...
Definition: world.hpp:375
bool m_self_destruct
Set when the world needs to be deleted but you can&#39;t do it immediately because you are e...
Definition: world.hpp:180
static void deleteWorld()
Delete the )singleton) world object, if it exists, and sets the singleton pointer to NULL...
Definition: world.hpp:222
Definition: physical_object.hpp:38
virtual bool kartHit(int kart_id, int hitter=-1)
Called when a kart was hit by a projectile.
Definition: world.hpp:314
bool m_schedule_pause
Pausing/unpausing are not done immediately, but at next udpdate.
Definition: world.hpp:162
unsigned int getNumKarts() const
Returns the number of karts in the race.
Definition: world.hpp:339
bool m_schedule_unpause
Pausing/unpausing are not done immediately, but at next udpdate.
Definition: world.hpp:169
int m_eliminated_players
Number of eliminated players.
Definition: world.hpp:122
int m_eliminated_karts
Number of eliminated karts.
Definition: world.hpp:120
virtual void kartAdded(AbstractKart *kart, scene::ISceneNode *node)
If you want to do something to karts or their graphics at the start of the race, override this...
Definition: world.hpp:306
int m_num_players
OVerall number of players.
Definition: world.hpp:124
A class that manages the clock (countdown, chrono, etc.) Also manages stuff like the &#39;ready/set/go&#39; t...
Definition: world_status.hpp:32
Represents one highscore entry, i.e.
Definition: highscores.hpp:40
virtual void newLap(unsigned int kart_index)
Called whenever a kart starts a new lap.
Definition: world.hpp:311
Describes a chain of 8-bit unsigned integers.
Definition: network_string.hpp:52
bool useHighScores() const
Definition: world.hpp:379
void setNetworkWorld(bool is_networked)
Set the network mode (true if networked)
Definition: world.hpp:404
virtual bool useFastMusicNearEnd() const
Returns if this mode should use fast music (if available).
Definition: world.hpp:302
unsigned int getCurrentNumKarts() const
Returns the number of currently active (i.e.non-elikminated) karts.
Definition: world.hpp:350
Represents a peer. This class is used to interface the ENetPeer structure.
Definition: stk_peer.hpp:75
bool m_is_network_world
Set when the world is online and counts network players.
Definition: world.hpp:183
AbstractKart * getKart(int kartId) const
Returns the kart with a given world id.
Definition: world.hpp:342
Contains the state information of an item, i.e.
Definition: item.hpp:52
RaceGUIBase * m_saved_race_gui
The actual race gui needs to be saved when the race result gui is displayed since it is still needed ...
Definition: world.hpp:155
An abstract interface for the actual karts.
Definition: abstract_kart.hpp:61
static void setWorld(World *world)
Sets the pointer to the world object.
Definition: world.hpp:231
virtual std::pair< uint32_t, uint32_t > getGameStartedProgress() const
Used by server to get the current started game progress in either or both remaining time or progress ...
Definition: world.hpp:414
Definition: world.hpp:53
const KartList & getKarts() const
Returns all karts.
Definition: world.hpp:347
Definition: world.hpp:63
virtual bool showLapsTarget()
If true lap counter shows lap count in format: 4/20 or if false then in format: 4.
Definition: world.hpp:264
virtual bool haveBonusBoxes()
Called to determine whether this race mode uses bonus boxes.
Definition: world.hpp:299