GameContext.cpp

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/>.
*/
 
#include "GameContext.h"
 
#include "AppContext.h"
#include "Actor.h"
#include "AeroEngine.h"
#include "CacheSystem.h"
#include "Collisions.h"
#include "Console.h"
#include "DashBoardManager.h"
#include "Engine.h"
#include "GfxScene.h"
#include "GUIManager.h"
#include "GUI_FrictionSettings.h"
#include "GUI_MainSelector.h"
#include "GUI_TopMenubar.h"
#include "InputEngine.h"
#include "OverlayWrapper.h"
#include "Replay.h"
#include "ScrewProp.h"
#include "ScriptEngine.h"
#include "SkyManager.h"
#include "SkyXManager.h"
#include "SoundScriptManager.h"
#include "Terrain.h"
#include "Terrn2FileFormat.h"
#include "TuneupFileFormat.h"
#include "Utils.h"
#include "VehicleAI.h"
 
using namespace RoR;
 
GameContext::GameContext()
{
    // Constructs `ActorPtr` - doesn't compile without `#include Actor.h` - not pretty if in header (even if auto-generated by C++).
}
 
GameContext::~GameContext()
{
    // Destructs `ActorPtr` - doesn't compile without `#include Actor.h` - not pretty if in header (even if auto-generated by C++).
}
 
// --------------------------------
// Message queue
 
void GameContext::PushMessage(Message m)
{
    std::lock_guard<std::mutex> lock(m_msg_mutex);
    m_msg_queue.push(m);
    m_msg_chain_end = &m_msg_queue.back();
}
 
void GameContext::ChainMessage(Message m)
{
    std::lock_guard<std::mutex> lock(m_msg_mutex);
    if (m_msg_chain_end)
    {
        
        m_msg_chain_end->chain.push_back(m);
        m_msg_chain_end = &m_msg_chain_end->chain.back();
    }
    else
    {
        // Regular `PushMessage()`, just without the lock.
        m_msg_queue.push(m);
        m_msg_chain_end = &m_msg_queue.back();
    }
}
 
bool GameContext::HasMessages()
{
    std::lock_guard<std::mutex> lock(m_msg_mutex);
    return !m_msg_queue.empty();
}
 
Message GameContext::PopMessage()
{
    std::lock_guard<std::mutex> lock(m_msg_mutex);
    ROR_ASSERT(m_msg_queue.size() > 0);
    if (m_msg_chain_end == &m_msg_queue.front())
    {
        m_msg_chain_end = nullptr;
    }
    Message m = m_msg_queue.front();
    m_msg_queue.pop();
    return m;
}
 
// --------------------------------
// Terrain
 
bool GameContext::LoadTerrain(std::string const& filename_part)
{
    m_last_spawned_actor = nullptr;
 
    // Find terrain in modcache
    CacheEntryPtr terrn_entry = App::GetCacheSystem()->FindEntryByFilename(LT_Terrain, /*partial=*/true, filename_part);
    if (!terrn_entry)
    {
        Str<200> msg; msg << _L("Terrain not found: ") << filename_part;
        RoR::Log(msg.ToCStr());
        App::GetGuiManager()->ShowMessageBox(_L("Terrain loading error"), msg.ToCStr());
        return false;
    }
 
    // Init resources
    App::GetCacheSystem()->LoadResource(terrn_entry);
 
    // Load the terrain def file
    Terrn2DocumentPtr terrn2;
    std::string const& filename = terrn_entry->fname;
    try
    {
        Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename);
        LOG(" ===== LOADING TERRAIN " + filename);
        Terrn2Parser parser;
        terrn2 = parser.LoadTerrn2(stream);
        if (!terrn2)
        {
            return false; // Errors already logged to console
        }
    }
    catch (Ogre::Exception& e)
    {
        App::GetGuiManager()->ShowMessageBox(_L("Terrain loading error"), e.getFullDescription().c_str());
        return false;
    }
    terrn_entry->terrn2_def = terrn2;
 
    for (std::string const& assetpack_filename: terrn2->assetpack_files)
    {
        App::GetCacheSystem()->LoadAssetPack(terrn_entry, assetpack_filename);
    }
 
    // CAUTION - the global instance must be set during init! Needed by:
    // * GameScript::spawnObject()
    // * ProceduralManager
    // * Landusemap
    // * SurveyMapTextureCreator
    // * Collisions (debug visualization)
    m_terrain = new RoR::Terrain(terrn_entry, terrn2);
    if (!m_terrain->initialize())
    {
        m_terrain = nullptr; // release local reference - object will be deleted when all references are released.
        return false; // Message box already displayed
    }
 
    // Initialize envmap textures by rendering center of map
    Ogre::Vector3 center = m_terrain->getMaxTerrainSize() / 2;
    center.y = m_terrain->getHeightAt(center.x, center.z) + 1.0f;
    App::GetGfxScene()->GetEnvMap().UpdateEnvMap(center, /*gfx_actor:*/nullptr, /*full:*/true);
 
    // Scan groundmodels
    App::GetGuiManager()->FrictionSettings.AnalyzeTerrain();
 
    return true;
}
 
void GameContext::UnloadTerrain()
{
    if (m_terrain != nullptr)
    {
        // dispose(), do not `delete` - script may still hold reference to the object.
        m_terrain->dispose();
        // release local reference - object will be deleted when all references are released.
        m_terrain = nullptr;
    }
}
 
// --------------------------------
// Actors (physics and netcode)
 
ActorPtr GameContext::SpawnActor(ActorSpawnRequest& rq)
{
    if (rq.asr_origin == ActorSpawnRequest::Origin::USER)
    {
        m_last_cache_selection = rq.asr_cache_entry;
        m_last_skin_selection  = rq.asr_skin_entry;
        m_last_tuneup_selection = rq.asr_tuneup_entry;
        m_last_section_config  = rq.asr_config;
 
        if (rq.asr_spawnbox == nullptr)
        {
            if (m_player_actor != nullptr)
            {
                float h = m_player_actor->getMaxHeight(true);
                rq.asr_rotation = Ogre::Quaternion(Ogre::Degree(270) - Ogre::Radian(m_player_actor->getRotation()), Ogre::Vector3::UNIT_Y);
                rq.asr_position = m_player_actor->getRotationCenter();
                rq.asr_position.y = m_terrain->GetCollisions()->getSurfaceHeightBelow(rq.asr_position.x, rq.asr_position.z, h);
                rq.asr_position.y += m_player_actor->getHeightAboveGroundBelow(h, true); // retain height above ground
            }
            else
            {
                Character* player_character = this->GetPlayerCharacter();
                rq.asr_rotation = Ogre::Quaternion(Ogre::Degree(180) - player_character->getRotation(), Ogre::Vector3::UNIT_Y);
                rq.asr_position = player_character->getPosition();
            }
        }
    }
 
    LOG(" ===== LOADING VEHICLE: " + rq.asr_filename);
 
    if (rq.asr_cache_entry)
    {
        rq.asr_filename = rq.asr_cache_entry->fname;
    }
    else
    {
        rq.asr_cache_entry = App::GetCacheSystem()->FindEntryByFilename(LT_AllBeam, /*partial:*/false, rq.asr_filename);
    }
 
    RigDef::DocumentPtr def = m_actor_manager.FetchActorDef(rq);
    if (def == nullptr)
    {
        return nullptr; // Error already reported
    }
 
    if (rq.asr_skin_entry)
    {
        App::GetCacheSystem()->LoadResource(rq.asr_skin_entry); // Also loads associated .skin file.
        if (!rq.asr_skin_entry->skin_def) // Make sure .skin was loaded OK.
        {
            rq.asr_skin_entry = nullptr; // Error already logged
        }
    }
 
    if (App::sim_tuning_enabled->getBool() && (App::mp_state->getEnum<MpState>() != MpState::CONNECTED))
    {
        if (rq.asr_tuneup_entry)
        {
            App::GetCacheSystem()->LoadResource(rq.asr_tuneup_entry); // Also loads associated .tuneup file.
            if (!rq.asr_tuneup_entry->tuneup_def)
            {
                rq.asr_tuneup_entry = nullptr; // Error already logged
            }
        }
    }
    else
    {
        rq.asr_working_tuneup = nullptr; // Make sure no tuneup is used
    }
 
#ifdef USE_SOCKETW
    if (rq.asr_origin != ActorSpawnRequest::Origin::NETWORK)
    {
        if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
        {
            RoRnet::UserInfo info = App::GetNetwork()->GetLocalUserData();
            rq.asr_net_username = tryConvertUTF(info.username);
            rq.asr_net_color    = info.colournum;
        }
    }
#endif //SOCKETW
 
    ActorPtr fresh_actor = m_actor_manager.CreateNewActor(rq, def);
    bool fresh_actor_seat_player = false;
 
    // lock slide nodes after spawning the actor?
    if (def->slide_nodes_connect_instantly)
    {
        fresh_actor->toggleSlideNodeLock(); // OK to invoke here - processing MSG_SIM_ACTOR_SPAWN_REQUESTED
    }
 
    if (rq.asr_origin == ActorSpawnRequest::Origin::USER)
    {
        m_last_spawned_actor = fresh_actor;
        if (fresh_actor->ar_driveable != NOT_DRIVEABLE)
        {
            fresh_actor_seat_player = true;
        }
        if (rq.asr_spawnbox == nullptr)
        {
            // Try to resolve collisions with other actors
            fresh_actor->resolveCollisions(50.0f, m_player_actor == nullptr);
        }
    }
    else if (rq.asr_origin == ActorSpawnRequest::Origin::CONFIG_FILE)
    {
        if (fresh_actor->ar_driveable != NOT_DRIVEABLE &&
            fresh_actor->ar_num_nodes > 0 &&
            App::diag_preset_veh_enter->getBool())
        {
            fresh_actor_seat_player = true;
        }
    }
    else if (rq.asr_origin == ActorSpawnRequest::Origin::TERRN_DEF)
    {
        if (rq.asr_terrn_machine)
        {
            fresh_actor->ar_driveable = MACHINE;
        }
    }
    else if (rq.asr_origin == ActorSpawnRequest::Origin::AI)
    {
        fresh_actor->ar_driveable = AI;
        fresh_actor->ar_state = ActorState::LOCAL_SIMULATED;
 
        if (fresh_actor->ar_engine)
        {
            fresh_actor->ar_engine->setAutoMode(RoR::SimGearboxMode::AUTO);
            fresh_actor->ar_engine->autoShiftSet(Engine::DRIVE);
        }
 
        if (App::mp_state->getEnum<MpState>() == MpState::LOCAL_SCRIPT)
        {
            fresh_actor->ar_net_source_id = rq.net_source_id;
            fresh_actor->ar_net_stream_id = rq.net_stream_id;
 
            if (BITMASK_IS_1(rq.asr_net_peeropts, RoRnet::PEEROPT_MUTE_ACTORS))
            {
                this->PushMessage(Message(MSG_SIM_MUTE_NET_ACTOR_REQUESTED, new ActorPtr(fresh_actor)));
            }
            if (BITMASK_IS_1(rq.asr_net_peeropts, RoRnet::PEEROPT_HIDE_ACTORS))
            {
                this->PushMessage(Message(MSG_SIM_HIDE_NET_ACTOR_REQUESTED, new ActorPtr(fresh_actor)));
            }
        }
    }
    else if (rq.asr_origin == ActorSpawnRequest::Origin::NETWORK)
    {
        fresh_actor->ar_net_source_id = rq.net_source_id;
        fresh_actor->ar_net_stream_id = rq.net_stream_id;
 
        if (BITMASK_IS_1(rq.asr_net_peeropts, RoRnet::PEEROPT_MUTE_ACTORS))
        {
            this->PushMessage(Message(MSG_SIM_MUTE_NET_ACTOR_REQUESTED, new ActorPtr(fresh_actor)));
        }
        if (BITMASK_IS_1(rq.asr_net_peeropts, RoRnet::PEEROPT_HIDE_ACTORS))
        {
            this->PushMessage(Message(MSG_SIM_HIDE_NET_ACTOR_REQUESTED, new ActorPtr(fresh_actor)));
        }
    }
    else if (rq.asr_origin == ActorSpawnRequest::Origin::SAVEGAME)
    {
        if (rq.asr_saved_state)
        {
            ActorModifyRequest* req = new ActorModifyRequest();
            req->amr_actor = fresh_actor->ar_instance_id;
            req->amr_type = ActorModifyRequest::Type::RESTORE_SAVED;
            req->amr_saved_state = rq.asr_saved_state;
            this->PushMessage(Message(MSG_SIM_MODIFY_ACTOR_REQUESTED, (void*)req));
        }
    }
    else
    {
        if (fresh_actor->ar_driveable != NOT_DRIVEABLE &&
            rq.asr_origin != ActorSpawnRequest::Origin::NETWORK &&
            rq.asr_enter)
        {
            fresh_actor_seat_player = true;
        }
    }
 
    if (fresh_actor_seat_player)
    {
        this->PushMessage(Message(MSG_SIM_SEAT_PLAYER_REQUESTED, new ActorPtr(fresh_actor)));
        // Loading all addonparts to resolve conflicts is slow and would cause huge UI lag if not forced now. Do it right after player was seated in the actor.
        this->ChainMessage(Message(MSG_GUI_REFRESH_TUNING_MENU_REQUESTED));
    }
 
    return fresh_actor;
}
 
