SimData.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-2023 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 "ForwardDeclarations.h"
#include "SimConstants.h"
#include "BitFlags.h"
#include "CmdKeyInertia.h"
#include "InputEngine.h"
 
#include <memory>
#include <Ogre.h>
#include <OgreUTFString.h>
#include <rapidjson/document.h>
 
namespace RoR {
 
enum CollisionEventFilter: short
{
    EVENT_NONE = 0,          
    EVENT_ALL,               
    EVENT_AVATAR,            
    EVENT_TRUCK,             
    EVENT_TRUCK_WHEELS,      
    EVENT_AIRPLANE,          
    EVENT_BOAT,              
};
 
enum class ExtCameraMode
{
    INVALID = -1,
    CLASSIC = 0,
    CINECAM = 1,
    NODE    = 2,
};
 
 
 
enum BeamType: short
{
    BEAM_NORMAL,
    BEAM_HYDRO,
    BEAM_VIRTUAL,         
};
 
 
 
enum HookState
{
    UNLOCKED,       
    PRELOCK,        
    LOCKED          
};
 
enum ActorType 
{
    // DO NOT MODIFY NUMBERS - serialized into cache file, see RoR::CacheEntry
 
    NOT_DRIVEABLE  = 0,   
    TRUCK          = 1,   
    AIRPLANE       = 2,   
    BOAT           = 3,   
    MACHINE        = 4,   
    AI             = 5,   
};
 
 
 
enum SpecialBeam: short
{
    NOSHOCK,        
    SHOCK1,         
    SHOCK2,         
    SHOCK3,         
    TRIGGER,        
    SUPPORTBEAM,    
    ROPE            
};
 
 
 
enum BlinkType 
{
    BLINK_NONE,     
    BLINK_LEFT,     
    BLINK_RIGHT,    
    BLINK_WARN      
};
 
enum HydroFlags
{
    HYDRO_FLAG_SPEED        = BITMASK(1),
    HYDRO_FLAG_DIR          = BITMASK(2),
    HYDRO_FLAG_AILERON      = BITMASK(3),
    HYDRO_FLAG_RUDDER       = BITMASK(4),
    HYDRO_FLAG_ELEVATOR     = BITMASK(5),
    HYDRO_FLAG_REV_AILERON  = BITMASK(6),
    HYDRO_FLAG_REV_RUDDER   = BITMASK(7),
    HYDRO_FLAG_REV_ELEVATOR = BITMASK(8),
};
 
enum AnimFlags
{
    ANIM_FLAG_AIRSPEED      = BITMASK(1),
    ANIM_FLAG_VVI           = BITMASK(2),
    ANIM_FLAG_ALTIMETER     = BITMASK(3),
    ANIM_FLAG_AOA           = BITMASK(4),
    ANIM_FLAG_FLAP          = BITMASK(5),
    ANIM_FLAG_AIRBRAKE      = BITMASK(6),
    ANIM_FLAG_ROLL          = BITMASK(7),
    ANIM_FLAG_PITCH         = BITMASK(8),
    ANIM_FLAG_THROTTLE      = BITMASK(9),
    ANIM_FLAG_RPM           = BITMASK(10),
    ANIM_FLAG_ACCEL         = BITMASK(11),
    ANIM_FLAG_BRAKE         = BITMASK(12),
    ANIM_FLAG_CLUTCH        = BITMASK(13),
    ANIM_FLAG_TACHO         = BITMASK(14),
    ANIM_FLAG_SPEEDO        = BITMASK(15),
    ANIM_FLAG_PBRAKE        = BITMASK(16),
    ANIM_FLAG_TURBO         = BITMASK(17),
    ANIM_FLAG_SHIFTER       = BITMASK(18),
    ANIM_FLAG_AETORQUE      = BITMASK(19),
    ANIM_FLAG_AEPITCH       = BITMASK(20),
    ANIM_FLAG_AESTATUS      = BITMASK(21),
    ANIM_FLAG_TORQUE        = BITMASK(22),
    ANIM_FLAG_HEADING       = BITMASK(23),
    ANIM_FLAG_DIFFLOCK      = BITMASK(24),
    ANIM_FLAG_STEERING      = BITMASK(25),
    ANIM_FLAG_EVENT         = BITMASK(26),
    ANIM_FLAG_AILERONS      = BITMASK(27),
    ANIM_FLAG_ARUDDER       = BITMASK(28),
    ANIM_FLAG_BRUDDER       = BITMASK(29),
    ANIM_FLAG_BTHROTTLE     = BITMASK(30),
    ANIM_FLAG_PERMANENT     = BITMASK(31),
    ANIM_FLAG_ELEVATORS     = BITMASK(32),
};
 
enum AnimModes
{
    ANIM_MODE_ROTA_X        = BITMASK(1),
    ANIM_MODE_ROTA_Y        = BITMASK(2),
    ANIM_MODE_ROTA_Z        = BITMASK(3),
    ANIM_MODE_OFFSET_X      = BITMASK(4),
    ANIM_MODE_OFFSET_Y      = BITMASK(5),
    ANIM_MODE_OFFSET_Z      = BITMASK(6),
    ANIM_MODE_AUTOANIMATE   = BITMASK(7),
    ANIM_MODE_NOFLIP        = BITMASK(8),
    ANIM_MODE_BOUNCE        = BITMASK(9),
};
 
 
 
enum ShockFlags
{
    SHOCK_FLAG_NORMAL           = BITMASK(1),
    SHOCK_FLAG_LACTIVE          = BITMASK(3),
    SHOCK_FLAG_RACTIVE          = BITMASK(4),
    SHOCK_FLAG_ISSHOCK2         = BITMASK(5),
    SHOCK_FLAG_ISSHOCK3         = BITMASK(6),
    SHOCK_FLAG_SOFTBUMP         = BITMASK(7),
    SHOCK_FLAG_ISTRIGGER        = BITMASK(8),
    SHOCK_FLAG_TRG_BLOCKER      = BITMASK(9),
    SHOCK_FLAG_TRG_CMD_SWITCH   = BITMASK(10),
    SHOCK_FLAG_TRG_CMD_BLOCKER  = BITMASK(11),
    SHOCK_FLAG_TRG_BLOCKER_A    = BITMASK(12),
    SHOCK_FLAG_TRG_HOOK_UNLOCK  = BITMASK(13),
    SHOCK_FLAG_TRG_HOOK_LOCK    = BITMASK(14),
    SHOCK_FLAG_TRG_CONTINUOUS   = BITMASK(15),
    SHOCK_FLAG_TRG_ENGINE       = BITMASK(16)
};
 
 
 
enum EngineTriggerType
{
    TRG_ENGINE_CLUTCH    = 0,
    TRG_ENGINE_BRAKE     = 1,
    TRG_ENGINE_ACC       = 2,
    TRG_ENGINE_RPM       = 3,
    TRG_ENGINE_SHIFTUP   = 4,
    TRG_ENGINE_SHIFTDOWN = 5 
};
 
enum class FlareType: char
{
    NONE           = 0,
    // Front lights
    HEADLIGHT      = 'f',
    HIGH_BEAM      = 'h',
    FOG_LIGHT      = 'g',
    // Rear lighs
    TAIL_LIGHT     = 't',
    BRAKE_LIGHT    = 'b',
    REVERSE_LIGHT  = 'R',
    // Special lights
    SIDELIGHT      = 's',
    BLINKER_LEFT   = 'l',
    BLINKER_RIGHT  = 'r',
    USER           = 'u',
    DASHBOARD      = 'd'
};
 
 
enum LocalizerType
{
    LOCALIZER_VERTICAL,
    LOCALIZER_HORIZONTAL,
    LOCALIZER_NDB,
    LOCALIZER_VOR
};
 
 
 
enum class ActorState
{
    LOCAL_SIMULATED,  
    NETWORKED_OK,     
    NETWORKED_HIDDEN, 
    LOCAL_REPLAY,
    LOCAL_SLEEPING,   
    DISPOSED          
};
 
enum class AeroEngineType
{
    AE_UNKNOWN,
    AE_XPROP,
    AE_TURBOJET,
};
 
// --------------------------------
// Soft body physics
 
struct node_t
{
    static const int8_t    INVALID_BBOX = -1;
 
