1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
|
/* Copyright (C) 2017 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* 0 A.D. is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef INCLUDED_GAME
#define INCLUDED_GAME
#include <vector>
#include "ps/Errors.h"
#include "ps/Filesystem.h"
#include "scriptinterface/ScriptVal.h"
#include "simulation2/helpers/Player.h"
class CWorld;
class CSimulation2;
class CGameView;
class CTurnManager;
class IReplayLogger;
struct CColor;
/**
* The container that holds the rules, resources and attributes of the game.
* The CGame object is responsible for creating a game that is defined by
* a set of attributes provided. The CGame object is also responsible for
* maintaining the relations between CPlayer and CWorld, CSimulation and CWorld.
**/
class CGame
{
NONCOPYABLE(CGame);
/**
* pointer to the CWorld object representing the game world.
**/
CWorld *m_World;
/**
* pointer to the CSimulation2 object operating on the game world.
**/
CSimulation2 *m_Simulation2;
/**
* pointer to the CGameView object representing the view into the game world.
**/
CGameView *m_GameView;
/**
* the game has been initialized and ready for use if true.
**/
bool m_GameStarted;
/**
* Timescale multiplier for simulation rate.
**/
float m_SimRate;
/**
* Index assigned to the current player.
* 1-8 to control players, 0 for gaia, -1 for observer.
*/
player_id_t m_PlayerID;
/**
* Differs from m_PlayerID if a defeated player or observer views another player.
*/
player_id_t m_ViewedPlayerID;
CTurnManager* m_TurnManager;
public:
CGame(bool disableGraphics = false, bool replayLog = true);
~CGame();
/**
* the game is paused and no updates will be performed if true.
**/
bool m_Paused;
void StartGame(JS::MutableHandleValue attribs, const std::string& savedState);
PSRETURN ReallyStartGame();
bool StartVisualReplay(const OsPath& replayPath);
/**
* Periodic heartbeat that controls the process. performs all per-frame updates.
* Simulation update is called and game status update is called.
*
* @param deltaRealTime Elapsed real time since last beat/frame, in seconds.
* @param doInterpolate Perform graphics interpolation if true.
* @return bool false if it can't keep up with the desired simulation rate
* indicating that you might want to render less frequently.
*/
void Update(const double deltaRealTime, bool doInterpolate = true);
void Interpolate(float simFrameLength, float realFrameLength);
int GetPlayerID();
void SetPlayerID(player_id_t playerID);
int GetViewedPlayerID();
void SetViewedPlayerID(player_id_t playerID);
/**
* Check if the game is finished by testing if there's a winner.
* It is used to end a non visual autostarted game.
*
* @return true if there's a winner, false otherwise.
*/
bool IsGameFinished() const;
/**
* Retrieving player colors from scripts is slow, so this updates an
* internal cache of all players' colors.
* Call this just before rendering, so it will always have the latest
* colors.
*/
void CachePlayerColors();
CColor GetPlayerColor(player_id_t player) const;
/**
* Get m_GameStarted.
*
* @return bool the value of m_GameStarted.
**/
inline bool IsGameStarted() const
{
return m_GameStarted;
}
/**
* Get if the graphics is disabled.
*
* @return bool true if the m_GameView is NULL, false otherwise.
*/
inline bool IsGraphicsDisabled() const
{
return !m_GameView;
}
/**
* Get m_IsVisualReplay.
*
* @return bool the value of m_IsVisualReplay.
**/
inline bool IsVisualReplay() const
{ return m_IsVisualReplay; }
/**
* Get the pointer to the game world object.
*
* @return CWorld * the value of m_World.
**/
inline CWorld *GetWorld()
{ return m_World; }
/**
* Get the pointer to the game view object.
*
* @return CGameView * the value of m_GameView.
**/
inline CGameView *GetView()
{ return m_GameView; }
/**
* Get the pointer to the simulation2 object.
*
* @return CSimulation2 * the value of m_Simulation2.
**/
inline CSimulation2 *GetSimulation2()
{ return m_Simulation2; }
/**
* Set the simulation scale multiplier.
*
* @param simRate Float value to set m_SimRate to.
* Because m_SimRate is also used to
* scale TimeSinceLastFrame it must be
* clamped to 0.0f.
**/
inline void SetSimRate(float simRate)
{ if (isfinite(simRate)) m_SimRate = std::max(simRate, 0.0f); }
inline float GetSimRate() const
{ return m_SimRate; }
inline OsPath GetReplayPath() const
{ return m_ReplayPath; }
/**
* Replace the current turn manager.
* This class will take ownership of the pointer.
*/
void SetTurnManager(CTurnManager* turnManager);
CTurnManager* GetTurnManager() const
{ return m_TurnManager; }
IReplayLogger& GetReplayLogger() const
{ return *m_ReplayLogger; }
private:
void RegisterInit(const JS::HandleValue attribs, const std::string& savedState);
IReplayLogger* m_ReplayLogger;
std::vector<CColor> m_PlayerColors;
int LoadInitialState();
std::string m_InitialSavedState; // valid between RegisterInit and LoadInitialState
bool m_IsSavedGame; // true if loading a saved game; false for a new game
int LoadVisualReplayData();
OsPath m_ReplayPath;
bool m_IsVisualReplay;
std::istream* m_ReplayStream;
u32 m_FinalReplayTurn;
};
extern CGame *g_Game;
#endif
|