void GameContext::ModifyActor(ActorModifyRequest& rq)
{
    ActorPtr actor = m_actor_manager.GetActorById(rq.amr_actor);
 
    if (!actor)
    {
        return;
    }
 
    if (rq.amr_type == ActorModifyRequest::Type::SOFT_RESET)
    {
        actor->SoftReset();
    }
    else if (rq.amr_type == ActorModifyRequest::Type::RESET_ON_SPOT)
    {
        actor->SyncReset(/*reset_position:*/false);
    }
    else if (rq.amr_type == ActorModifyRequest::Type::RESET_ON_INIT_POS)
    {
        actor->SyncReset(/*reset_position:*/true);
    }
    else if (rq.amr_type == ActorModifyRequest::Type::RESTORE_SAVED)
    {
        m_actor_manager.RestoreSavedState(actor, *rq.amr_saved_state.get());
    }
    else if (rq.amr_type == ActorModifyRequest::Type::WAKE_UP &&
        actor->ar_state == ActorState::LOCAL_SLEEPING)
    {
        actor->ar_state = ActorState::LOCAL_SIMULATED;
        actor->ar_sleep_counter = 0.0f;
    }
    else if (rq.amr_type == ActorModifyRequest::Type::RELOAD)
    {
        if (actor->getUsedActorEntry()->deleted)
        {
            App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_ACTOR, Console::CONSOLE_SYSTEM_ERROR,
                fmt::format(_LC("GameContext", "Cannot reload '{}' ({}) - the associated modcache entry was deleted."),
                    actor->getUsedActorEntry()->dname, actor->getUsedActorEntry()->fname));
            return;
        }
 
        // Create spawn request while actor still exists
        ActorSpawnRequest* srq = new ActorSpawnRequest;
        srq->asr_position   = Ogre::Vector3(actor->getPosition().x, actor->getMinHeight(), actor->getPosition().z);
        srq->asr_rotation   = Ogre::Quaternion(Ogre::Degree(270) - Ogre::Radian(actor->getRotation()), Ogre::Vector3::UNIT_Y);
        srq->asr_config     = actor->getSectionConfig();
        srq->asr_skin_entry = actor->getUsedSkinEntry();
        srq->asr_working_tuneup = actor->getWorkingTuneupDef();
        srq->asr_cache_entry= actor->getUsedActorEntry();
        srq->asr_debugview  = (int)actor->GetGfxActor()->GetDebugView();
        srq->asr_origin     = ActorSpawnRequest::Origin::USER;
 
        // This deletes all actors using the resource bundle, including the one we're reloading.
        this->PushMessage(Message(MSG_EDI_RELOAD_BUNDLE_REQUESTED, new CacheEntryPtr(actor->getUsedActorEntry())));
 
        // Load our actor again, but only after all actors are deleted.
        this->ChainMessage(Message(MSG_SIM_SPAWN_ACTOR_REQUESTED, (void*)srq));
    }
    else if (rq.amr_type == ActorModifyRequest::Type::SOFT_RESPAWN)
    {
        actor->softRespawn(rq.amr_softrespawn_position, rq.amr_softrespawn_rotation);
    }
    else if (rq.amr_type == ActorModifyRequest::Type::REFRESH_VISUALS)
    {
        actor->GetGfxActor()->UpdateSimDataBuffer();
        App::GetGfxScene()->ForceUpdateSingleGfxActor(actor->GetGfxActor());
    }
}
 
void GameContext::DeleteActor(ActorPtr actor)
{
    if (actor == m_player_actor)
    {
        Ogre::Vector3 center = m_player_actor->getRotationCenter();
        this->ChangePlayerActor(nullptr); // Get out of the vehicle
        this->GetPlayerCharacter()->setPosition(center);
        // Update scene SimBuffer immediatelly to prevent having dangling pointer.
        App::GetGfxScene()->GetSimDataBuffer().simbuf_player_actor = nullptr;
    }
 
    if (actor == m_prev_player_actor)
    {
        m_prev_player_actor = nullptr;
    }
 
    if (actor == m_last_spawned_actor)
    {
        m_last_spawned_actor = nullptr;
    }
 
    // Find linked actors and un-tie if tied
    for (auto actorx : m_actor_manager.GetLocalActors())
    {
        if (actorx->isTied() && std::find(actor->ar_linked_actors.begin(), actor->ar_linked_actors.end(), actorx) != actor->ar_linked_actors.end())
        {
            actorx->tieToggle(); // OK to invoke here - processing MSG_SIM_DELETE_ACTOR_REQUESTED
        }
 
        if (actorx->isLocked() && std::find(actor->ar_linked_actors.begin(), actor->ar_linked_actors.end(), actorx) != actor->ar_linked_actors.end())
        {
            actorx->hookToggle(); // OK to invoke here - processing MSG_SIM_DELETE_ACTOR_REQUESTED
        }
    }
 
    App::GetGfxScene()->RemoveGfxActor(actor->GetGfxActor());
 
#ifdef USE_SOCKETW
    if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
    {
        m_character_factory.UndoRemoteActorCoupling(actor);
    }
#endif //SOCKETW
 
    TRIGGER_EVENT_ASYNC(SE_GENERIC_DELETED_TRUCK, actor->ar_instance_id);
 
    m_actor_manager.DeleteActorInternal(actor);
}
 