    node_t()               { memset(this, 0, sizeof(node_t)); nd_coll_bbox_id = INVALID_BBOX; }
    node_t(size_t _pos)    { memset(this, 0, sizeof(node_t)); nd_coll_bbox_id = INVALID_BBOX; pos = static_cast<short>(_pos); }
 
    Ogre::Vector3   RelPosition;             
    Ogre::Vector3   AbsPosition;             
    Ogre::Vector3   Velocity;
    Ogre::Vector3   Forces;
 
    Ogre::Real      mass;
    Ogre::Real      buoyancy;
    Ogre::Real      friction_coef;
    Ogre::Real      surface_coef;
    Ogre::Real      volume_coef;
 
    NodeNum_t       pos;                     
    int16_t         nd_coll_bbox_id;         
    int16_t         nd_lockgroup;            
 
    // Bit flags
    bool            nd_cab_node:1;           
    bool            nd_rim_node:1;           
    bool            nd_tyre_node:1;          
    bool            nd_contacter:1;          
    bool            nd_contactable:1;        
    bool            nd_has_ground_contact:1; 
    bool            nd_has_mesh_contact:1;   
    bool            nd_immovable:1;          
    bool            nd_loaded_mass:1;        
    bool            nd_no_ground_contact:1;  
    bool            nd_override_mass:1;      
    bool            nd_under_water:1;        
    bool            nd_no_mouse_grab:1;      
 
