de/d75/_engine_sim_8h_source.html

/*

    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 "Application.h"


namespace RoR {


class EngineSim

{

    friend class ActorSpawner;


public:


    EngineSim(float min_rpm, float max_rpm, float torque, std::vector<float> gears, float dratio, ActorPtr actor);

    ~EngineSim();


    void PushNetworkState(float engine_rpm, float acc, float clutch, int gear, bool running, bool contact, char auto_mode, char auto_select=-1);


    void SetEngineOptions(float einertia, char etype, float eclutch, float ctime, float stime, float pstime, float irpm, float srpm, float maximix, float minimix, float ebraking);


    void SetTurboOptions(int type, float tinertiaFactor, int nturbos, float param1, float param2, float param3, float param4, float param5, float param6, float param7, float param8, float param9, float param10, float param11);


    void           SetAcceleration(float val);

    void           SetAutoMode(RoR::SimGearboxMode mode);

    void           SetClutch(float clutch);

    float          GetAcceleration();

    float          GetClutch();

    float          GetClutchForce();

    float          GetCrankFactor();

    float          GetSmoke();

    float          GetTorque();

    float          GetTurboPsi();

    RoR::SimGearboxMode GetAutoShiftMode();

    void           SetEngineRpm(float rpm);

    void           SetEnginePriming(bool p);

    void           SetHydroPumpWork(float work);

    void           SetWheelSpin(float rpm);

    void           SetTCaseRatio(float ratio);

    void           ToggleAutoShiftMode();

    void           OffStart();

    void           StartEngine();

    int            GetGear();

    int            GetGearRange();

    void           SetGear(int v);

    void           SetGearRange(int v);

    void           StopEngine();

    float          GetAccToHoldRPM();

    bool           HasTurbo() const         { return m_engine_has_turbo; };

    bool           isRunning() const        { return m_engine_is_running; };

    int            GetAutoMode() const      { return static_cast<int>(m_auto_mode); };

    char           GetEngineType() const    { return m_engine_type; };

    float          getIdleRPM() const       { return m_engine_idle_rpm; };

    float          getMaxRPM() const        { return m_engine_max_rpm; };

    float          getMinRPM() const        { return m_engine_min_rpm; };

    int            getNumGears() const      { return static_cast<int>(m_gear_ratios.size() - 2); };

    int            getNumGearsRanges() const{ return getNumGears() / 6 + 1; };

    TorqueCurve*   getTorqueCurve()         { return m_torque_curve; };

    float          GetEngineRpm() const     { return m_cur_engine_rpm; }

    float          GetEngineTorque() const  { return m_cur_engine_torque; }

    float          GetInputShaftRpm()       { return m_cur_wheel_revolutions * m_gear_ratios[m_cur_gear + 1]; };

    float          GetDriveRatio()          { return m_gear_ratios[m_cur_gear + 1]; };

    float          GetEngineInertia()       { return m_engine_inertia; };

    float          getEnginePower()         { return getEnginePower(m_cur_engine_rpm); };

    float          getEnginePower(float rpm);

    float          getTurboPower();

    float          getIdleMixture();

    float          getPrimeMixture();

    int            getAutoShift();

    void           autoSetAcc(float val);

    void           autoShiftDown();

    void           autoShiftSet(int mode);

    void           autoShiftUp();

    void           setManualClutch(float val);

    void           shift(int val);

    void           shiftTo(int val);

    void           updateShifts();

    void           UpdateEngineSim(float dt, int doUpdate);

    void           UpdateEngineAudio();

    void           UpdateInputEvents(float dt);


    // Ignition

    void           toggleContact();

    bool           hasContact() const { return m_contact; };


    enum autoswitch

    {

        REAR,

        NEUTRAL,

        DRIVE,

        TWO,

        ONE,

        MANUALMODE

    };


    enum turbomode

    {

        OLD,

        NEW

    };


private:


    enum shiftmodes

    {

        AUTOMATIC,

        SEMIAUTO,

        MANUAL,

        MANUAL_STICK,

        MANUAL_RANGES

    };


    // Vehicle

    ActorPtr         m_actor;


    // Gearbox

    float          m_ref_wheel_revolutions;

    float          m_cur_wheel_revolutions;

    int            m_cur_gear;

    int            m_cur_gear_range;

    int            m_num_gears;

    std::vector<float> m_gear_ratios;


    // Clutch

    float          m_clutch_force;

    float          m_clutch_time;

    float          m_cur_clutch;

    float          m_cur_clutch_torque;


    // Engine

    bool           m_engine_is_electric;

    bool           m_engine_has_air;

    bool           m_engine_has_turbo;

    int            m_engine_turbo_mode;

    bool           m_engine_is_running;

    char           m_engine_type;

    float          m_braking_torque;

    float          m_cur_acc;

    float          m_cur_engine_rpm;

    float          m_cur_engine_torque;

    float          m_diff_ratio;

    float          m_tcase_ratio;

    float          m_engine_torque;

    float          m_hydropump_state;

    float          m_min_idle_mixture;

    float          m_max_idle_mixture;

    float          m_engine_inertia;

    float          m_engine_max_rpm;

    float          m_engine_min_rpm;

    float          m_engine_idle_rpm;

    float          m_engine_stall_rpm;

    bool           m_engine_is_priming;

    TorqueCurve*   m_torque_curve;

    float          m_air_pressure;


    // Ignition

    bool           m_contact;

    bool           m_starter;


    // Shifting

    float          m_post_shift_time;

    float          m_post_shift_clock;

    float          m_shift_time;

    float          m_shift_clock;

    int            m_post_shifting;

    int            m_shifting;

    int            m_shift_val;


    // Auto transmission

    int            m_auto_mode;

    autoswitch     m_autoselect;

    float          m_auto_cur_acc;

    float          m_full_rpm_range;

    float          m_one_third_rpm_range;

    float          m_half_rpm_range;

    float          m_shift_behaviour;

    int            m_upshift_delay_counter;

    int            m_kickdown_delay_counter;

    std::deque<float> m_rpms;

    std::deque<float> m_accs;

    std::deque<float> m_brakes;


    // Turbo

#define MAXTURBO 4

    int            m_turbo_ver;

    float          m_cur_turbo_rpm[MAXTURBO];

    float          m_turbo_inertia_factor;

    int            m_num_turbos;

    int            m_max_turbo_rpm;

    float          m_engine_addi_torque[MAXTURBO];

    float          m_turbo_engine_rpm_operation;

    bool           m_turbo_has_bov;

    float          m_turbo_bov_rpm[MAXTURBO];

    int            m_min_bov_psi;

    bool           m_turbo_has_wastegate;

    float          m_min_wastegate_psi;

    bool           m_turbo_flutters;

    float          m_turbo_wg_threshold_p;

    float          m_turbo_wg_threshold_n;

    bool           m_turbo_has_antilag;

    float          m_antilag_min_rpm;

    float          m_antilag_rand_chance;

    float          m_antilag_power_factor;

};


} // namespace RoR