void GameContext::ChangePlayerActor(ActorPtr actor)
{
    ActorPtr prev_player_actor = m_player_actor;
    m_player_actor = actor;
 
    // hide any old dashes
    if (prev_player_actor && prev_player_actor->ar_dashboard)
    {
        prev_player_actor->ar_dashboard->setVisible3d(false);
    }
    // show new
    if (m_player_actor && m_player_actor->ar_dashboard)
    {
        m_player_actor->ar_dashboard->setVisible3d(true);
    }
 
    if (prev_player_actor)
    {
        App::GetOverlayWrapper()->showDashboardOverlays(false, prev_player_actor);
 
        SOUND_STOP(prev_player_actor, SS_TRIG_AIR);
        SOUND_STOP(prev_player_actor, SS_TRIG_PUMP);
    }
 
    if (m_player_actor == nullptr)
    {
        // getting outside
 
        if (prev_player_actor)
        {
            if (prev_player_actor->GetGfxActor()->GetVideoCamState() == VideoCamState::VCSTATE_ENABLED_ONLINE)
            {
                prev_player_actor->GetGfxActor()->SetVideoCamState(VideoCamState::VCSTATE_ENABLED_OFFLINE);
            }
 
            prev_player_actor->prepareInside(false);
 
            // get player out of the vehicle
            float h = prev_player_actor->getMinCameraRadius();
            float rotation = prev_player_actor->getRotation() - Ogre::Math::HALF_PI;
            Ogre::Vector3 position = prev_player_actor->getPosition();
            if (prev_player_actor->ar_cinecam_node[0] != NODENUM_INVALID)
            {
                // actor has a cinecam (find optimal exit position)
                Ogre::Vector3 l = position - 2.0f * prev_player_actor->GetCameraRoll();
                Ogre::Vector3 r = position + 2.0f * prev_player_actor->GetCameraRoll();
                float l_h = m_terrain->GetCollisions()->getSurfaceHeightBelow(l.x, l.z, l.y + h);
                float r_h = m_terrain->GetCollisions()->getSurfaceHeightBelow(r.x, r.z, r.y + h);
                position  = std::abs(r.y - r_h) * 1.2f < std::abs(l.y - l_h) ? r : l;
            }
            position.y = m_terrain->GetCollisions()->getSurfaceHeightBelow(position.x, position.z, position.y + h);
 
            Character* player_character = this->GetPlayerCharacter();
            if (player_character)
            {
                player_character->SetActorCoupling(false, nullptr);
                player_character->setRotation(Ogre::Radian(rotation));
                player_character->setPosition(position);
            }
        }
 
        App::GetAppContext()->GetForceFeedback().SetEnabled(false);
 
        TRIGGER_EVENT_ASYNC(SE_TRUCK_EXIT, prev_player_actor?prev_player_actor->ar_instance_id:-1);
    }
    else
    {
        // getting inside
        App::GetOverlayWrapper()->showDashboardOverlays(
            !App::GetGuiManager()->IsGuiHidden(), m_player_actor);
 
        if (m_player_actor->GetGfxActor()->GetVideoCamState() == VideoCamState::VCSTATE_ENABLED_OFFLINE)
        {
            m_player_actor->GetGfxActor()->SetVideoCamState(VideoCamState::VCSTATE_ENABLED_ONLINE);
        }
 
        // force feedback
        App::GetAppContext()->GetForceFeedback().SetEnabled(m_player_actor->ar_driveable == TRUCK); //only for trucks so far
 
        // attach player to vehicle
        Character* player_character = this->GetPlayerCharacter();
        if (player_character)
        {
            player_character->SetActorCoupling(true, m_player_actor);
        }
 
        App::GetGuiManager()->FlexbodyDebug.AnalyzeFlexbodies();
 
        TRIGGER_EVENT_ASYNC(SE_TRUCK_ENTER, m_player_actor?m_player_actor->ar_instance_id:-1);
    }
 
    if (prev_player_actor != nullptr || m_player_actor != nullptr)
    {
        App::GetCameraManager()->NotifyVehicleChanged(m_player_actor);
    }
 
    m_actor_manager.UpdateSleepingState(m_player_actor, 0.f);
}
 
const ActorPtr& GameContext::FetchPrevVehicleOnList()
{
    return m_actor_manager.FetchPreviousVehicleOnList(m_player_actor, m_prev_player_actor);
}
 
const ActorPtr& GameContext::FetchNextVehicleOnList()
{
    return m_actor_manager.FetchNextVehicleOnList(m_player_actor, m_prev_player_actor);
}
 
void GameContext::UpdateActors()
{
    m_actor_manager.UpdateActors(m_player_actor);
}
 
ActorPtr GameContext::FindActorByCollisionBox(std::string const & ev_src_instance_name, std::string const & box_name)
{
    return m_actor_manager.FindActorInsideBox(m_terrain->GetCollisions(),
                                              ev_src_instance_name, box_name);
}
 
void GameContext::RespawnLastActor()
{
    if (m_last_cache_selection != nullptr)
    {
        ActorSpawnRequest* rq = new ActorSpawnRequest;
        rq->asr_cache_entry     = m_last_cache_selection;
        rq->asr_config          = m_last_section_config;
        rq->asr_skin_entry      = m_last_skin_selection;
        rq->asr_origin          = ActorSpawnRequest::Origin::USER;
        this->PushMessage(Message(MSG_SIM_SPAWN_ACTOR_REQUESTED, (void*)rq));
    }
}
 
void GameContext::SpawnPreselectedActor(std::string const& preset_vehicle, std::string const& preset_veh_config)
{
    CacheEntryPtr entry = App::GetCacheSystem()->FindEntryByFilename(
        LT_AllBeam, /*partial=*/true, preset_vehicle);
 
    if (!entry)
        return;
 
    ActorSpawnRequest* rq = new ActorSpawnRequest;
    rq->asr_cache_entry = entry;
    rq->asr_position    = this->GetPlayerCharacter()->getPosition();
    rq->asr_rotation    = Ogre::Quaternion(Ogre::Degree(180) - this->GetPlayerCharacter()->getRotation(), Ogre::Vector3::UNIT_Y);
    rq->asr_origin      = ActorSpawnRequest::Origin::CONFIG_FILE;
 
    RoR::LogFormat("[RoR|Diag] Preselected Truck: %s (%s)", entry->dname.c_str(), entry->fname.c_str());
 
    // Section config lookup
    if (!entry->sectionconfigs.empty())
    {
        if (std::find(entry->sectionconfigs.begin(), entry->sectionconfigs.end(),
                      preset_veh_config)
            == entry->sectionconfigs.end())
        {
            // Preselected config doesn't exist -> use first available one
            rq->asr_config = entry->sectionconfigs[0];
        }
        else
        {
            rq->asr_config = preset_veh_config;
        }
        RoR::LogFormat("[RoR|Diag] Preselected Truck Config: %s", rq->asr_config.c_str());
    }
 
    this->PushMessage(Message(MSG_SIM_SPAWN_ACTOR_REQUESTED, (void*)rq));
}
 
void GameContext::ShowLoaderGUI(int type, const Ogre::String& instance, const Ogre::String& box)
{
    // first, test if the place if clear, BUT NOT IN MULTIPLAYER
    if (!(App::mp_state->getEnum<MpState>() == MpState::CONNECTED))
    {
        collision_box_t* spawnbox = m_terrain->GetCollisions()->getBox(instance, box);
        for (ActorPtr& actor : this->GetActorManager()->GetActors())
        {
            for (int i = 0; i < actor->ar_num_nodes; i++)
            {
                if (m_terrain->GetCollisions()->isInside(actor->ar_nodes[i].AbsPosition, spawnbox))
                {
                    App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE, _L("Please clear the place first"), "error.png");
                    return;
                }
            }
        }
    }
 
    m_current_selection.asr_position = m_terrain->GetCollisions()->getPosition(instance, box);
    m_current_selection.asr_rotation = m_terrain->GetCollisions()->getDirection(instance, box);
    m_current_selection.asr_spawnbox = m_terrain->GetCollisions()->getBox(instance, box);
 
    RoR::Message m(MSG_GUI_OPEN_SELECTOR_REQUESTED);
    m.payload = reinterpret_cast<void*>(new LoaderType(LoaderType(type)));
    App::GetGameContext()->PushMessage(m);
}
 
void GameContext::OnLoaderGuiCancel()
{
    m_current_selection = ActorSpawnRequest(); // Reset
 
    if (App::GetGuiManager()->TopMenubar.ai_select)
    {
        App::GetGuiManager()->TopMenubar.ai_select = false;
        App::GetGuiManager()->TopMenubar.ai_menu = true;
    }
    if (App::GetGuiManager()->TopMenubar.ai_select2)
    {
        App::GetGuiManager()->TopMenubar.ai_select2 = false;
        App::GetGuiManager()->TopMenubar.ai_menu = true;
    }
}
 