    Ogre::Real      nd_avg_collision_slip;   
    Ogre::Vector3   nd_last_collision_slip;  
    Ogre::Vector3   nd_last_collision_force; 
    ground_model_t* nd_last_collision_gm;    
};
 
struct beam_t
{
    beam_t();
    ~beam_t();
 
    node_t*         p1 = nullptr;
    node_t*         p2 = nullptr;
    float           k = 0.f;                     
    float           d = 0.f;                     
    float           L = 0.f;                     
    float           minmaxposnegstress = 0.f;
    float           maxposstress = 0.f;
    float           maxnegstress = 0.f;
    float           strength = 0.f;
    float           stress = 0.f;
    float           plastic_coef = 0.f;
    int             detacher_group = DEFAULT_DETACHER_GROUP; 
    SpecialBeam     bounded = SpecialBeam::NOSHOCK;
    BeamType        bm_type = BeamType::BEAM_NORMAL;
    bool            bm_inter_actor = false;      
    ActorPtr        bm_locked_actor;             
    bool            bm_disabled = false;
    bool            bm_broken = false;
 
    float           shortbound = 0.f;
    float           longbound = 0.f;
    float           refL = 0.f;                  
 
    shock_t*        shock = nullptr;
 
    float           initial_beam_strength = 0.f; 
    float           default_beam_deform = 0.f;   
 
    float           debug_k = 0.f;               
    float           debug_d = 0.f;               
    float           debug_v = 0.f;               
};
 
struct shock_t
{
    shock_t() { memset(this, 0, sizeof(shock_t)); }
 
    int beamid;
    int flags;
 
    bool trigger_enabled;       
    float trigger_switch_state; 
    float trigger_boundary_t;   
    int trigger_cmdlong;        
    int trigger_cmdshort;       
    int last_debug_state;       
 
    float springin;  
    float dampin;    
    float springout; 
    float dampout;   
 
