GameContext.h

Go to the documentation of this file.

/*
    This source file is part of Rigs of Rods
    Copyright 2005-2012 Pierre-Michel Ricordel
    Copyright 2007-2012 Thomas Fischer
    Copyright 2013-2020 Petr Ohlidal
 
    For more information, see http://www.rigsofrods.org/
 
    Rigs of Rods is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3, as
    published by the Free Software Foundation.
 
    Rigs of Rods 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 Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
*/
 
 
#pragma once
 
#include "ActorManager.h"
#include "CacheSystem.h"
#include "CharacterFactory.h"
#include "RaceSystem.h"
#include "RepairMode.h"
#include "SceneMouse.h"
#include "SimData.h"
#include "Terrain.h"
 
#include <list>
#include <mutex>
#include <queue>
#include <string>
 
namespace RoR {
 
 
 
struct Message
{
    Message(MsgType _type): type(_type) {}
    Message(MsgType _type, std::string const& _desc): type(_type), description(_desc) {}
    Message(MsgType _type, void* _data): type(_type), payload(_data) {}
 
    MsgType     type         = MSG_INVALID;
    std::string description;
    void*       payload      = nullptr;
    std::vector<Message> chain; 
};
struct Message {…};
 
typedef std::queue < Message, std::list<Message>> GameMsgQueue;
 
 
 
class GameContext
{
    friend class AppContext;
public:
 
    GameContext();
    ~GameContext();
 
 
    void                PushMessage(Message m);  
    void                ChainMessage(Message m); 
    bool                HasMessages();
    Message             PopMessage();
 
 
    bool                LoadTerrain(std::string const& filename_part);
    void                UnloadTerrain();
    const TerrainPtr&   GetTerrain() { return m_terrain; }
 
 
    ActorPtr            SpawnActor(ActorSpawnRequest& rq);
    void                ModifyActor(ActorModifyRequest& rq);
    void                DeleteActor(ActorPtr actor);
    void                UpdateActors();
    ActorManager*       GetActorManager() { return &m_actor_manager; }
    const ActorPtr&     FetchPrevVehicleOnList();
    const ActorPtr&     FetchNextVehicleOnList();
    ActorPtr            FindActorByCollisionBox(std::string const & ev_src_instance_name, std::string const & box_name);
    void                RespawnLastActor();
    void                SpawnPreselectedActor(std::string const& preset_vehicle, std::string const& preset_veh_config); 
 
    const ActorPtr&     GetPlayerActor() { return m_player_actor; }
    const ActorPtr&     GetPrevPlayerActor() { return m_prev_player_actor; }
    const ActorPtr&     GetLastSpawnedActor() { return m_last_spawned_actor; } 
    const ActorPtr&     GetActorRemotelyReceivingCommands() { return m_actor_remotely_receiving_commands; }
    void                SetPrevPlayerActor(ActorPtr actor);
    void                ChangePlayerActor(ActorPtr actor);
 
    void                ShowLoaderGUI(int type, const Ogre::String& instance, const Ogre::String& box);
    void                OnLoaderGuiCancel(); 
    void                OnLoaderGuiApply(RoR::LoaderType type, CacheEntryPtr entry, std::string sectionconfig);  
 
 
    void                CreatePlayerCharacter(); 
    Character*          GetPlayerCharacter();
    CharacterFactory*   GetCharacterFactory() { return &m_character_factory; }
 
    // (defined in Savegame.cpp)
 
    void                LoadScene(std::string const& filename); 
    void                SaveScene(std::string const& filename);
    std::string         GetQuicksaveFilename(); 
    std::string         ExtractSceneName(std::string const& filename);
    std::string         ExtractSceneTerrain(std::string const& filename); 
    void                HandleSavegameHotkeys();
 
 
    RaceSystem&         GetRaceSystem() { return m_race_system; }
    RepairMode&         GetRepairMode() { return m_recovery_mode; }
    SceneMouse&         GetSceneMouse() { return m_scene_mouse; }
    void                TeleportPlayer(float x, float z);
    void                UpdateGlobalInputEvents();
    void                UpdateSimInputEvents(float dt);
    void                UpdateSkyInputEvents(float dt);
    void                UpdateCommonInputEvents(float dt);
    void                UpdateAirplaneInputEvents(float dt);
    void                UpdateBoatInputEvents(float dt);
    void                UpdateTruckInputEvents(float dt);
 
 
private:
    // Message queue
    GameMsgQueue        m_msg_queue;
    Message*            m_msg_chain_end = nullptr;
    std::mutex          m_msg_mutex;
 
    // Terrain
    TerrainPtr          m_terrain;
 
    // Actors (physics and netcode)
    ActorManager        m_actor_manager;
    ActorPtr            m_player_actor;           
    ActorPtr            m_prev_player_actor;      
    ActorPtr            m_last_spawned_actor;     
    ActorPtr            m_actor_remotely_receiving_commands; 
    
    CacheEntryPtr       m_last_cache_selection;   
    CacheEntryPtr       m_last_skin_selection;
    CacheEntryPtr       m_last_tuneup_selection;
    Ogre::String        m_last_section_config;
    ActorSpawnRequest   m_current_selection;                
    CacheEntryPtr       m_dummy_cache_selection;
 
    // Characters (simplified physics and netcode)
    CharacterFactory    m_character_factory;
 
    // Gameplay feats (misc.)
    RaceSystem          m_race_system;
    RepairMode          m_recovery_mode;                     
    SceneMouse          m_scene_mouse;                       
    Ogre::Timer         m_timer;
    Ogre::Vector3       prev_pos = Ogre::Vector3::ZERO;
};
class GameContext {…};
 
 
} // namespace RoR