void GameContext::OnLoaderGuiApply(LoaderType type, CacheEntryPtr entry, std::string sectionconfig)
{
    bool spawn_now = false;
    switch (type)
    {
    case LT_AddonPart:
        if (m_player_actor)
        {
            ModifyProjectRequest* req = new ModifyProjectRequest();
            req->mpr_type = ModifyProjectRequestType::TUNEUP_USE_ADDONPART_SET;
            req->mpr_subject = entry->fname;
            req->mpr_target_actor = m_player_actor;
            App::GetGameContext()->PushMessage(Message(MSG_EDI_MODIFY_PROJECT_REQUESTED, req));
        }
        break;
 
    case LT_Skin:
        if (entry != m_dummy_cache_selection)
        {
            m_current_selection.asr_skin_entry = entry;
            if (App::GetGuiManager()->TopMenubar.ai_select)
            {
                App::GetGuiManager()->TopMenubar.ai_skin = entry->dname;
            }
            if (App::GetGuiManager()->TopMenubar.ai_select2)
            {
                App::GetGuiManager()->TopMenubar.ai_skin2 = entry->dname;
            }
        }
        spawn_now = true;
        break;
 
    case LT_Vehicle:
    case LT_Truck:
    case LT_Car:
    case LT_Boat:
    case LT_Airplane:
    case LT_Trailer:
    case LT_Train:
    case LT_Load:
    case LT_Extension:
    case LT_AllBeam:
        m_current_selection.asr_cache_entry = entry;
        m_current_selection.asr_config = sectionconfig;
        if (App::GetGuiManager()->TopMenubar.ai_select)
        {
            App::GetGuiManager()->TopMenubar.ai_sectionconfig = sectionconfig;
        }
        if (App::GetGuiManager()->TopMenubar.ai_select2)
        {
            App::GetGuiManager()->TopMenubar.ai_sectionconfig2 = sectionconfig;
        }
        m_current_selection.asr_origin = ActorSpawnRequest::Origin::USER;
        // Look for extra skins
        if (!entry->guid.empty())
        {
            CacheQuery skin_query;
            skin_query.cqy_filter_guid = entry->guid;
            skin_query.cqy_filter_type = LT_Skin;
            size_t num_skins = App::GetCacheSystem()->Query(skin_query);
            // Determine default skin
            CacheEntryPtr default_skin_entry = nullptr;
            if (entry->default_skin != "")
            {
                for (CacheQueryResult& res : skin_query.cqy_results)
                {
                    if (res.cqr_entry->dname == entry->default_skin)
                        default_skin_entry = res.cqr_entry;
                }
                if (!default_skin_entry)
                {
                    App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_ACTOR, Console::CONSOLE_SYSTEM_WARNING,
                        fmt::format(_L("Default skin '{}' for actor '{}' not found!"), entry->default_skin, entry->dname));
                }
                if (default_skin_entry && num_skins == 1)
                {
                    m_current_selection.asr_skin_entry = default_skin_entry;
                }
            }
            else
            {
                default_skin_entry = m_dummy_cache_selection;
                default_skin_entry->dname = "Default skin";
                default_skin_entry->description = "Original, unmodified skin";
            }
 
            if (!m_current_selection.asr_skin_entry && num_skins > 0)
            {
                App::GetGuiManager()->MainSelector.Show(LT_Skin, entry->guid, default_skin_entry); // Intentionally not using MSG_
            }
            else
            {
                spawn_now = true;
            }
        }
        else
        {
            spawn_now = true;
        }
        break;
 
    default:;
    }
 
    if (spawn_now)
    {
        if (App::GetGuiManager()->TopMenubar.ai_select)
        {
            App::GetGuiManager()->TopMenubar.ai_fname = m_current_selection.asr_cache_entry->fname;
            App::GetGuiManager()->TopMenubar.ai_dname = m_current_selection.asr_cache_entry->dname;
            App::GetGuiManager()->TopMenubar.ai_select = false;
            App::GetGuiManager()->TopMenubar.ai_menu = true;
        }
        else if (App::GetGuiManager()->TopMenubar.ai_select2)
        {
            App::GetGuiManager()->TopMenubar.ai_fname2 = m_current_selection.asr_cache_entry->fname;
            App::GetGuiManager()->TopMenubar.ai_dname2 = m_current_selection.asr_cache_entry->dname;
            App::GetGuiManager()->TopMenubar.ai_select2 = false;
            App::GetGuiManager()->TopMenubar.ai_menu = true;
        }
        else
        {
            ActorSpawnRequest* rq = new ActorSpawnRequest;
            *rq = m_current_selection;
            this->PushMessage(Message(MSG_SIM_SPAWN_ACTOR_REQUESTED, (void*)rq));
        }
 
        m_current_selection = ActorSpawnRequest(); // Reset
    }
}
 
void GameContext::SetPrevPlayerActor(ActorPtr actor) { m_prev_player_actor = actor; }
 
// --------------------------------
// Characters
 
void GameContext::CreatePlayerCharacter()
{
    m_character_factory.CreateLocalCharacter();
 
    // Adjust character position and rotation
    Ogre::Vector3 spawn_pos = m_terrain->getSpawnPos();
    Ogre::Degree spawn_rot(0.f);
 
    if (m_terrain->GetDef()->start_rotation_specified)
    {
        spawn_rot = m_terrain->GetDef()->start_rotation;
    }
    else if (!m_terrain->HasPredefinedActors())
    {
        // Classic behavior, retained for compatibility.
        // Required for maps like N-Labs or F1 Track.
        spawn_rot = 180.0f;
    }
 
    // Preset position - commandline has precedence
    if (App::cli_preset_spawn_pos->getStr() != "")
    {
        spawn_pos = Ogre::StringConverter::parseVector3(App::cli_preset_spawn_pos->getStr(), spawn_pos);
        App::cli_preset_spawn_pos->setStr("");
    }
    else if (App::diag_preset_spawn_pos->getStr() != "")
    {
        spawn_pos = Ogre::StringConverter::parseVector3(App::diag_preset_spawn_pos->getStr(), spawn_pos);
        App::diag_preset_spawn_pos->setStr("");
    }
 
    // Preset rotation - commandline has precedence
    if (App::cli_preset_spawn_rot->getStr() != "")
    {
        spawn_rot = Ogre::StringConverter::parseReal(App::cli_preset_spawn_rot->getStr(), spawn_rot.valueDegrees());
        App::cli_preset_spawn_rot->setStr("");
    }
    else if (App::diag_preset_spawn_rot->getStr() != "")
    {
        spawn_rot = Ogre::StringConverter::parseReal(App::diag_preset_spawn_rot->getStr(), spawn_rot.valueDegrees());
        App::diag_preset_spawn_rot->setStr("");
    }
 
    spawn_pos.y = m_terrain->GetCollisions()->getSurfaceHeightBelow(spawn_pos.x, spawn_pos.z, spawn_pos.y + 1.8f);
 
    this->GetPlayerCharacter()->setPosition(spawn_pos);
    this->GetPlayerCharacter()->setRotation(spawn_rot);
 
    App::GetCameraManager()->GetCameraNode()->setPosition(this->GetPlayerCharacter()->getPosition());
 
    // Small hack to improve the spawn experience
    for (int i = 0; i < 100; i++)
    {
        App::GetCameraManager()->UpdateInputEvents(0.02f);
    }
}
 
Character* GameContext::GetPlayerCharacter() // Convenience ~ counterpart of `GetPlayerActor()`
{
    return m_character_factory.GetLocalCharacter();
}
 
// --------------------------------
// Gameplay feats
 
void GameContext::TeleportPlayer(float x, float z)
{
    float y = m_terrain->GetCollisions()->getSurfaceHeight(x, z);
    if (!this->GetPlayerActor())
    {
        this->GetPlayerCharacter()->setPosition(Ogre::Vector3(x, y, z));
        return;
    }
 
    TRIGGER_EVENT_ASYNC(SE_TRUCK_TELEPORT, this->GetPlayerActor()->ar_instance_id);
 
    Ogre::Vector3 translation = Ogre::Vector3(x, y, z) - this->GetPlayerActor()->ar_nodes[0].AbsPosition;
 
    std::vector<ActorPtr> actorsToBeamUp;
    actorsToBeamUp.assign(this->GetPlayerActor()->ar_linked_actors.begin(), this->GetPlayerActor()->ar_linked_actors.end());
    actorsToBeamUp.push_back(this->GetPlayerActor());
 
    float src_agl = std::numeric_limits<float>::max(); 
    float dst_agl = std::numeric_limits<float>::max(); 
    for (ActorPtr& actor : actorsToBeamUp)
    {
        for (int i = 0; i < actor->ar_num_nodes; i++)
        {
            Ogre::Vector3 pos = actor->ar_nodes[i].AbsPosition;
            src_agl = std::min(pos.y - m_terrain->GetCollisions()->getSurfaceHeight(pos.x, pos.z), src_agl);
            pos += translation;
            dst_agl = std::min(pos.y - m_terrain->GetCollisions()->getSurfaceHeight(pos.x, pos.z), dst_agl);
        }
    }
 
    translation += Ogre::Vector3::UNIT_Y * (std::max(0.0f, src_agl) - dst_agl);
 
    for (ActorPtr& actor : actorsToBeamUp)
    {
        actor->resetPosition(actor->ar_nodes[0].AbsPosition + translation, false);
    }
}
 