    float sprogin;   
    float dprogin;   
    float sprogout;  
    float dprogout;  
 
    float splitin;   
    float dslowin;   
    float dfastin;   
    float splitout;  
    float dslowout;  
    float dfastout;  
 
    float sbd_spring;           
    float sbd_damp;             
};
 
struct collcab_rate_t
{
    int rate;     // remaining amount of physics cycles to be skipped
    int distance; // distance (in physics cycles) to the previous collision check
};
 
 
struct soundsource_t
{
    soundsource_t();
    ~soundsource_t();
 
    SoundScriptInstancePtr ssi;
    NodeNum_t nodenum;
    int type;
};
 
struct wheel_t
{
    enum class BrakeCombo 
    {
        NONE,                 
        FOOT_HAND,            
        FOOT_HAND_SKID_LEFT,  
        FOOT_HAND_SKID_RIGHT, 
        FOOT_ONLY             
    };
 
    int         wh_num_nodes;
    node_t*     wh_nodes[50];             // TODO: remove limit, make this dyn-allocated ~ only_a_ptr, 08/2017
    int         wh_num_rim_nodes;
    node_t*     wh_rim_nodes[50];         // TODO: remove limit, make this dyn-allocated ~ only_a_ptr, 08/2017
    BrakeCombo  wh_braking;
    node_t*     wh_arm_node;
    node_t*     wh_near_attach_node;
    node_t*     wh_axis_node_0;
    node_t*     wh_axis_node_1;
    int         wh_propulsed;             // TODO: add enum ~ only_a_ptr, 08/2017
    Ogre::Real  wh_radius;
    Ogre::Real  wh_rim_radius;
    Ogre::Real  wh_speed;             
    Ogre::Real  wh_avg_speed;         
    Ogre::Real  wh_alb_coef;          
    Ogre::Real  wh_tc_coef;           
    Ogre::Real  wh_mass;              
    Ogre::Real  wh_torque;            
    Ogre::Real  wh_last_torque;       
    Ogre::Real  wh_last_retorque;     
    float       wh_net_rp;
    float       wh_width;
    bool        wh_is_detached;
 
    // Debug
    float debug_rpm;
    float debug_torque;
    Ogre::Vector3 debug_vel;
    Ogre::Vector3 debug_slip;
    Ogre::Vector3 debug_force;
    Ogre::Vector3 debug_scaled_cforce;
};
 
struct wheeldetacher_t
{
    int wd_wheel_id;
    int wd_detacher_group;
};
 
 
struct hook_t
{
    hook_t();
    ~hook_t();
 
    HookState  hk_locked = HookState::UNLOCKED;
    int        hk_group = 0;
    int        hk_lockgroup = 0;
    bool       hk_selflock = false;
    bool       hk_autolock = false;
    bool       hk_nodisable = false;
    float      hk_maxforce = 0.f;
    float      hk_lockrange = 0.f;
    float      hk_lockspeed = 0.f;
    float      hk_timer = 0.f;
    float      hk_timer_preset = 0.f;
    float      hk_min_length = 0.f; 
    node_t*    hk_hook_node = nullptr;
    node_t*    hk_lock_node = nullptr;
    beam_t*    hk_beam = nullptr;
    ActorPtr   hk_locked_actor;
};
 
struct ropable_t
{
    node_t *node;
    int pos;            
    int group;
    int attached_ties;  
    int attached_ropes; 
    bool multilock;     
};
 
struct rope_t
{
    rope_t();
    ~rope_t();
 
    int        rp_locked = 0;
    int        rp_group = 0;
    beam_t*    rp_beam = nullptr;
    ropable_t* rp_locked_ropable = nullptr;
    ActorPtr   rp_locked_actor;
};
 
struct tie_t
{
    tie_t();
    ~tie_t();
 
