Game.h

Go to the documentation of this file.

/* Copyright (C) 2023 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 "graphics/Color.h"
#include "ps/CStr.h"
#include "ps/Errors.h"
#include "lib/os_path.h"
#include "scriptinterface/ScriptTypes.h"
#include "simulation2/helpers/Player.h"
 
#include <vector>
 
class CGameView;
class CSimulation2;
class CTurnManager;
class CWorld;
class IReplayLogger;
 
/**
 * 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 replayLog);
    ~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();
 
    const 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 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 (std::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:
    static const CStr EventNameSimulationUpdate;
 
    void RegisterInit(const JS::HandleValue attribs, const std::string& savedState);
    IReplayLogger* m_ReplayLogger;
 
    std::vector<CColor> m_PlayerColors;
 
    int LoadInitialState(const std::string& savedState);
    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