void GameContext::UpdateGlobalInputEvents()
{
    // Generic escape key event
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_QUIT_GAME))
    {
        if (App::app_state->getEnum<AppState>() == AppState::MAIN_MENU)
        {
            if (App::GetGuiManager()->GameAbout.IsVisible())
            {
                App::GetGuiManager()->GameAbout.SetVisible(false);
            }
            else if (App::GetGuiManager()->MainSelector.IsVisible())
            {
                App::GetGuiManager()->MainSelector.Close();
            }
            else if (App::GetGuiManager()->GameSettings.IsVisible())
            {
                App::GetGuiManager()->GameSettings.SetVisible(false);
            }
            else if (App::GetGuiManager()->GameControls.IsVisible())
            {
                App::GetGuiManager()->GameControls.SetVisible(false);
            }
            else if (App::GetGuiManager()->MultiplayerSelector.IsVisible())
            {
                App::GetGuiManager()->MultiplayerSelector.SetVisible(false);
            }
            else if (App::GetGuiManager()->RepositorySelector.IsVisible())
            {
                App::GetGuiManager()->RepositorySelector.SetVisible(false);
            }
            else
            {
                this->PushMessage(Message(MSG_APP_SHUTDOWN_REQUESTED));
            }
        }
        else if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
        {
            if (App::GetGuiManager()->MainSelector.IsVisible())
            {
                App::GetGuiManager()->MainSelector.Close();
            }
            else if (App::GetGuiManager()->GameControls.IsVisible())
            {
                App::GetGuiManager()->GameControls.SetVisible(false);
            }
            else if (App::sim_state->getEnum<SimState>() == SimState::RUNNING)
            {
                this->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
                if (App::mp_state->getEnum<MpState>() != MpState::CONNECTED)
                {
                    this->PushMessage(Message(MSG_SIM_PAUSE_REQUESTED));
                }
            }
            else if (App::sim_state->getEnum<SimState>() == SimState::PAUSED)
            {
                this->PushMessage(Message(MSG_SIM_UNPAUSE_REQUESTED));
                this->PushMessage(Message(MSG_GUI_CLOSE_MENU_REQUESTED));
            }
        }
    }
 
    // screenshot
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_SCREENSHOT, 0.25f))
    {
        this->PushMessage(Message(MSG_APP_SCREENSHOT_REQUESTED));
    }
 
    // fullscreen toggle
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_FULLSCREEN_TOGGLE, 2.0f))
    {   
        if (App::GetAppContext()->GetRenderWindow()->isFullScreen())
            this->PushMessage(Message(MSG_APP_DISPLAY_WINDOWED_REQUESTED));
        else
            this->PushMessage(Message(MSG_APP_DISPLAY_FULLSCREEN_REQUESTED));
    }
 
    // render mode
    switch (App::gfx_polygon_mode->getEnum<Ogre::PolygonMode>())
    {
    case 1: App::GetCameraManager()->GetCamera()->setPolygonMode(Ogre::PM_SOLID);       break;
    case 2: App::GetCameraManager()->GetCamera()->setPolygonMode(Ogre::PM_WIREFRAME);   break;
    case 3: App::GetCameraManager()->GetCamera()->setPolygonMode(Ogre::PM_POINTS);      break;
    }
 
    // Write player position to log
    if (App::app_state->getEnum<AppState>() == AppState::SIMULATION &&
        App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_OUTPUT_POSITION))
    {
        Ogre::Vector3 position(Ogre::Vector3::ZERO);
        Ogre::Radian rotation(0);
        if (this->GetPlayerActor() == nullptr)
        {
            position = this->GetPlayerCharacter()->getPosition();
            rotation = this->GetPlayerCharacter()->getRotation() + Ogre::Radian(Ogre::Math::PI);
        }
        else
        {
            position = this->GetPlayerActor()->getPosition();
            rotation = this->GetPlayerActor()->getRotation();
        }
        Ogre::String pos = Ogre::StringUtil::format("%8.3f, %8.3f, %8.3f"   , position.x, position.y, position.z);
        Ogre::String rot = Ogre::StringUtil::format("% 6.1f, % 6.1f, % 6.1f",       0.0f, rotation.valueDegrees()  ,       0.0f);
        LOG("Position: " + pos + ", " + rot);
    }
 
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_TOGGLE_RESET_MODE))
    {
        App::sim_soft_reset_mode->setVal(!App::sim_soft_reset_mode->getBool());
        App::GetConsole()->putMessage(
            Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
            (App::sim_soft_reset_mode->getBool()) ? _L("Enabled soft reset mode") : _L("Enabled hard reset mode"));
    }
}
 
void GameContext::UpdateSimInputEvents(float dt)
{
    // get new vehicle
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_GET_NEW_VEHICLE))
    {
        RoR::Message m(MSG_GUI_OPEN_SELECTOR_REQUESTED);
        m.payload = reinterpret_cast<void*>(new LoaderType(LT_AllBeam));
        App::GetGameContext()->PushMessage(m);
    }
 
    // Enter/exit truck - With a toggle delay
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_ENTER_OR_EXIT_TRUCK, 0.5f))
    {
        if (this->GetPlayerActor() == nullptr) // no vehicle
        {
            // find the nearest vehicle
            float mindist = 1000.0;
            ActorPtr nearest_actor = nullptr;
            for (ActorPtr& actor : this->GetActorManager()->GetActors())
            {
                if (!actor->ar_driveable)
                    continue;
                if (actor->ar_cinecam_node[0] == NODENUM_INVALID)
                {
                    LOG("cinecam missing, cannot enter the actor!");
                    continue;
                }
                float len = 0.0f;
                if (this->GetPlayerCharacter())
                {
                    len = actor->ar_nodes[actor->ar_cinecam_node[0]].AbsPosition.distance(this->GetPlayerCharacter()->getPosition() + Ogre::Vector3(0.0, 2.0, 0.0));
                }
                if (len < mindist)
                {
                    mindist = len;
                    nearest_actor = actor;
                }
            }
 
            if (mindist < 20.0)
            {
                this->PushMessage(Message(MSG_SIM_SEAT_PLAYER_REQUESTED, static_cast<void*>(new ActorPtr(nearest_actor))));
            }
        }
        else // We're in a vehicle -> If moving slowly enough, get out
        {
            if (this->GetPlayerActor()->ar_nodes[0].Velocity.squaredLength() < 1.0f ||
                this->GetPlayerActor()->ar_state == ActorState::NETWORKED_OK || this->GetPlayerActor()->ar_state == ActorState::NETWORKED_HIDDEN ||
                this->GetPlayerActor()->ar_driveable == AI)
            {
                this->PushMessage(Message(MSG_SIM_SEAT_PLAYER_REQUESTED, static_cast<void*>(new ActorPtr())));
            }
        }
    }
 
    // enter next truck
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_ENTER_NEXT_TRUCK, 0.25f))
    {
        ActorPtr actor = this->FetchNextVehicleOnList();
        if (actor != this->GetPlayerActor())
        {
            this->PushMessage(Message(MSG_SIM_SEAT_PLAYER_REQUESTED, static_cast<void*>(new ActorPtr(actor))));
        }
    }
 
    // enter previous truck
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_ENTER_PREVIOUS_TRUCK, 0.25f))
    {
        ActorPtr actor = this->FetchPrevVehicleOnList();
        if (actor != this->GetPlayerActor())
        {
            this->PushMessage(Message(MSG_SIM_SEAT_PLAYER_REQUESTED, static_cast<void*>(new ActorPtr(actor))));
        }
    }
 
    // respawn last truck
    if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_RESPAWN_LAST_TRUCK, 0.25f))
    {
        this->RespawnLastActor();
    }
 
    // terrain editor toggle
    if (!App::GetGameContext()->GetPlayerActor() && App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_TOGGLE_TERRAIN_EDITOR))
    {
        App::GetGameContext()->PushMessage(MSG_EDI_ENTER_TERRN_EDITOR_REQUESTED);
    }
 
    // forward commands from character
    ActorPtr actor_to_reset_commandkeys;
    if (!m_player_actor)
    {
        // Find nearest actor
        const Ogre::Vector3 position = App::GetGameContext()->GetPlayerCharacter()->getPosition();
        ActorPtr nearest_actor = nullptr;
        float min_squared_distance = std::numeric_limits<float>::max();
        for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
        {
            float squared_distance = position.squaredDistance(actor->ar_nodes[0].AbsPosition);
            if (squared_distance < min_squared_distance)
            {
                min_squared_distance = squared_distance;
                nearest_actor = actor;
            }
        }
 
        // Evaluate
        if (nearest_actor != nullptr &&
            nearest_actor->ar_import_commands &&
            min_squared_distance < (nearest_actor->getMinCameraRadius()*nearest_actor->getMinCameraRadius()))
        {
            if (nearest_actor != m_actor_remotely_receiving_commands)
            {
                actor_to_reset_commandkeys = m_actor_remotely_receiving_commands;
            }
            m_actor_remotely_receiving_commands = nearest_actor;
 
            // get commands
            for (int i = 1; i <= MAX_COMMANDS; i++) // BEWARE: commandkeys are indexed 1-MAX_COMMANDS!
            {
                int eventID = EV_COMMANDS_01 + (i - 1);
 
                const float eventVal = RoR::App::GetInputEngine()->getEventValue(eventID);
                if (eventVal != nearest_actor->ar_command_key[i].playerInputValue
                    && nearest_actor->ar_state == ActorState::LOCAL_SLEEPING)
                {
                    // Wake up
                    nearest_actor->ar_state = ActorState::LOCAL_SIMULATED;
                    nearest_actor->ar_sleep_counter = 0.0f;
                }
 
                nearest_actor->ar_command_key[i].playerInputValue = eventVal;
            }
        }
        else
        {
            if (m_actor_remotely_receiving_commands)
            {
                // Just left the vicinity of the actor, but still on foot
                actor_to_reset_commandkeys = m_actor_remotely_receiving_commands;
                m_actor_remotely_receiving_commands = nullptr;
            }
        }
    }
    else if (m_actor_remotely_receiving_commands)
    {
        // Just left the vicinity of the actor by entering vehicle
        actor_to_reset_commandkeys = m_actor_remotely_receiving_commands;
        m_actor_remotely_receiving_commands = nullptr;
    }
 
    if (actor_to_reset_commandkeys)
    {
        for (int i = 1; i <= MAX_COMMANDS; i++) // BEWARE: commandkeys are indexed 1-MAX_COMMANDS!
        {
            actor_to_reset_commandkeys->ar_command_key[i].playerInputValue = 0.f;
        }
        actor_to_reset_commandkeys = nullptr;
    }
 
    // AI waypoint recording
    if (App::GetGuiManager()->TopMenubar.ai_rec)
    {
        if (m_timer.getMilliseconds() > 1000) // Don't spam it, record every 1 sec
        {
            if (App::GetGameContext()->GetPlayerActor()) // We are in vehicle
            {
                if (App::GetGameContext()->GetPlayerActor()->getPosition().distance(prev_pos) >= 5) // Skip very close positions
                {
                    ai_events waypoint;
                    waypoint.position = App::GetGameContext()->GetPlayerActor()->getPosition();
                    waypoint.speed = App::GetGameContext()->GetPlayerActor()->getWheelSpeed() * 3.6;
                    if (waypoint.speed < 5)
                    {
                        waypoint.speed = -1;
                    }
                    App::GetGuiManager()->TopMenubar.ai_waypoints.push_back(waypoint);
                }
                prev_pos = App::GetGameContext()->GetPlayerActor()->getPosition();
            }
            else // We are in feet
            {
                if (App::GetGameContext()->GetPlayerCharacter()->getPosition() != prev_pos) // Skip same positions
                {
                    ai_events waypoint;
                    waypoint.position = App::GetGameContext()->GetPlayerCharacter()->getPosition();
                    App::GetGuiManager()->TopMenubar.ai_waypoints.push_back(waypoint);
                }
                prev_pos = App::GetGameContext()->GetPlayerCharacter()->getPosition();
            }
            m_timer.reset();
        }
    }
    else
    {
        prev_pos = Ogre::Vector3::ZERO;
    }
}
 