    ActorPtr   ti_locked_actor;
    beam_t*    ti_beam = nullptr;
    ropable_t* ti_locked_ropable = nullptr;
    int        ti_group = 0;
    float      ti_contract_speed = 0.f;
    float      ti_max_stress = 0.f;
    float      ti_min_length = 0.f;       
 
    bool       ti_no_self_lock:1;   
    bool       ti_tied:1;           
    bool       ti_tying:1;          
};
 
struct wing_t
{
    FlexAirfoil *fa;
    Ogre::SceneNode *cnode;
};
 
struct commandbeam_state_t
{
    commandbeam_state_t() { memset(this, 0, sizeof(commandbeam_state_t)); }
 
    int8_t   auto_moving_mode;      
 
    // Bit flags
    bool     pressed_center_mode:1; 
    bool     auto_move_lock:1;      
};
 
struct commandbeam_t
{
    uint16_t cmb_beam_index;            
    float    cmb_engine_coupling;       
    float    cmb_center_length;         
    float    cmb_speed;                 
    float    cmb_boundary_length;       
 
    // Bit flags
    bool     cmb_is_contraction:1;      
    bool     cmb_is_force_restricted:1; 
    bool     cmb_needs_engine:1;        
    bool     cmb_is_autocentering:1;    
    bool     cmb_plays_sound:1;         
    bool     cmb_is_1press:1;           
    bool     cmb_is_1press_center:1;    
 
    std::shared_ptr<commandbeam_state_t> cmb_state;
};
 
struct command_t
{
    int commandValueState = 0;
    float commandValue = 0;
    float triggerInputValue = 0.f;
    float playerInputValue = 0.f;
    bool trigger_cmdkeyblock_state = false;  
    std::vector<commandbeam_t> beams;
    std::vector<int> rotators;
    Ogre::String description;
    RoR::CmdKeyInertia rotator_inertia;
    RoR::CmdKeyInertia command_inertia;
};
 
struct hydrobeam_t
{
    uint16_t hb_beam_index; 
    float    hb_ref_length; 
    float    hb_speed;      
    int      hb_flags;
    int      hb_anim_flags; 
    float    hb_anim_param; 
    RoR::CmdKeyInertia  hb_inertia;
};
 
struct rotator_t
{
    bool needs_engine;
    NodeNum_t nodes1[4];
    NodeNum_t nodes2[4];
    NodeNum_t axis1; 
    NodeNum_t axis2;
    float angle;
    float rate;
    float force;
    float tolerance;
    float engine_coupling;
    float debug_rate;
    float debug_aerror;
};
 
struct flare_t
{
    NodeNum_t noderef = NODENUM_INVALID;
    NodeNum_t nodex   = NODENUM_INVALID;
    NodeNum_t nodey   = NODENUM_INVALID;
    float offsetx;
    float offsety;
    float offsetz;
    Ogre::SceneNode *snode = nullptr;
    Ogre::BillboardSet *bbs = nullptr; 
    Ogre::Light *light = nullptr;
    FlareType fl_type;
    int controlnumber; 
    int dashboard_link; 
    float blinkdelay;
    float blinkdelay_curr;
    bool blinkdelay_state;
    float size;
    float intensity;
    bool uses_inertia = false; 
    SimpleInertia inertia; 
};
 
struct exhaust_t
{
    NodeNum_t emitterNode   = NODENUM_INVALID;
    NodeNum_t directionNode = NODENUM_INVALID;
    Ogre::SceneNode *smokeNode = nullptr;
    Ogre::ParticleSystem* smoker = nullptr; 
    std::string particleSystemName; 
};
 
 
struct cparticle_t
{
    NodeNum_t emitterNode   = NODENUM_INVALID;
    NodeNum_t directionNode = NODENUM_INVALID;
    bool active;
    Ogre::SceneNode *snode;
    Ogre::ParticleSystem* psys;
};
 
struct PropAnimKeyState
{
    bool eventlock_present = false;
    bool event_active_prev = false;
    bool anim_active = false;
    events event_id = EV_MODE_LAST; // invalid
};
 
class CmdKeyArray
{
public:
    command_t& operator[](int index)
    {
        if (index >= 0 && index <= MAX_COMMANDS) // for backwards compatibility, we accept 0 as index too.
        {
            return m_commandkey[index]; // valid commandkey (indexed 1-MAX_COMMANDS!)
        }
        else if (index < 0)
        {
            return m_virtualkey[index]; // 'virtual' commandkey - if hashmap value doesn't exist, it's inserted automatically.
        }
        else
        {
            assert(false);
            return m_dummykey; // Whatever!
        }
    }
private:
    std::array<command_t, MAX_COMMANDS + 1> m_commandkey; 
    std::unordered_map<int, command_t> m_virtualkey; 
    command_t m_dummykey;
};
 
struct UniqueCommandKeyPair
{
    std::string uckp_description;
    CommandkeyID_t uckp_key1 = COMMANDKEYID_INVALID;
    CommandkeyID_t uckp_key2 = COMMANDKEYID_INVALID;
};
 
 
// --------------------------------
// some non-actor structs
 
 
 
 
struct collision_box_t
{
    bool virt;
    bool refined;
    bool selfrotated;
    bool camforced;
    bool enabled;
    CollisionEventFilter event_filter;
    short eventsourcenum;
    Ogre::Vector3 lo;           
    Ogre::Vector3 hi;           
    Ogre::Vector3 center;       
    Ogre::Quaternion rot;       
    Ogre::Quaternion unrot;     
    Ogre::Vector3 selfcenter;   
    Ogre::Quaternion selfrot;   
    Ogre::Quaternion selfunrot; 
    Ogre::Vector3 relo;         
    Ogre::Vector3 rehi;         
    Ogre::Vector3 campos;       
    Ogre::Vector3 debug_verts[8];
};
typedef std::vector<collision_box_t*> CollisionBoxPtrVec;
 
struct ground_model_t
{
    float va;                       
    float ms;                       
    float mc;                       
    float t2;                       
    float vs;                       
    float alpha;                    
    float strength;                 
 
