ActorManager.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
 
    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 "Application.h"
#include "CmdKeyInertia.h"
#include "Network.h"
#include "RigDef_Prerequisites.h"
#include "ScriptEvents.h"
#include "SimData.h"
#include "ThreadPool.h"
 
#include <string>
#include <vector>
 
namespace RoR {
 
 
class ActorManager
{
public:
 
    typedef std::vector<FreeForce> FreeForceVec_t;
 
    ActorManager();
    ~ActorManager();
 
    ActorPtr       CreateNewActor(ActorSpawnRequest rq, RigDef::DocumentPtr def);
    void           DeleteActorInternal(ActorPtr actor); 
 
    const ActorPtr& GetActorById(ActorInstanceID_t actor_id);
    const ActorPtr& GetActorByNetworkLinks(int source_id, int stream_id);
    ActorPtr        FindActorInsideBox(Collisions* collisions, const Ogre::String& inst, const Ogre::String& box);
    const ActorPtr& FetchNextVehicleOnList(ActorPtr player, ActorPtr prev_player);
    const ActorPtr& FetchPreviousVehicleOnList(ActorPtr player, ActorPtr prev_player);
    const ActorPtr& FetchRescueVehicle();
    ActorInstanceID_t GetActorNextInstanceId() { return m_actor_next_instance_id++; } 
 
    void           AddFreeForce(FreeForceRequest* rq);
    void           ModifyFreeForce(FreeForceRequest* rq);
    void           RemoveFreeForce(FreeForceID_t id);
    bool           FindFreeForce(FreeForceID_t id, FreeForceVec_t::iterator& out_itor);
    FreeForceID_t  GetFreeForceNextId() { return m_free_force_next_id++; } 
    FreeForceVec_t& GetFreeForces() { return m_free_forces; }
 
    void           UpdateActors(ActorPtr player_actor);
    void           SyncWithSimThread();
    void           UpdatePhysicsSimulation();
    void           WakeUpAllActors();
    void           SendAllActorsSleeping();
    void           SetTrucksForcedAwake(bool forced)       { m_forced_awake = forced; };
    bool           AreTrucksForcedAwake() const            { return m_forced_awake; }
    void           SetSimulationSpeed(float speed)         { m_simulation_speed = std::max(0.0f, speed); };
    float          GetSimulationSpeed() const              { return m_simulation_speed; };
    bool           IsSimulationPaused() const              { return m_simulation_paused; }
    void           SetSimulationPaused(bool v)             { m_simulation_paused = v; }
    float          GetTotalTime() const                    { return m_total_sim_time; }
    RoR::CmdKeyInertiaConfig& GetInertiaConfig()           { return m_inertia_config; }
    
 
    void           CleanUpSimulation(); 
 
    void           RepairActor(Collisions* collisions, const Ogre::String& inst, const Ogre::String& box, bool keepPosition = false);
    void           UpdateSleepingState(ActorPtr player_actor, float dt);
    
 
    void           UpdateInputEvents(float dt);
    RigDef::DocumentPtr   FetchActorDef(RoR::ActorSpawnRequest& rq);
    // Truck file handling
    void                  ExportActorDef(RigDef::DocumentPtr def, std::string filename, std::string rg_name);
 
#ifdef USE_SOCKETW
    void           HandleActorStreamData(std::vector<RoR::NetRecvPacket> packet);
#endif
    unsigned long  GetNetTime() { return m_net_timer.getMilliseconds(); };
    int            GetNetTimeOffset(int sourceid);
    void           UpdateNetTimeOffset(int sourceid, int offset);
    void           AddStreamMismatch(RoRnet::ActorStreamRegister* reg);
    void           RetryFailedStreamRegistrations(ScriptEventArgs* args);
    void           RequestSpawnRemoteActor(RoRnet::ActorStreamRegister* reg, const CacheEntryPtr& cache_entry, const RoRnet::UserInfo& userinfo, BitMask_t peeropts);
    RoRnet::UiStreamsHealth CheckNetworkStreamsOk(int sourceid);
    RoRnet::UiStreamsHealth CheckNetRemoteStreamsOk(int sourceid);
 
    // Savegames (defined in Savegame.cpp)
 
    bool           LoadScene(Ogre::String filename);
    bool           SaveScene(Ogre::String filename);
    void           RestoreSavedState(ActorPtr actor, rapidjson::Value const& j_entry);
 
    ActorPtrVec& GetActors() { return m_actors; };
    std::vector<ActorPtr> GetLocalActors();
 
    std::pair<ActorPtr, float> GetNearestActor(Ogre::Vector3 position);
 
    std::map<beam_t*, std::pair<ActorPtr, ActorPtr>> inter_actor_links;
    bool AreActorsDirectlyLinked(const ActorPtr& a1, const ActorPtr& a2);
 
    static const ActorPtr ACTORPTR_NULL; // Dummy value to be returned as const reference.
 
private:
 
    bool           CheckActorCollAabbIntersect(int a, int b);    
    bool           PredictActorCollAabbIntersect(int a, int b);  
    void           RemoveStreamSource(int sourceid);
    void           RemoveStream(int sourceid, int streamid);
    void           RecursiveActivation(int j, std::vector<bool>& visited);
    void           ForwardCommands(ActorPtr source_actor); 
    void           UpdateTruckFeatures(ActorPtr vehicle, float dt);
    void           CalcFreeForces();                             
 
    // Networking
    std::map<int, std::set<int>> m_stream_mismatches; 
    std::vector<RoRnet::ActorStreamRegister> m_stream_mismatched_regs; 
    std::map<int, int>  m_stream_time_offsets;       
    Ogre::Timer         m_net_timer;
 
    // Physics
    ActorPtrVec         m_actors;                         
    ActorInstanceID_t   m_actor_next_instance_id          = 1;     
    bool                m_forced_awake           = false; 
    int                 m_physics_steps          = 0;
    float               m_dt_remainder           = 0.f;   
    float               m_simulation_speed       = 1.f;   
    float               m_last_simulation_speed  = 0.1f;  
    float               m_simulation_time        = 0.f;   
    bool                m_simulation_paused      = false;
    float               m_total_sim_time         = 0.f;
    FreeForceVec_t      m_free_forces;                    
    FreeForceID_t       m_free_force_next_id     = 0;     
 
    // Utils
    std::unique_ptr<ThreadPool> m_sim_thread_pool;
    std::shared_ptr<Task>       m_sim_task;
    RoR::CmdKeyInertiaConfig    m_inertia_config;
};
class ActorManager {…};
 
 
} // namespace RoR