void GameContext::UpdateSkyInputEvents(float dt)
{
#ifdef USE_CAELUM
    if (App::gfx_sky_mode->getEnum<GfxSkyMode>() == GfxSkyMode::CAELUM &&
        m_terrain->getSkyManager())
    {
        float time_factor = 1.0f;
 
        if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_INCREASE_TIME))
        {
            time_factor = 1000.0f;
        }
        else if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_INCREASE_TIME_FAST))
        {
            time_factor = 10000.0f;
        }
        else if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_DECREASE_TIME))
        {
            time_factor = -1000.0f;
        }
        else if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_DECREASE_TIME_FAST))
        {
            time_factor = -10000.0f;
        }
        else if (App::gfx_sky_time_cycle->getBool())
        {
            time_factor = App::gfx_sky_time_speed->getInt();
        }
 
        if (m_terrain->getSkyManager()->GetSkyTimeFactor() != time_factor)
        {
            m_terrain->getSkyManager()->SetSkyTimeFactor(time_factor);
            Str<200> msg; msg << _L("Time set to ") << m_terrain->getSkyManager()->GetPrettyTime();
            RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE, msg.ToCStr());
        }
    }
 
#endif // USE_CAELUM
    if (App::gfx_sky_mode->getEnum<GfxSkyMode>() == GfxSkyMode::SKYX &&
        m_terrain->getSkyXManager())
    {
        if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_INCREASE_TIME))
        {
            m_terrain->getSkyXManager()->GetSkyX()->setTimeMultiplier(1.0f);
        }
        else if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_INCREASE_TIME_FAST))
        {
            m_terrain->getSkyXManager()->GetSkyX()->setTimeMultiplier(2.0f);
        }
        else if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_DECREASE_TIME))
        {
            m_terrain->getSkyXManager()->GetSkyX()->setTimeMultiplier(-1.0f);
        }
        else if (RoR::App::GetInputEngine()->getEventBoolValue(EV_SKY_DECREASE_TIME_FAST))
        {
            m_terrain->getSkyXManager()->GetSkyX()->setTimeMultiplier(-2.0f);
        }
        else
        {
            m_terrain->getSkyXManager()->GetSkyX()->setTimeMultiplier(0.01f);
        }
    }
}
 
void GameContext::UpdateCommonInputEvents(float dt, ActorPtr actor)
{
    ROR_ASSERT(actor);
 
    // reload current truck
    if (actor->getEventBoolValueBounce(EV_TRUCKEDIT_RELOAD, 0.5f))
    {
        ActorModifyRequest* rq = new ActorModifyRequest;
        rq->amr_type = ActorModifyRequest::Type::RELOAD;
        rq->amr_actor = actor->ar_instance_id;
        this->PushMessage(Message(MSG_SIM_MODIFY_ACTOR_REQUESTED, (void*)rq));
    }
 
    // remove current truck
    if (actor->getEventBoolValue(EV_COMMON_REMOVE_CURRENT_TRUCK))
    {
        App::GetGameContext()->PushMessage(Message(MSG_SIM_DELETE_ACTOR_REQUESTED, static_cast<void*>(new ActorPtr(m_player_actor))));
    }
 
    // Front lights
    if (actor->getEventBoolValueBounce(EV_COMMON_TOGGLE_TRUCK_LOW_BEAMS))
    {
        actor->setHeadlightsVisible(!actor->getHeadlightsVisible());
        // sync sidelights to lowbeams
        actor->setSideLightsVisible(actor->getHeadlightsVisible());
    }
    if (actor->getEventBoolValueBounce(EV_COMMON_CYCLE_TRUCK_LIGHTS))
    {
        // Smart cycling:
        //  1) all lights off
        //  2) sidelights on but only if any installed, otherwise skip to 3).
        //  3) sidelights and lowbeams on.
        //  4) sidelights, lowbeams and highbeams on, but only if highbeams are installed, otherwise cycle to 1).
        if (actor->countFlaresByType(FlareType::SIDELIGHT) > 0 && !actor->getSideLightsVisible())
        {
            actor->setSideLightsVisible(true);
        }
        else if (!actor->getHeadlightsVisible())
        {
            actor->setSideLightsVisible(true);
            actor->setHeadlightsVisible(true);
        }
        else if (actor->countFlaresByType(FlareType::HIGH_BEAM) > 0 && !actor->getHighBeamsVisible())
        {
            actor->setSideLightsVisible(true);
            actor->setHeadlightsVisible(true);
            actor->setHighBeamsVisible(true);
        }
        else
        {
            actor->setSideLightsVisible(false);
            actor->setHeadlightsVisible(false);
            actor->setHighBeamsVisible(false);
        }
    }
    if (actor->getEventBoolValueBounce(EV_COMMON_TOGGLE_TRUCK_HIGH_BEAMS))
    {
        actor->setHighBeamsVisible(!actor->getHighBeamsVisible());
    }
    if (actor->getEventBoolValueBounce(EV_COMMON_TOGGLE_TRUCK_FOG_LIGHTS))
    {
        actor->setFogLightsVisible(!actor->getFogLightsVisible());
    }
 
    // Beacons
    if (actor->getEventBoolValueBounce(EV_COMMON_TOGGLE_TRUCK_BEACONS))
    {
        actor->beaconsToggle();
    }
 
    // blinkers
    if (actor->getEventBoolValueBounce(EV_TRUCK_BLINK_LEFT))
        actor->toggleBlinkType(BLINK_LEFT);
 
    if (actor->getEventBoolValueBounce(EV_TRUCK_BLINK_RIGHT))
        actor->toggleBlinkType(BLINK_RIGHT);
 
    if (actor->getEventBoolValueBounce(EV_TRUCK_BLINK_WARN))
        actor->toggleBlinkType(BLINK_WARN);
 
    // custom lights
    for (int i = 0; i < MAX_CLIGHTS; i++)
    {
        if (actor->getEventBoolValueBounce(EV_TRUCK_LIGHTTOGGLE01 + i))
            actor->setCustomLightVisible(i, !actor->getCustomLightVisible(i));
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_TRUCK_REMOVE))
    {
        App::GetGameContext()->PushMessage(Message(MSG_SIM_DELETE_ACTOR_REQUESTED, static_cast<void*>(new ActorPtr(m_player_actor))));
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_ROPELOCK))
    {
        actor->ar_toggle_ropes = true;
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_LOCK))
    {
        //actor->hookToggle(-1, HOOK_TOGGLE, -1);
        ActorLinkingRequest* hook_rq = new ActorLinkingRequest();
        hook_rq->alr_type = ActorLinkingRequestType::HOOK_TOGGLE;
        hook_rq->alr_actor_instance_id = actor->ar_instance_id;
        App::GetGameContext()->PushMessage(Message(MSG_SIM_ACTOR_LINKING_REQUESTED, hook_rq));
 
        //actor->toggleSlideNodeLock();
        ActorLinkingRequest* slidenode_rq = new ActorLinkingRequest();
        slidenode_rq->alr_type = ActorLinkingRequestType::SLIDENODE_TOGGLE;
        slidenode_rq->alr_actor_instance_id = actor->ar_instance_id;
        App::GetGameContext()->PushMessage(Message(MSG_SIM_ACTOR_LINKING_REQUESTED, slidenode_rq));
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_AUTOLOCK))
    {
        actor->hookToggle(-2, ActorLinkingRequestType::HOOK_UNLOCK, -1); //unlock all autolocks
    }
 
    //strap
    if (actor->getEventBoolValueBounce(EV_COMMON_SECURE_LOAD))
    {
        actor->ar_toggle_ties = true;
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_TOGGLE_CUSTOM_PARTICLES))
    {
        actor->toggleCustomParticles();
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_TOGGLE_DEBUG_VIEW))
    {
        actor->GetGfxActor()->ToggleDebugView();
        for (ActorPtr& actor : actor->ar_linked_actors)
        {
            actor->GetGfxActor()->SetDebugView(actor->GetGfxActor()->GetDebugView());
        }
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_CYCLE_DEBUG_VIEWS))
    {
        actor->GetGfxActor()->CycleDebugViews();
        for (ActorPtr& actor : actor->ar_linked_actors)
        {
            actor->GetGfxActor()->SetDebugView(actor->GetGfxActor()->GetDebugView());
        }
    }
 
    if (actor->getEventBoolValueBounce(EV_COMMON_RESCUE_TRUCK, 0.5f) &&
        App::mp_state->getEnum<MpState>() != MpState::CONNECTED &&
        actor->ar_driveable != AIRPLANE)
    {
        ActorPtr rescuer = nullptr;
        for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
        {
            if (actor->ar_rescuer_flag)
            {
                rescuer = actor;
            }
        }
        if (rescuer == nullptr)
        {
            App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE, _L("No rescue truck found!"), "error.png");
        }
        else
        {
            App::GetGameContext()->PushMessage(Message(MSG_SIM_SEAT_PLAYER_REQUESTED, static_cast<void*>(new ActorPtr(rescuer))));
        }
    }
 
    // parking brake
    if (actor->getEventBoolValueBounce(EV_TRUCK_TRAILER_PARKING_BRAKE))
    {
        if (actor->ar_driveable == TRUCK)
            actor->ar_trailer_parking_brake = !actor->ar_trailer_parking_brake;
        else if (actor->ar_driveable == NOT_DRIVEABLE)
            actor->parkingbrakeToggle();
    }
 
    // videocam
    if (actor->getEventBoolValueBounce(EV_TRUCK_TOGGLE_VIDEOCAMERA, 0.5f))
    {
        if (actor->GetGfxActor()->GetVideoCamState() == VideoCamState::VCSTATE_DISABLED)
        {
            actor->GetGfxActor()->SetVideoCamState(VideoCamState::VCSTATE_ENABLED_ONLINE);
        }
        else
        {
            actor->GetGfxActor()->SetVideoCamState(VideoCamState::VCSTATE_DISABLED);
        }
    }
 
    // enter/exit truck - Without a delay: the vehicle must brake like braking normally
    if (actor->getEventBoolValue(EV_COMMON_ENTER_OR_EXIT_TRUCK))
    {
        if (actor->ar_driveable != AI)
        {
            actor->ar_brake = 0.66f;
        }
    }
 
    // toggle physics
    if (actor->getEventBoolValueBounce(EV_TRUCK_TOGGLE_PHYSICS))
    {
        for (ActorPtr& linked_actor : actor->ar_linked_actors)
        {
            linked_actor->ar_physics_paused = !linked_actor->ar_physics_paused;
        }
        actor->ar_physics_paused = !actor->ar_physics_paused;
    }
 
    // reset truck
    if (actor->getEventBoolValue(EV_COMMON_RESET_TRUCK))
    {
        ActorModifyRequest* rq = new ActorModifyRequest;
        rq->amr_actor = App::GetGameContext()->GetPlayerActor()->ar_instance_id;
        rq->amr_type  = ActorModifyRequest::Type::RESET_ON_INIT_POS;
        App::GetGameContext()->PushMessage(Message(MSG_SIM_MODIFY_ACTOR_REQUESTED, (void*)rq));
    }
 
    // Commandkeys: process controller input for all commands
    for (int i = 1; i <= MAX_COMMANDS; i++) // BEWARE: commandkeys are indexed 1-MAX_COMMANDS!
    {
        int eventID = EV_COMMANDS_01 + (i - 1);
 
        actor->ar_command_key[i].playerInputValue = actor->getEventValue(eventID);
    }
 
    // Commandkeys: Apply command buttons in T-screen
    if (actor == m_player_actor &&
        App::GetGuiManager()->VehicleInfoTPanel.GetActiveCommandKey() != COMMANDKEYID_INVALID)
    {
        m_player_actor->ar_command_key[App::GetGuiManager()->VehicleInfoTPanel.GetActiveCommandKey()].playerInputValue = 1.f;
    }
 
    if (actor->getEventBoolValueBounce(EV_TRUCK_TOGGLE_FORWARDCOMMANDS))
    {
        actor->ar_forward_commands = !actor->ar_forward_commands;
        if (actor->ar_forward_commands)
        {
            RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE, _L("forwardcommands enabled"), "information.png");
        }
        else
        {
            RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE, _L("forwardcommands disabled"), "information.png");
        }
    }
 
    if (actor->getEventBoolValueBounce(EV_TRUCK_TOGGLE_IMPORTCOMMANDS))
    {
        actor->ar_import_commands = !actor->ar_import_commands;
        if (actor->ar_import_commands)
        {
            RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE, _L("importcommands enabled"), "information.png");
        }
        else
        {
            RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE, _L("importcommands disabled"), "information.png");
        }
    }
 
    if (actor == m_player_actor &&
        m_player_actor->getReplay())
    {
        m_player_actor->getReplay()->UpdateInputEvents();
    }
}
 