    float fluid_density;            
    float flow_consistency_index;   
 
    float flow_behavior_index;
 
    
    float solid_ground_level;       
    float drag_anisotropy;          
 
    int fx_type;
    Ogre::ColourValue fx_colour;
    char name[256];
    char basename[256];
    char particle_name[256];
 
    int fx_particle_amount;         
 
    float fx_particle_min_velo;     
    float fx_particle_max_velo;     
    float fx_particle_fade;         
    float fx_particle_timedelta;    
    float fx_particle_velo_factor;  
    float fx_particle_ttl;
};
 
 
enum class FreeForceType
{
    DUMMY,               
    CONSTANT,            
    TOWARDS_COORDS,      
    TOWARDS_NODE,        
};
 
struct FreeForce
{
    // Common params:
    FreeForceID_t        ffc_id = FREEFORCEID_INVALID;
    FreeForceType        ffc_type = FreeForceType::DUMMY;
    float                ffc_force_magnitude = 0.f;
    ActorPtr             ffc_base_actor;
    NodeNum_t            ffc_base_node = NODENUM_INVALID;
    // Direction-specific params:
    Ogre::Vector3        ffc_force_const_direction = Ogre::Vector3::ZERO; 
    Ogre::Vector3        ffc_target_coords = Ogre::Vector3::ZERO;
    ActorPtr             ffc_target_actor;
    NodeNum_t            ffc_target_node = NODENUM_INVALID;
};
 
struct FreeForceRequest
{
    // AngelScript `dictionary` converts all primitives to `double` or `int64`, see 'scriptdictionary.cpp', function `Set()`
    