// Internal heper for UpdateAirplaneInputEvents()
void smoothValue(float& ref, float value, float rate)
{
    if (value < -1)
        value = -1;
    if (value > 1)
        value = 1;
    // smooth!
    if (ref > value)
    {
        ref -= rate;
        if (ref < value)
            ref = value;
    }
    else if (ref < value)
        ref += rate;
}
 
void GameContext::UpdateAirplaneInputEvents(float dt, ActorPtr airplane)
{
    if (airplane->isBeingReset() || airplane->ar_physics_paused)
        return;
 
    // autopilot
    if (airplane->ar_autopilot && airplane->ar_autopilot->wantsdisconnect)
    {
        airplane->ar_autopilot->disconnect();
    }
 
    float commandrate = 4.0;
 
    // steer
    float tmp_left = airplane->getEventValue(EV_AIRPLANE_STEER_LEFT);
    float tmp_right = airplane->getEventValue(EV_AIRPLANE_STEER_RIGHT);
    float sum_steer = -tmp_left + tmp_right;
    airplane->ar_hydro_speed_coupling_active = !(airplane->isEventAnalog(EV_AIRPLANE_STEER_LEFT) && airplane->isEventAnalog(EV_AIRPLANE_STEER_RIGHT));
    
    // pitch
    float tmp_pitch_up = airplane->getEventValue(EV_AIRPLANE_ELEVATOR_UP);
    float tmp_pitch_down = airplane->getEventValue(EV_AIRPLANE_ELEVATOR_DOWN);
    float sum_pitch = tmp_pitch_down - tmp_pitch_up;
    
    // rudder
    float tmp_rudder_left = airplane->getEventValue(EV_AIRPLANE_RUDDER_LEFT);
    float tmp_rudder_right = airplane->getEventValue(EV_AIRPLANE_RUDDER_RIGHT);
    float sum_rudder = tmp_rudder_left - tmp_rudder_right;
 
    // Simulated inputs at actor level shouldn't be smoothed. We'll let
    // the code that added simulated values do its own smoothing
    // if needed.
    if (airplane->hasEventSimulatedValue(EV_AIRPLANE_STEER_LEFT) &&
        airplane->hasEventSimulatedValue(EV_AIRPLANE_STEER_RIGHT))
    {
        airplane->ar_aileron = sum_steer;
    }
    else
    {
        smoothValue(airplane->ar_aileron, sum_steer, dt * commandrate);
        airplane->ar_hydro_dir_command = airplane->ar_aileron;
    }
    if (airplane->hasEventSimulatedValue(EV_AIRPLANE_ELEVATOR_UP) &&
        airplane->hasEventSimulatedValue(EV_AIRPLANE_ELEVATOR_DOWN))
    {
        airplane->ar_elevator = sum_pitch;
    }
    else
    {
        smoothValue(airplane->ar_elevator, sum_pitch, dt * commandrate);
    }
    if (airplane->hasEventSimulatedValue(EV_AIRPLANE_RUDDER_LEFT) &&
        airplane->hasEventSimulatedValue(EV_AIRPLANE_RUDDER_RIGHT))
    {
        airplane->ar_rudder = sum_rudder;
    }
    else
    {
        smoothValue(airplane->ar_rudder, sum_rudder, dt * commandrate);
    }
 
    // brakes
    if (!airplane->ar_parking_brake)
    {
        airplane->ar_brake = airplane->getEventValue(EV_AIRPLANE_BRAKE) * 0.66f;
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_PARKING_BRAKE))
    {
        airplane->parkingbrakeToggle();
    }
 
    // reverse
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_REVERSE))
    {
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->toggleReverse();
        }
    }
 
    // engines
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_TOGGLE_ENGINES))
    {
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->flipStart();
        }
    }
 
    // flaps
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_FLAPS_NONE))
    {
        if (airplane->ar_aerial_flap > 0)
        {
            airplane->ar_aerial_flap = 0;
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_FLAPS_FULL))
    {
        if (airplane->ar_aerial_flap < 5)
        {
            airplane->ar_aerial_flap = 5;
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_FLAPS_LESS))
    {
        if (airplane->ar_aerial_flap > 0)
        {
            airplane->ar_aerial_flap = (airplane->ar_aerial_flap) - 1;
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_FLAPS_MORE))
    {
        if (airplane->ar_aerial_flap < 5)
        {
            airplane->ar_aerial_flap = (airplane->ar_aerial_flap) + 1;
        }
    }
 
    // airbrakes
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_AIRBRAKES_NONE))
    {
        if (airplane->ar_airbrake_intensity > 0)
        {
            airplane->setAirbrakeIntensity(0);
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_AIRBRAKES_FULL))
    {
        if (airplane->ar_airbrake_intensity < 5)
        {
            airplane->setAirbrakeIntensity(5);
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_AIRBRAKES_LESS))
    {
        if (airplane->ar_airbrake_intensity > 0)
        {
            airplane->setAirbrakeIntensity((airplane->ar_airbrake_intensity) - 1);
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_AIRBRAKES_MORE))
    {
        if (airplane->ar_airbrake_intensity < 5)
        {
            airplane->setAirbrakeIntensity((airplane->ar_airbrake_intensity) + 1);
        }
    }
 
    // throttle
    if (airplane->isEventDefined(EV_AIRPLANE_THROTTLE_AXIS))
    {
        float f = airplane->getEventValue(EV_AIRPLANE_THROTTLE_AXIS);
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->setThrottle(f);
        }
    }
    else
    {
        float tmp_throttle = airplane->getEventBoolValue(EV_AIRPLANE_THROTTLE);
        if (tmp_throttle > 0)
        {
            for (int i = 0; i < airplane->ar_num_aeroengines; i++)
            {
                airplane->ar_aeroengines[i]->setThrottle(tmp_throttle);
            }
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_THROTTLE_DOWN, 0.1f))
    {
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->setThrottle(airplane->ar_aeroengines[i]->getThrottle() - 0.05);
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_THROTTLE_UP, 0.1f))
    {
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->setThrottle(airplane->ar_aeroengines[i]->getThrottle() + 0.05);
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_THROTTLE_NO, 0.1f))
    {
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->setThrottle(0);
        }
    }
 
    if (airplane->getEventBoolValueBounce(EV_AIRPLANE_THROTTLE_FULL, 0.1f))
    {
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->setThrottle(1);
        }
    }
 
    // autopilot
    if (airplane->ar_autopilot)
    {
        for (int i = 0; i < airplane->ar_num_aeroengines; i++)
        {
            airplane->ar_aeroengines[i]->setThrottle(airplane->ar_autopilot->getThrottle(airplane->ar_aeroengines[i]->getThrottle(), dt));
        }
    }
}
 