    // common params:
    int64_t ffr_id = FREEFORCEID_INVALID;
    int64_t ffr_type = (int64_t)FreeForceType::DUMMY;
    double ffr_force_magnitude = 0.0;
    int64_t ffr_base_actor = ACTORINSTANCEID_INVALID;
    int64_t ffr_base_node = NODENUM_INVALID;
    // direction-specific params:
    Ogre::Vector3 ffr_force_const_direction = Ogre::Vector3::ZERO;
    Ogre::Vector3 ffr_target_coords = Ogre::Vector3::ZERO;
    int64_t ffr_target_actor = ACTORINSTANCEID_INVALID;
    int64_t ffr_target_node = NODENUM_INVALID;
    
};
 
 
struct authorinfo_t
{
    int id;
    Ogre::String type;
    Ogre::String name;
    Ogre::String email;
};
 
struct ActorSpawnRequest
{
    ActorSpawnRequest();
    ~ActorSpawnRequest();
 
    enum class Origin 
    {
        UNKNOWN,
        CONFIG_FILE,  
        TERRN_DEF,    
        USER,         
        SAVEGAME,     
        NETWORK,      
        AI            
    };
 
    CacheEntryPtr       asr_cache_entry; 
    std::string         asr_filename;    
    Ogre::String        asr_config;
    Ogre::Vector3       asr_position = Ogre::Vector3::ZERO;
    Ogre::Quaternion    asr_rotation = Ogre::Quaternion::ZERO;
    collision_box_t*    asr_spawnbox = nullptr;
    CacheEntryPtr       asr_skin_entry;
    CacheEntryPtr       asr_tuneup_entry; 
    TuneupDefPtr        asr_working_tuneup; 
    Origin              asr_origin = Origin::UNKNOWN;
    int                 asr_debugview = 0; //(int)DebugViewType::DEBUGVIEW_NONE;
    Ogre::UTFString     asr_net_username;
    int                 asr_net_color = 0;
    int                 net_source_id = 0;
    int                 net_stream_id = 0;
    bool                asr_free_position = false;   
    bool                asr_enter = true;
    bool                asr_terrn_machine = false;   
    std::shared_ptr<rapidjson::Document>
                        asr_saved_state;             
};
 
struct ActorModifyRequest
{
    ActorModifyRequest();
    ~ActorModifyRequest();
 
    enum class Type
    {
        INVALID,
        RELOAD,               
        RESET_ON_INIT_POS,
        RESET_ON_SPOT,
        SOFT_RESET,
        RESTORE_SAVED,
        WAKE_UP,
    };
 
    ActorInstanceID_t   amr_actor = ACTORINSTANCEID_INVALID;// not ActorPtr because it's not thread-safe
    Type                amr_type;
    std::shared_ptr<rapidjson::Document>
                        amr_saved_state;
    CacheEntryPtr       amr_addonpart; 
    std::string         amr_addonpart_fname; 
};
 
enum class ActorLinkingRequestType
{
    INVALID,
    LOAD_SAVEGAME,
    // hookToggle()
    HOOK_LOCK,
    HOOK_UNLOCK,
    HOOK_TOGGLE,
    HOOK_MOUSE_TOGGLE,
    HOOK_RESET,
    // tieToggle()
    TIE_TOGGLE,
    TIE_RESET,
    // ropeToggle()
    ROPE_TOGGLE,
    ROPE_RESET,
    // toggleSlideNodeLock()
    SLIDENODE_TOGGLE
};
 
struct ActorLinkingRequest
{
    ActorInstanceID_t alr_actor_instance_id = ACTORINSTANCEID_INVALID;
    ActorLinkingRequestType alr_type = ActorLinkingRequestType::INVALID;
    // hookToggle()
    int alr_hook_group = -1;
    NodeNum_t alr_hook_mousenode = NODENUM_INVALID;
    // tieToggle()
    int alr_tie_group = -1;
    // ropeToggle()
    int alr_rope_group = -1;
};
 
} // namespace RoR