void GameContext::UpdateBoatInputEvents(float dt, ActorPtr boat)
{
    // throttle
    if (boat->isEventDefined(EV_BOAT_THROTTLE_AXIS))
    {
        float f = boat->getEventValue(EV_BOAT_THROTTLE_AXIS);
        // use negative values also!
        f = f * 2 - 1;
        for (int i = 0; i < boat->ar_num_screwprops; i++)
            boat->ar_screwprops[i]->setThrottle(-f);
    }
 
    if (boat->getEventBoolValueBounce(EV_BOAT_THROTTLE_DOWN, 0.1f))
    {
        for (int i = 0; i < boat->ar_num_screwprops; i++)
            boat->ar_screwprops[i]->setThrottle(boat->ar_screwprops[i]->getThrottle() - 0.05);
    }
 
    if (boat->getEventBoolValueBounce(EV_BOAT_THROTTLE_UP, 0.1f))
    {
        for (int i = 0; i < boat->ar_num_screwprops; i++)
            boat->ar_screwprops[i]->setThrottle(boat->ar_screwprops[i]->getThrottle() + 0.05);
    }
 
    // steer
    float tmp_steer_left = boat->getEventValue(EV_BOAT_STEER_LEFT);
    float tmp_steer_right = boat->getEventValue(EV_BOAT_STEER_RIGHT);
    float stime = boat->getEventBounceTime(EV_BOAT_STEER_LEFT) + boat->getEventBounceTime(EV_BOAT_STEER_RIGHT);
    float sum_steer = (tmp_steer_left - tmp_steer_right) * dt;
    // do not center the rudder!
    if (fabs(sum_steer) > 0 && stime <= 0)
    {
        for (int i = 0; i < boat->ar_num_screwprops; i++)
            boat->ar_screwprops[i]->setRudder(boat->ar_screwprops[i]->getRudder() + sum_steer);
    }
 
    if (boat->isEventDefined(EV_BOAT_STEER_LEFT_AXIS) && boat->isEventDefined(EV_BOAT_STEER_RIGHT_AXIS))
    {
        tmp_steer_left = boat->getEventValue(EV_BOAT_STEER_LEFT_AXIS);
        tmp_steer_right = boat->getEventValue(EV_BOAT_STEER_RIGHT_AXIS);
        sum_steer = (tmp_steer_left - tmp_steer_right);
        for (int i = 0; i < boat->ar_num_screwprops; i++)
            boat->ar_screwprops[i]->setRudder(sum_steer);
    }
 
    // rudder
    if (boat->getEventBoolValueBounce(EV_BOAT_CENTER_RUDDER, 0.1f))
    {
        for (int i = 0; i < boat->ar_num_screwprops; i++)
            boat->ar_screwprops[i]->setRudder(0);
    }
 
    // reverse
    if (boat->getEventBoolValueBounce(EV_BOAT_REVERSE))
    {
        for (int i = 0; i < boat->ar_num_screwprops; i++)
            boat->ar_screwprops[i]->toggleReverse();
    }
}
 
void GameContext::UpdateTruckInputEvents(float dt, ActorPtr truck)
{
    if (truck->isBeingReset() || truck->ar_physics_paused)
        return;
#ifdef USE_ANGELSCRIPT
    if (truck->ar_vehicle_ai && truck->ar_vehicle_ai->isActive())
        return;
#endif // USE_ANGELSCRIPT
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_LEFT_MIRROR_LEFT))
        truck->ar_left_mirror_angle -= 0.001;
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_LEFT_MIRROR_RIGHT))
        truck->ar_left_mirror_angle += 0.001;
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_RIGHT_MIRROR_LEFT))
        truck->ar_right_mirror_angle -= 0.001;
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_RIGHT_MIRROR_RIGHT))
        truck->ar_right_mirror_angle += 0.001;
 
    // steering
    float tmp_left_digital  = truck->getEventValue(EV_TRUCK_STEER_LEFT , false, InputSourceType::IST_DIGITAL);
    float tmp_right_digital = truck->getEventValue(EV_TRUCK_STEER_RIGHT, false, InputSourceType::IST_DIGITAL);
    float tmp_left_analog   = truck->getEventValue(EV_TRUCK_STEER_LEFT , false, InputSourceType::IST_ANALOG);
    float tmp_right_analog  = truck->getEventValue(EV_TRUCK_STEER_RIGHT, false, InputSourceType::IST_ANALOG);
 
    float sum = -std::max(tmp_left_digital, tmp_left_analog) + std::max(tmp_right_digital, tmp_right_analog);
 
    truck->ar_hydro_dir_command = Ogre::Math::Clamp(sum, -1.0f, 1.0f);
 
    truck->ar_hydro_speed_coupling_active = (tmp_left_digital >= tmp_left_analog) && (tmp_right_digital >= tmp_right_analog);
 
    if (truck->ar_engine)
    {
        truck->ar_engine->UpdateInputEvents(dt);
    }
 
    if (truck->ar_brake > 1.0f / 6.0f)
    {
        SOUND_START(truck, SS_TRIG_BRAKE);
    }
    else
    {
        SOUND_STOP(truck, SS_TRIG_BRAKE);
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_TOGGLE_INTER_AXLE_DIFF))
    {
        truck->toggleAxleDiffMode();
        truck->displayAxleDiffMode();
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_TOGGLE_INTER_WHEEL_DIFF))
    {
        truck->toggleWheelDiffMode();
        truck->displayWheelDiffMode();
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_TOGGLE_TCASE_4WD_MODE))
    {
        truck->toggleTransferCaseMode();
        truck->displayTransferCaseMode();
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_TOGGLE_TCASE_GEAR_RATIO))
    {
        truck->toggleTransferCaseGearRatio();
        truck->displayTransferCaseMode();
    }
 
    if (truck->ar_is_police)
    {
        if (truck->getEventBoolValueBounce(EV_TRUCK_HORN))
        {
            SOUND_TOGGLE(truck, SS_TRIG_HORN); // Police siren
        }
    }
    else
    {
        if (truck->getEventBoolValue(EV_TRUCK_HORN)
            || App::GetGuiManager()->VehicleInfoTPanel.IsHornButtonActive())
        {
            SOUND_START(truck, SS_TRIG_HORN);
        }
        else
        {
            SOUND_STOP(truck, SS_TRIG_HORN);
        }
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_PARKING_BRAKE) &&
        !truck->getEventBoolValue(EV_TRUCK_TRAILER_PARKING_BRAKE))
    {
        truck->parkingbrakeToggle();
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_ANTILOCK_BRAKE))
    {
        truck->antilockbrakeToggle();
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_TRACTION_CONTROL))
    {
        truck->tractioncontrolToggle();
    }
 
    if (truck->getEventBoolValueBounce(EV_TRUCK_CRUISE_CONTROL))
    {
        truck->cruisecontrolToggle();
    }
 
    if (truck->getTyrePressure().IsEnabled())
    {
        truck->getTyrePressure().UpdateInputEvents(dt);
    }
}