game.c

Go to the documentation of this file.

#ifdef BREAK_COMPILATION
    THIS DEFINE BREAKS GAME SCRIPT MODULE COMPILATION
    DO NOT REMOVE IT, IT IS NEEDED FOR VARIOUS TESTS
#endif
 
 
enum EGameFlags
{
    Metabolism = 1,
    SpawnVehicles = 2,
    SpawnAI = 4,
    Last = 4
}
 
enum EDiagMenuGame : EDiagMenuGameLib
{
}
 
class ArmaReforgerScripted : ChimeraGame
{
    const string CONFIG_CORES_PATH = "Configs/Core/";
 
    const ResourceName CONFIG_DIALOGS_ERROR = "{D3BFEE28E7D5B6A1}Configs/ServerBrowser/KickDialogs.conf";
 
    protected EGameFlags                    m_eGameFlags;
    protected bool                          m_bAreGameFlagsObtained;
    protected ref ScriptInvoker             Event_OnObtainedGameFlags = new ScriptInvoker();
    protected SCR_HUDManagerComponent       m_HUDManager;
    protected ScriptedChatEntity            m_ChatEntity;
    protected ref SCR_GameCoresManager      m_CoresManager;
    protected ref SCR_SettingsManager       m_SettingsManager;
    protected ref SCR_ProfaneFilter     m_ProfanityFilter;
    protected SCR_SaveManagerCore           m_SaveManagerCore;
    protected SCR_BuildingDestructionManagerComponent m_BuildingDestructionManager;
    protected SCR_SpawnerAIGroupManagerComponent m_SpawnerAIGroupManager;
    protected bool                          m_bHasKeyboard;
 
    protected SCR_LoadoutManager m_pLoadoutManager;
    
    protected SCR_DataCollectorComponent m_DataCollectorComponent;
    
    protected SCR_SoundManagerEntity m_SoundManagerEntity;
 
    ref ScriptInvoker m_OnMissionSetInvoker = new ScriptInvoker();
    ref RplSessionErrorHandler m_SessionErrorHandler;
 
    bool m_bIsMainMenuOpen = false;
    private bool m_bGameStarted = false;
 
    protected ref SCR_Stack<SCR_GameErrorMessage> m_aErrorStack = new SCR_Stack<SCR_GameErrorMessage>();
 
    protected ref ScriptInvoker m_OnChangeUserSettingsInvoker = new ScriptInvoker();
    protected ref ScriptInvoker m_OnInputDeviceUserChangedInvoker = new ScriptInvoker();
    protected ref ScriptInvoker m_OnInputDeviceIsGamepadInvoker = new ScriptInvoker();
    protected ref ScriptInvoker m_OnWorldSimulatePhysicsInvoker = new ScriptInvoker();
    protected ref ScriptInvoker<int, int, bool> m_OnWindowResizeInvoker = new ScriptInvoker();
    protected ref ScriptCallQueue m_Callqueue = new ScriptCallQueue();
 
    //ref SCR_RCONCommander m_dsCommander;
    
    protected ref SCR_ResourceGrid m_ResourceGrid;
    protected ref SCR_ResourceSystemSubscriptionManager m_ResourceSystemSubscriptionManager;
    
    //------------------------------------------------------------------------------------------------
    // destructor
    void ~ArmaReforgerScripted()
    {
        g_ARGame = null;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_DataCollectorComponent GetDataCollector()
    {
        return m_DataCollectorComponent;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ResourceGrid GetResourceGrid()
    {
        if (!m_ResourceGrid)
            m_ResourceGrid = new SCR_ResourceGrid();
        
        return m_ResourceGrid;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_ResourceSystemSubscriptionManager GetResourceSystemSubscriptionManager()
    {
        if (!m_ResourceSystemSubscriptionManager)
            m_ResourceSystemSubscriptionManager = new SCR_ResourceSystemSubscriptionManager();
        
        return m_ResourceSystemSubscriptionManager;
    }
 
    //------------------------------------------------------------------------------------------------
    void RegisterDataCollector(SCR_DataCollectorComponent instance)
    {
        if (m_DataCollectorComponent)
        {
            Print("Trying to register a SCR_DataCollectorComponent, but one is already registered!", LogLevel.ERROR);
            return;
        }
        
        m_DataCollectorComponent = instance;
    }
    
    //------------------------------------------------------------------------------------------------
    void UnregisterBuildingDestructionManager(notnull SCR_BuildingDestructionManagerComponent manager)
    {
        // Only set to null if it's the passed one
        if (m_BuildingDestructionManager == manager)
            m_BuildingDestructionManager = null;
    }
    
    //------------------------------------------------------------------------------------------------
    void RegisterBuildingDestructionManager(notnull SCR_BuildingDestructionManagerComponent manager)
    {
        if (m_BuildingDestructionManager)
        {
            Print("Trying to register a SCR_BuildingDestructionManagerComponent, but one is already registered!", LogLevel.ERROR);
            return;
        }
        
        m_BuildingDestructionManager = manager;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_BuildingDestructionManagerComponent GetBuildingDestructionManager()
    {
        return m_BuildingDestructionManager;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_LoadoutManager GetLoadoutManager()
    {
        return m_pLoadoutManager;
    }
    
    //------------------------------------------------------------------------------------------------
    void RegisterSoundManagerEntity(SCR_SoundManagerEntity instance)
    {
        if (m_SoundManagerEntity)
        {
            Print("Trying to register a SCR_SoundManagerEntity, but one is already registered!", LogLevel.ERROR);
            return;
        }
        
        m_SoundManagerEntity = instance;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_SoundManagerEntity GetSoundManagerEntity()
    {
        return m_SoundManagerEntity;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_SettingsManager GetSettingsManager()
    {
        if (!m_SettingsManager)
            m_SettingsManager = new SCR_SettingsManager();
        
        return m_SettingsManager;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_ProfaneFilter GetProfanityFilter()
    {
        if (!m_ProfanityFilter)
            m_ProfanityFilter = new SCR_ProfaneFilter();
        
        return m_ProfanityFilter;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_SaveManagerCore GetSaveManager()
    {
        return m_SaveManagerCore;
    }
    
    //------------------------------------------------------------------------------------------------
    bool GetHasKeyboard()
    {
        return m_bHasKeyboard;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptCallQueue GetCallqueue()
    {
        return m_Callqueue;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker OnUserSettingsChangedInvoker()
    {
        return m_OnChangeUserSettingsInvoker;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker OnInputDeviceUserChangedInvoker()
    {
        return m_OnInputDeviceUserChangedInvoker;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker OnInputDeviceIsGamepadInvoker()
    {
        return m_OnInputDeviceIsGamepadInvoker;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker OnWorldSimulatePhysicsInvoker()
    {
        return m_OnWorldSimulatePhysicsInvoker;
    }
    
    //------------------------------------------------------------------------------------------------
    ScriptInvoker OnWindowResizeInvoker()
    {
        return m_OnWindowResizeInvoker;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool GetIsClientAuthority()
    {
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void OnMissionSet(MissionHeader mission)
    {
        m_OnMissionSetInvoker.Invoke(mission);
 
        SCR_MissionHeader pHeader = SCR_MissionHeader.Cast(mission);
        if (pHeader)
            SetGameFlags(pHeader.m_eDefaultGameFlags, false);
        
        GameSessionStorage.s_Data["m_iRejoinAttempt"] = "0";
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnCinematicStart()
    {
        Print("Cinematic start");
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnCinematicEnd()
    {
        Print("Cinematic end");
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnCinematicBlending(float blendFactor, vector cameraPosition)
    {
        // This makes the player head dissolve nicely when we are transitioning from/to cinematic
        auto playerEntity = SCR_PlayerController.GetLocalControlledEntity();
        if (playerEntity)
        {
            SCR_CharacterCameraHandlerComponent camHandlerComp = SCR_CharacterCameraHandlerComponent.Cast(playerEntity.FindComponent(SCR_CharacterCameraHandlerComponent));
            if (camHandlerComp)
            {
                camHandlerComp.UpdateHeadVisibility(cameraPosition);
            }
        }
    }
    
    //------------------------------------------------------------------------------------------------
    override protected void OnKickedFromGame(KickCauseCode kickCode)
    {
        KickCauseGroup2 groupInt;
        int reasonInt;
        string group, reason;
        
        //~ Get the kick reason ID
        GetFullKickReason(kickCode, groupInt, reasonInt, group, reason);
 
        // Detail
        string format = "Kick cause code: group=%1 '%2', reason=%3 '%4'";
        string strDetail = string.Format(format , groupInt, group, reasonInt, reason);
        Print(string.Format(format, groupInt, group, reasonInt, reason), LogLevel.NORMAL);
 
        //  Set dialog tag
        string dialogTag = group + "_" + reason;
 
        // Default error
        if (group == "<unknown>")
            dialogTag = "DEFAULT_ERROR";
        else
        {
            // No specific reason in group 
            if (reason == "<unknown>")
            {
                dialogTag = group;
            }
        }
 
        // Set msg
        SCR_KickDialogs.CreateKickErrorDialog(dialogTag, group, strDetail);
        
        // Add rejoin attempt
        AddRejoinAttempt();
    }
    
    //------------------------------------------------------------------------------------------------
    bool GetFullKickReason(KickCauseCode kickCode, out KickCauseGroup2 groupInt, out int reasonInt, out string group, out string reason)
    {
        groupInt = KickCauseCodeAPI.GetGroup(kickCode);
        reasonInt = KickCauseCodeAPI.GetReason(kickCode);
        
        group = "<unknown>";
        reason = "<unknown>";
        switch(groupInt)
        {
            case RplKickCauseGroup.REPLICATION:
                group = "REPLICATION";
                switch(reasonInt)
                {
                    case RplError.SYSTEM_FAILURE: reason = "SYSTEM_FAILURE"; return true;
                    case RplError.DISCONNECTION: reason = "DISCONNECTION"; return true;
                    case RplError.CONNECTION_FAILURE: reason = "CONNECTION_FAILURE"; return true;
                    case RplError.TIMEOUT: reason = "TIMEOUT"; return true;
                    case RplError.FLOODED: reason = "FLOODED"; return true;
                    case RplError.STALLED: reason = "STALLED"; return true;
                    case RplError.SERVICE_FAILURE: reason = "SERVICE_FAILURE"; return true;
                    case RplError.JIP_ERROR: reason = "JIP_ERROR"; return true;
                    case RplError.SHUTDOWN: reason = "SHUTDOWN"; return true;
                    case RplError.CREATION_FAILURE: reason = "CREATION_FAILURE"; return true;
                }
            break;
 
            case KickCauseGroup.BATTLEYE_INIT:
                group = "BATTLEYE_INIT";
                switch(reasonInt)
                {
                    case BattlEyeInitError.LOAD_ERROR: reason = "LOAD_ERROR"; return true;
                    case BattlEyeInitError.UNSUPPORTED_VERSION: reason = "UNSUPPORTED_VERSION"; return true;
                    case BattlEyeInitError.OTHER_ERROR: reason = "OTHER_ERROR"; return true;
                }
            break;
 
            case KickCauseGroup.BATTLEYE:
                group = "BATTLEYE";
                switch(reasonInt)
                {
                    case BattlEyeKickReason.CLIENT_NOT_RESPONDING: reason = "CLIENT_NOT_RESPONDING"; return true;
                    case BattlEyeKickReason.QUERY_TIMEOUT: reason = "QUERY_TIMEOUT"; return true;
                    case BattlEyeKickReason.GAME_RESTART_REQUIRED: reason = "GAME_RESTART_REQUIRED"; return true;
                    case BattlEyeKickReason.BAD_SERVICE_VERSION: reason = "BAD_SERVICE_VERSION"; return true;
                    case BattlEyeKickReason.DISALLOWED_PROGRAM: reason = "DISALLOWED_PROGRAM"; return true;
                    case BattlEyeKickReason.CORRUPTED_MEMORY: reason = "CORRUPTED_MEMORY"; return true;
                    case BattlEyeKickReason.CORRUPTED_DATA: reason = "CORRUPTED_DATA"; return true;
                    case BattlEyeKickReason.WINAPI_FAILURE: reason = "WINAPI_FAILURE"; return true;
                    case BattlEyeKickReason.GLOBAL_BAN: reason = "GLOBAL_BAN"; return true;
                    case BattlEyeKickReason.ADMIN_BAN: reason = "ADMIN_BAN"; return true;
                    case BattlEyeKickReason.ADMIN_KICK: reason = "ADMIN_KICK"; return true;
                    case BattlEyeKickReason.INVALID_SERVER_CONFIG: reason = "INVALID_SERVER_CONFIG"; return true;
                }
            break;
 
            case KickCauseGroup.DATA:
                group = "DATA";
                switch(reasonInt)
                {
                    case DataError.VERSION_MISMATCH: reason = "VERSION_MISMATCH"; return true;
                    case DataError.RDB_MISMATCH: reason = "RDB_MISMATCH"; return true;
                    case DataError.SCRIPT_MISMATCH: reason = "SCRIPT_MISMATCH"; return true;
                    case DataError.WORLD_LOAD_ERROR: reason = "WORLD_LOAD_ERROR"; return true;
                    case DataError.WORLD_LOAD_INCONSISTENCY: reason = "WORLD_LOAD_INCONSISTENCY"; return true;
                    case DataError.ADDON_LOAD_ERROR: reason = "ADDON_LOAD_ERROR"; return true;
                }
            break;
 
            case KickCauseGroup2.PLATFORM:
                group = "PLATFORM";
                switch(reasonInt)
                {
                    case PlatformKickReason.ACTIVE_USER_LOST: reason = "ACTIVE_USER_LOST"; return true;
                    case PlatformKickReason.NO_MP_PRIVILEGE: reason = "NO_MP_PRIVILEGE"; return true;
                    case PlatformKickReason.NO_CROSSPLAY_PRIVILEGE: reason = "NO_CROSSPLAY_PRIVILEGE"; return true;
                }
            break;
 
            case KickCauseGroup2.PLAYER_MANAGER:
                group = "PLAYER_MANAGER";
                switch (reasonInt)
                {
                    case PlayerManagerKickReason.KICK: reason = "KICK"; return true;
                    case PlayerManagerKickReason.KICK_VOTED: reason = "KICK_VOTED"; return true;
                    case PlayerManagerKickReason.DUPLICATE_PLAYER_IDENTITY: reason = "DUPLICATE_PLAYER_IDENTITY"; return true;
                    case PlayerManagerKickReason.BAN: reason = "BAN"; return true;
                    case PlayerManagerKickReason.TEMP_BAN: reason = "TEMP_BAN"; return true;
                    case SCR_PlayerManagerKickReason.KICKED_BY_GM: reason = "KICKED_BY_GM"; return true;
                    case SCR_PlayerManagerKickReason.BANNED_BY_GM: reason = "BANNED_BY_GM"; return true;
                    case SCR_PlayerManagerKickReason.FRIENDLY_FIRE: reason = "FRIENDLY_FIRE"; return true;
                    case SCR_PlayerManagerKickReason.DISRUPTIVE_BEHAVIOUR: reason = "DISRUPTIVE_BEHAVIOUR"; return true;
                }
            break;
        }
        
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void AddRejoinAttempt()
    {
        // Get count
        string strAttempt = GameSessionStorage.s_Data["m_iRejoinAttempt"];
        int attempt = 0;
        
        // Setup number
        if (strAttempt.IsEmpty())
        {
            GameSessionStorage.s_Data["m_iRejoinAttempt"] = "0";
        }   
        else 
        {
            attempt = strAttempt.ToInt();
        }
 
        // Add
        attempt++;
        GameSessionStorage.s_Data["m_iRejoinAttempt"] = attempt.ToString();
    }
    
    //------------------------------------------------------------------------------------------------
    protected override void OnWorldPostProcess(World world)
    {
        if (m_CoresManager)
            m_CoresManager.OnWorldPostProcess(world);
        
        if (GetGameMode())
            GetGameMode().OnWorldPostProcess(world);
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void ShowErrorMessage(string msg)
    {
        m_aErrorStack.Push(new SCR_GameErrorMessage(msg, "Error"));
    }
 
    //------------------------------------------------------------------------------------------------
    protected void ShowNextErrorDialog()
    {
        MenuManager menuManager = GetMenuManager();
        if (!menuManager)   // No menu manager, we have no means of displaying the error atm
            return;
 
        DialogUI currentDialog = DialogUI.Cast(menuManager.FindMenuByPreset(ChimeraMenuPreset.ErrorDialog));
        if (currentDialog != null)  // There is already an error dialog displayed, do not display next one
            return;
 
        SCR_GameErrorMessage errorMessage = m_aErrorStack.Pop();
        if (!errorMessage)
            return; // Should not occur as we're checking for whether the stack is empty
 
        // Display the error message using DialogUI menu dialogue
        if (errorMessage)
        {
            DialogUI dialog = DialogUI.Cast(menuManager.OpenDialog(ChimeraMenuPreset.ErrorDialog));
            if (dialog)
            {
                dialog.SetTitle(errorMessage.GetTitle());
                dialog.SetMessage(errorMessage.GetMessage());
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetGameStarted()
    {
        return m_bGameStarted;
    }
 
    //------------------------------------------------------------------------------------------------
    EGameFlags GetGameFlags()
    {
        return m_eGameFlags;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetGameFlags(EGameFlags newGameFlags, bool shouldInvoke)
    {
        m_bAreGameFlagsObtained = true;
        m_eGameFlags            = newGameFlags;
 
        if (shouldInvoke)
        {
            InvokeGameFlags();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    bool AreGameFlagsObtained()
    {
        return m_bAreGameFlagsObtained;
    }
 
    //------------------------------------------------------------------------------------------------
    bool AreGameFlagsSet(EGameFlags checkGameFlags)
    {
        return (m_eGameFlags & checkGameFlags) != 0;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnObtainedGameFlagsInvoker()
    {
        return Event_OnObtainedGameFlags;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void InvokeGameFlags()
    {
        Event_OnObtainedGameFlags.Invoke();
    }
 
    //------------------------------------------------------------------------------------------------
    override typename GetMenuPreset()
    {
        return ChimeraMenuPreset;
    }
 
    //------------------------------------------------------------------------------------------------
    override LoadingAnim CreateLoadingAnim(WorkspaceWidget workspaceWidget)
    {
        return new ArmaReforgerLoadingAnim(workspaceWidget);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnAfterInit(BaseWorld world)
    {
        //required for DS registration with -dserver param
        if (System.IsConsoleApp())
        {
            DSSession session = GetGame().GetBackendApi().GetDSSession();
            if (session)
            {
                /*m_dsCommander = new SCR_RCONCommander();
                session.SetRCONCommander(m_dsCommander);*/
            }
        }
        m_CoresManager = SCR_GameCoresManager.CreateCoresManager();
        m_SaveManagerCore = SCR_SaveManagerCore.Cast(m_CoresManager.GetCore(SCR_SaveManagerCore));
        
        WidgetManager.SetCursor(0);
    }
 
    //------------------------------------------------------------------------------------------------
    override bool OnGameStart()
    {
        m_bGameStarted = true;
 
        #ifdef ENABLE_DIAG
        if (RplSession.Mode() != RplMode.Client)
        {
            DiagMenu.RegisterMenu(SCR_DebugMenuID.DEBUGUI_DEPLOYABLE_SPAWNPOINTS, "Deployable SpawnPoints", "Game");
            DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_DEPLOYABLE_SPAWNPOINTS_ENABLE_DIAG, "", "Show Exclusion Zones", "Deployable SpawnPoints");
        }       
        
        DiagMenu.RegisterItem(SCR_DebugMenuID.DEBUGUI_INPUT_MANAGER, "", "Show input manager", "GameCode", "disabled,active,all");
 
        // Game
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_GAME_BOUNDS_OVERLAP_PREFAB, "", "Show bounds overlap target info", "Game");
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_GAME_CURSOR_TARGET_PREFAB, "", "Show cursor target info", "Game");
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_GAME_COPY_ENF_VIEW_LINK, "lctrl+lshift+l", "Copy view link", "Game");
 
        // UI
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_UI_CLOSE_ALL_MENUS, "", "Close All Menus", "UI");
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_UI_OPEN_MAIN_MENU, "", "Open Main Menu", "UI");
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_UI_LOG_UNDER_CURSOR, "", "Log widgets under cursor", "UI");
        #endif
 
        if (!GetWorldEntity() || RplSession.Mode() != RplMode.Client)
        {
            m_bAreGameFlagsObtained = true;
            InvokeGameFlags();
        }
        
        AddActionListeners();
 
        if (m_CoresManager)
            m_CoresManager.OnGameStart();
 
        m_SessionErrorHandler = new RplSessionErrorHandler();
 
#ifndef PLATFORM_CONSOLE
        if (System.IsCLIParam("listScenarios"))
            SCR_GameLogHelper.LogScenariosConfPaths();
        
        m_bHasKeyboard = true;
#endif
        
#ifdef PLATFORM_CONSOLE
        SCR_SettingsManager settingsManager = GetSettingsManager();
        //by default we do not expect console to have keyboard
        m_bHasKeyboard = false;
 
        //setup default quality settings for series S and series X xbox
        if (settingsManager)
        {
            SCR_SettingsManagerVideoModule settingsVideoModule = SCR_SettingsManagerVideoModule.Cast(settingsManager.GetModule(ESettingManagerModuleType.SETTINGS_MANAGER_VIDEO));
            
            //by default we do not expect console to have keyboard
            m_bHasKeyboard = false;
            
            //setup default quality settings for series S and series X xbox
            if (settingsVideoModule)
            {
                int lastUsedPresetID = -1;
                BaseContainer videoSettings = GetGame().GetGameUserSettings().GetModule("SCR_VideoSettings");
                if (videoSettings)
                {
                    videoSettings.Get("m_iLastUsedPreset", lastUsedPresetID);
                    if (lastUsedPresetID == -1 && System.GetPlatform() == EPlatform.XBOX_SERIES_S)
                        settingsVideoModule.SetConsolePreset(EVideoQualityPreset.SERIES_S_PRESET_QUALITY);
                    else if (lastUsedPresetID == -1 && System.GetPlatform() == EPlatform.XBOX_SERIES_X)
                        settingsVideoModule.SetConsolePreset(EVideoQualityPreset.SERIES_X_PRESET_QUALITY);
                    
                    if (lastUsedPresetID != -1)
                        settingsVideoModule.SetConsolePreset(lastUsedPresetID);
                }
            }
        }
#endif
        
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    protected static void OnMenuOpen()
    {
        MenuManager menuManager = GetGame().GetMenuManager();
        if (!menuManager || menuManager.IsAnyMenuOpen() || menuManager.IsAnyDialogOpen())
            return;
 
        OpenPauseMenu();
    }
 
    //------------------------------------------------------------------------------------------------
    static void OnShowPlayerList()
    {
        MenuManager manager = GetGame().GetMenuManager();
        if (manager.IsAnyMenuOpen() || manager.IsAnyDialogOpen())
            return;
 
        OpenPlayerList();
    }
 
    //------------------------------------------------------------------------------------------------
    static void OnShowGroupMenu()
    {
        OpenGroupMenu();
    }
 
    //------------------------------------------------------------------------------------------------
    static void OpenPauseMenu(bool hideParentMenu = true, bool fadeBackground = false)
    {
        MenuBase menu = GetGame().GetMenuManager().OpenMenu(ChimeraMenuPreset.PauseMenu, 0, true, hideParentMenu);
        if (!fadeBackground)
            return;
 
        PauseMenuUI pauseMenu = PauseMenuUI.Cast(menu);
        if (pauseMenu)
            pauseMenu.FadeBackground(true, true);
    }
 
    //------------------------------------------------------------------------------------------------
    static SCR_PlayerListMenu OpenPlayerList()
    {
        MenuManager menuManager = GetGame().GetMenuManager();
        if (menuManager.IsAnyDialogOpen())
            return null; // We don't want to open this menu behind any dialogs.
 
        MenuBase menu = menuManager.FindMenuByPreset(ChimeraMenuPreset.PlayerListMenu);
        if (!menu)
            menu = menuManager.OpenMenu(ChimeraMenuPreset.PlayerListMenu);
        
        return SCR_PlayerListMenu.Cast(menu);
    }
 
    //------------------------------------------------------------------------------------------------
    static SCR_GroupMenu OpenGroupMenu()
    {
        SCR_Faction playerFaction;
        SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
        if (factionManager)
            playerFaction = SCR_Faction.Cast(factionManager.GetLocalPlayerFaction());
        
        if (!playerFaction)
            return null;
        
        MenuManager menuManager = GetGame().GetMenuManager();
        if (menuManager.IsAnyDialogOpen())
            return null; // We don't want to open this menu behind any dialogs.
 
        MenuBase menu = MenuBase.Cast(menuManager.FindMenuByPreset(ChimeraMenuPreset.GroupMenu));
        MenuBase playerMenu = MenuBase.Cast(menuManager.FindMenuByPreset(ChimeraMenuPreset.PlayerListMenu));
        if (playerMenu)
            return null;
        
        if (!menu)
            GetGame().GetMenuManager().OpenMenu(ChimeraMenuPreset.GroupMenu, 0, false, false);
        else    
            GetGame().GetMenuManager().CloseMenu(menu);
        
        return SCR_GroupMenu.Cast(menu);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnGameEnd()
    {
        m_bAreGameFlagsObtained = false;
        Event_OnObtainedGameFlags.Clear();
        GetGame().GetMenuManager().CloseAllMenus();
        
        RemoveActionListeners();
 
        SCR_BaseGameMode gameMode = SCR_BaseGameMode.Cast(GetGameMode());
        if (gameMode)
            gameMode.OnGameEnd();
 
        ShutdownBackend();
 
        if (m_CoresManager)
            m_CoresManager.OnGameEnd();
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnUserSettingsChangedEvent()
    {
        m_OnChangeUserSettingsInvoker.Invoke();
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnInputDeviceUserChangedEvent(EInputDeviceType oldDevice, EInputDeviceType newDevice)
    {
        m_OnInputDeviceUserChangedInvoker.Invoke(oldDevice, newDevice);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnInputDeviceIsGamepadEvent(bool isGamepad)
    {
        m_OnInputDeviceIsGamepadInvoker.Invoke(isGamepad);
        if (!isGamepad && !m_bHasKeyboard)
            m_bHasKeyboard = true;
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnWorldSimulatePhysics(float timeSlice)
    {
        m_OnWorldSimulatePhysicsInvoker.Invoke(timeSlice);
    }
    
    //------------------------------------------------------------------------------------------------
    override event void OnWindowResize(int w, int h, bool windowed)
    {
        m_OnWindowResizeInvoker.Invoke(w, h, windowed);
    }
    
    //------------------------------------------------------------------------------------------------
    void AddActionListeners()
    {
        InputManager inputManager = GetInputManager();
        inputManager.AddActionListener("ShowScoreboard", EActionTrigger.DOWN, OnShowPlayerList);
        inputManager.AddActionListener("ShowGroupMenu", EActionTrigger.DOWN, OnShowGroupMenu);
        inputManager.AddActionListener("MenuOpen", EActionTrigger.DOWN, OnMenuOpen);
        
        #ifdef WORKBENCH
            inputManager.AddActionListener("MenuOpenWB", EActionTrigger.DOWN, OnMenuOpen);
        #endif
    }
    
    //------------------------------------------------------------------------------------------------
    void RemoveActionListeners()
    {
        InputManager inputManager = GetInputManager();
        inputManager.RemoveActionListener("ShowScoreboard", EActionTrigger.DOWN, OnShowPlayerList);
        inputManager.RemoveActionListener("ShowGroupMenu", EActionTrigger.DOWN, OnShowGroupMenu);
        inputManager.RemoveActionListener("MenuOpen", EActionTrigger.DOWN, OnMenuOpen);
        
        #ifdef WORKBENCH
            inputManager.RemoveActionListener("MenuOpenWB", EActionTrigger.DOWN, OnMenuOpen);
        #endif
    }
 
    #ifdef ENABLE_DIAG
    private ref QueryTargetDiag m_pQueryTargetDiag = new QueryTargetDiag();
 
    //------------------------------------------------------------------------------------------------
    private bool GetQueryTargetInfo(IEntity ent, out string name, out string tree)
    {
        if (!ent)
            return false;
        
        EntityPrefabData prefabData = ent.GetPrefabData();
        if (!prefabData)
            return false;
        
        name = prefabData.GetPrefabName();
        tree = "";
        
        BaseContainer cont = prefabData.GetPrefab();
        while (cont)
        {
            string contName = cont.GetName();
            if (!contName.IsEmpty())
            {
                tree += contName;
                if (!tree.IsEmpty())
                    tree += "\n";
                
                if (name.IsEmpty())
                    name = contName;
            }
            
            cont = cont.GetAncestor();
        }
        
        return true;    
    }
    #endif
 
    //------------------------------------------------------------------------------------------------
    override void OnUpdate(BaseWorld world, float timeslice)
    {
        super.OnUpdate(world, timeslice);
 
        m_Callqueue.Tick(timeslice);
 
        // Setup in-game context
        if (!GetMenuManager().IsAnyMenuOpen())
        {
            GetInputManager().ActivateContext("IngameContext", 1);
        }
 
        // If we're in the main menu and there are errors on the error stack
        // process them one by one
        if (m_bIsMainMenuOpen)
        {
            if (!m_aErrorStack.IsEmpty())
            {
                ShowNextErrorDialog();
            }
        }
 
        GetInputManager().SetDebug(DiagMenu.GetValue(SCR_DebugMenuID.DEBUGUI_INPUT_MANAGER));
 
        // Check clipboard link diag
        #ifdef ENABLE_DIAG
        bool bGetEnfLinkToClipboard = DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_GAME_COPY_ENF_VIEW_LINK);
        if (bGetEnfLinkToClipboard)
        {
            // Out to clip
            vector cameraTransform[4];
            world.GetCurrentCamera(cameraTransform);
            System.ExportToClipboard(GetWorldEditorLink(cameraTransform));
            // Reset
            DiagMenu.SetValue(SCR_DebugMenuID.DEBUGUI_GAME_COPY_ENF_VIEW_LINK, 0);
        }
 
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_GAME_CURSOR_TARGET_PREFAB))
        {
            CameraManager cameraManager = GetGame().GetCameraManager();
            if (cameraManager)
            {
                CameraBase current = cameraManager.CurrentCamera();
                if (current)
                {
                    DbgUI.Begin("Cursor target info");
                    IEntity ent = current.GetCursorTarget();
                    if (ent)
                    {
                        // Position
                        vector pos = ent.GetOrigin();
 
                        // Name
                        string name = ent.GetName();
                        string pname;
                        if( name.IsEmpty() )
                            pname = "Unnamed entity";
                        else
                            pname = "Name: " + name;
                            
                        // Draw text
                        DbgUI.Text(pname);
 
                        string prfab;
                        string ptree;
                        string pepos;
                        if (GetQueryTargetInfo(ent, prfab, ptree))
                        {
                            pepos = "Position: <" + pos[0] + ", " + pos[1] + ", " + pos[2] + ">";                       
                            
                            Physics phys = ent.GetPhysics();
                            if( phys && phys.GetVelocity().Length() > 0 )
                            {
                                string pevel = "Velocity: " + phys.GetVelocity().Length();
                                pepos += ", ";
                                pepos += pevel;
                            }
                            DbgUI.Text(pepos);
                                
                            DbgUI.Text("Prefab: " + prfab);
                            DbgUI.Text("Prefab Inheritance Tree: " + ptree);
                        }
                        DbgUI.Spacer(32);
                        string infoText = string.Format("%1\n%2\nPrefab: \"%3\"\nPrefab Inheritance Tree: \"%4\"", pname, pepos, prfab, ptree);
                        
                        if (DbgUI.Button("Copy to clipboard"))
                        {
                            System.ExportToClipboard(infoText);
                        }
 
                        // Draw ddbox
                        vector mins, maxs;
                        ent.GetWorldBounds(mins, maxs);
                        Shape boundingFill = Shape.Create(ShapeType.BBOX, ARGB(5, 0, 255, 0), ShapeFlags.ONCE | ShapeFlags.NOZBUFFER | ShapeFlags.TRANSP, mins, maxs);
                        Shape boundingWire = Shape.Create(ShapeType.BBOX, ARGB(200, 0, 255, 255), ShapeFlags.ONCE | ShapeFlags.NOZBUFFER | ShapeFlags.WIREFRAME | ShapeFlags.TRANSP, mins, maxs);
 
                        DebugTextWorldSpace.Create(current.GetWorld(), infoText, DebugTextFlags.FACE_CAMERA | DebugTextFlags.CENTER | DebugTextFlags.ONCE, pos[0], maxs[1] + 0.5, pos[2], 8, ARGB(255, 0, 255, 255), ARGB(64, 0, 0, 0));
                    }
                    DbgUI.End();
                }
            }
        }
 
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_GAME_BOUNDS_OVERLAP_PREFAB))
        {
            CameraManager cameraManager = GetGame().GetCameraManager();
            if (cameraManager)
            {
                CameraBase current = cameraManager.CurrentCamera();
                if (current)
                {
                    DbgUI.Begin("Bounds overlap target info");
                    vector cameraMat[4];
                    current.GetWorldTransform(cameraMat);
 
                    m_pQueryTargetDiag.Prepare();
                    m_pQueryTargetDiag.DoQuery(current.GetWorld(), cameraMat[3], cameraMat[3] + 3.0 * cameraMat[2]);
                    IEntity ent = m_pQueryTargetDiag.GetClosestEntity(cameraMat[3]);
                    if (ent)
                    {
                        // Position
                        vector pos = ent.GetOrigin();
 
                        // Name
                        string name = ent.GetName();
                        string pname;
                        if( name.IsEmpty() )
                            pname = "Unnamed entity";
                        else
                            pname = "Name: " + name;
                            
                        // Draw text
                        DbgUI.Text(pname);
 
                        string prfab;
                        string ptree;
                        string pepos;
                        if (GetQueryTargetInfo(ent, prfab, ptree))
                        {
                            pepos = "Position: <" + pos[0] + ", " + pos[1] + ", " + pos[2] + ">";                       
                            
                            Physics phys = ent.GetPhysics();
                            if( phys && phys.GetVelocity().Length() > 0 )
                            {
                                string pevel = "Velocity: " + phys.GetVelocity().Length();
                                pepos += ", ";
                                pepos += pevel;
                            }
                            DbgUI.Text(pepos);
                                
                            DbgUI.Text("Prefab: " + prfab);
                            DbgUI.Text("Prefab Inheritance Tree: " + ptree);
                        }
                        DbgUI.Spacer(32);
                        string infoText = string.Format("%1\n%2\nPrefab: \"%3\"\nPrefab Inheritance Tree: \"%4\"", pname, pepos, prfab, ptree);
                        if (DbgUI.Button("Copy to clipboard"))
                        {
                            System.ExportToClipboard(infoText);
                        }
 
                        // Draw ddbox
                        vector mins, maxs;
                        ent.GetWorldBounds(mins, maxs);
                        Shape boundingFill = Shape.Create(ShapeType.BBOX, ARGB(5, 0, 255, 0), ShapeFlags.ONCE | ShapeFlags.NOZBUFFER | ShapeFlags.TRANSP, mins, maxs);
                        Shape boundingWire = Shape.Create(ShapeType.BBOX, ARGB(200, 0, 255, 255), ShapeFlags.ONCE | ShapeFlags.NOZBUFFER | ShapeFlags.WIREFRAME | ShapeFlags.TRANSP, mins, maxs);
 
                        DebugTextWorldSpace.Create(current.GetWorld(), infoText, DebugTextFlags.FACE_CAMERA | DebugTextFlags.CENTER | DebugTextFlags.ONCE, pos[0], maxs[1] + 0.5, pos[2], 8, ARGB(255, 0, 255, 255), ARGB(64, 0, 0, 0));
                    }
                    DbgUI.End();
                }
            }
        }
 
        // Close all menus
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_UI_CLOSE_ALL_MENUS))
        {
            DiagMenu.SetValue(SCR_DebugMenuID.DEBUGUI_UI_CLOSE_ALL_MENUS, 0);
            GetGame().GetMenuManager().CloseAllMenus();
        }
 
        // Open main menu
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_UI_OPEN_MAIN_MENU))
        {
            DiagMenu.SetValue(SCR_DebugMenuID.DEBUGUI_UI_OPEN_MAIN_MENU, 0);
            GetGame().GetMenuManager().OpenMenu(ChimeraMenuPreset.MainMenu);
        }
 
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_UI_LOG_UNDER_CURSOR))
        {
            DiagMenu.SetValue(SCR_DebugMenuID.DEBUGUI_UI_LOG_UNDER_CURSOR, 0);
 
            array<Widget> widgets = {};
            int mouseX, mouseY;
            WidgetManager.GetMousePos(mouseX, mouseY);
            WidgetManager.TraceWidgets(mouseX, mouseY, GetGame().GetWorkspace(), widgets);
            int count = widgets.Count();
            Print(string.Format("Widgets under cursor (x = %1, y = %2): %3", mouseX, mouseY, count), LogLevel.NORMAL);
            for (int i; i < count; i++)
            {
                Print("  " + SCR_WidgetTools.GetHierarchyLog(widgets[i]), LogLevel.NORMAL);
            }
        }
 
        #endif
 
        if (m_CoresManager)
            m_CoresManager.OnUpdate(timeslice);
    }
 
    //------------------------------------------------------------------------------------------------
    // called by OnGameEnd
    void ShutdownBackend()
    {
//      BackendApi backendApi = GetBackendApi();
//      if (backendApi.IsAuthenticated())
//          backendApi.Shutdown();
    }
 
    //------------------------------------------------------------------------------------------------
    void SetHUDManager(SCR_HUDManagerComponent hud)
    {
        m_HUDManager = hud;
    }
    
    //------------------------------------------------------------------------------------------------
    void LoadSave(string fileName)
    {
        //--- Remove .json extension
        string ext;
        string fileNameFiltered = FilePath.StripExtension(fileName, ext);
        if (ext == "json")
            fileName = fileNameFiltered;
        
        GetSaveManager().RestartAndLoad(fileName);
    }
 
    //------------------------------------------------------------------------------------------------
    void RegisterLoadoutManager(SCR_LoadoutManager instance)
    {
        if (m_pLoadoutManager)
        {
            Print("Trying to register a SCR_LoadoutManager, but one is already registered!", LogLevel.ERROR);
            return;
        }
 
        m_pLoadoutManager = instance;
    }
 
    //------------------------------------------------------------------------------------------------
    void UnregisterLoadoutManager(SCR_LoadoutManager instance)
    {
        if (!m_pLoadoutManager)
        {
            Print("Trying to unregister a SCR_LoadoutManager, but none is registered!", LogLevel.ERROR);
            return;
        }
 
        if (!instance)
        {
            Print("Trying to unregister an invalid SCR_LoadoutManager!", LogLevel.ERROR);
            return;
        }
 
        if (m_pLoadoutManager != instance)
        {
            Print("Trying to unregister a SCR_LoadoutManager, but different one is registered!", LogLevel.ERROR);
            return;
        }
 
        Print("SCR_LoadoutManager unregistered successfully, released instance: " + instance, LogLevel.VERBOSE);
        // Release reference
        m_pLoadoutManager = null;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_HUDManagerComponent GetHUDManager()
    {
        return m_HUDManager;
    }
 
    #ifdef ENABLE_DIAG
    //------------------------------------------------------------------------------------------------
    static string GetWorldEditorLink(vector transformation[4])
    {
        // Fetch position
        vector position = transformation[3];
 
        // Fetch angles
        vector angles = Math3D.MatrixToAngles(transformation);
 
        // We want to substring only /worlds/...
        // to prevent exposing local folders, etc.
        string fullLink = GetGame().GetWorldFile();
        string fullLinkLower = fullLink;
        fullLinkLower.ToLower(); // In case another casing of the folder is used
        int begin = fullLinkLower.IndexOf("worlds/");
        string worldPath = fullLink.Substring(begin, fullLink.Length() - begin);
 
        // Create link
        string link = string.Format(
            "enfusion://WorldEditor/%1;%2,%3,%4;%5,%6,%7",
            worldPath,
            position[0],
            position[1],
            position[2],
            angles[1],
            angles[0],
            angles[2]);
 
        // Print it to console
        return link;
    }
    #endif
 
    //------------------------------------------------------------------------------------------------
    override protected ref Managed GetPlayerDataStats(int playerID)
    {
        if (m_DataCollectorComponent)
            return m_DataCollectorComponent.GetPlayerDataStats(playerID);
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    override string GetMissionName()
    {
        SCR_MissionHeader header = SCR_MissionHeader.Cast(GetMissionHeader());
        if (header)
            return header.m_sName;
        else
            return "";
    }
 
    //------------------------------------------------------------------------------------------------
    override void PlayGameConfig(ResourceName sResource, string addonsList)
    {
        Print(string.Format("PlayGameConfig {Resource: %1; Addons: %2}", sResource, addonsList), LogLevel.NORMAL);
 
        if (sResource.Empty)
        {
            Print(string.Format("PlayGameConfig: Empty resource passed!"), LogLevel.NORMAL);
            return;
        }
        
        if (GameStateTransitions.RequestScenarioChangeTransition(sResource, addonsList))
            GetGame().GetMenuManager().CloseAllMenus();
        else
            Print(string.Format("Failed to start scenario."), LogLevel.ERROR);
    }
 
    //------------------------------------------------------------------------------------------------
    override void HostGameConfig()
    {
        bool success = GameStateTransitions.RequestPublicServerTransition(null);
        
        if (success)
            GetGame().GetMenuManager().CloseAllMenus();
        else
            Print("Failed to host config", LogLevel.ERROR);
    }
 
    //------------------------------------------------------------------------------------------------
    override Managed ReadGameConfig(string sResource)
    {
        return MissionHeader.ReadMissionHeader(sResource);
    }
 
    //------------------------------------------------------------------------------------------------
    override array<ResourceName> GetDefaultGameConfigs()
    {
        ResourceName config = "{CB4130E7FBE99D74}Configs/Workshop/DefaultScenarios.conf";
        Resource resource = BaseContainerTools.LoadContainer(config);
        if (!resource)
            return null;
 
        BaseContainer entries = resource.GetResource().ToBaseContainer();
        if (!entries)
            return null;
 
        array<ResourceName> resources = {};
 
        entries.Get("m_aDefaultScenarios", resources);
        
        return resources;
    }
    
    //------------------------------------------------------------------------------------------------
    protected void InsertNewScenario(ResourceName scenario, inout array<ResourceName> resources)
    {
        foreach (ResourceName r : resources)
        {
            if (scenario == r)
                return;
        }
        
        resources.Insert(scenario);
    }
 
    //------------------------------------------------------------------------------------------------
    protected static bool CheckMissionHeader(MissionWorkshopItem mission)
    {
        SCR_MissionHeader header = SCR_MissionHeader.Cast(mission.GetHeader());
 
        if (!header)
        {
            Print(string.Format("Mission header doesn't exist or is not of SCR_MissionHeader class: %1", mission.Name()), LogLevel.ERROR);
            return false;
        }
 
        string worldPath = header.GetWorldPath();
        if (worldPath.IsEmpty())
        {
            Print(string.Format("Mission world path is incorrect: %1", mission.Name()), LogLevel.ERROR);
            return false;
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    static SCR_2DPIPSightsComponent GetCurrentPIPSights()
    {
        IEntity controlledEntity = SCR_PlayerController.GetLocalControlledEntity();
        if (!controlledEntity)
            return null;
 
        ChimeraCharacter character = ChimeraCharacter.Cast(controlledEntity);
        if (!character)
            return null;
 
        BaseWeaponManagerComponent weaponManager = character.GetCharacterController().GetWeaponManagerComponent();
        if (!weaponManager)
            return null;
 
        BaseSightsComponent currentSights = weaponManager.GetCurrentSights();
        if (!currentSights)
            return null;
 
        SCR_2DPIPSightsComponent pip = SCR_2DPIPSightsComponent.Cast(currentSights);
        if (!pip)
            return null;
 
        return pip;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool IsScreenPointInPIPSights(vector screenPosition, SCR_2DPIPSightsComponent sightsComponent)
    {
        if (!sightsComponent)
            return false;
 
        return sightsComponent.IsScreenPositionInSights(screenPosition);
    }
    
    //-------------------------------------------------------------------------------------------
    bool IsPlatformGameConsole()
    {
        #ifdef PLATFORM_CONSOLE
            return true;
        #else
            return false;
        #endif
    }
    
    //-------------------------------------------------------------------------------------------
    override void OnGamepadConnectionStatus(bool isConnected)
    {
        #ifndef AUTOTEST
        if (!isConnected && IsPlatformGameConsole())
            SCR_GamepadRemovalUI.OpenGamepadRemovalDialog();
        #endif
    }
}
 
ArmaReforgerScripted g_ARGame;
 
//------------------------------------------------------------------------------------------------
Game CreateGame()
{
    g_ARGame = new ArmaReforgerScripted;
    return g_ARGame;
}
 
//------------------------------------------------------------------------------------------------
ArmaReforgerScripted GetGame()
{
    return g_ARGame;
}
 
#ifdef ENABLE_DIAG
class QueryTargetDiag
{
    private ref array<IEntity> m_aQueriedTargetEntities = {};
 
    //------------------------------------------------------------------------------------------------
    // Prepares for collection
    void Prepare()
    {
        m_aQueriedTargetEntities.Clear();
    }
 
    //------------------------------------------------------------------------------------------------
    // Collects nearby entities
    void DoQuery(BaseWorld world, vector from, vector to)
    {
        world.QueryEntitiesByLine(from, to, QueryTargetEntity);
    }
 
    // Internal query callback
    private bool QueryTargetEntity(IEntity ent)
    {
        if (CameraBase.Cast(ent))
            return true;
 
        m_aQueriedTargetEntities.Insert(ent);
        return true;
    }
 
    IEntity GetFirstEntity()
    {
        if (m_aQueriedTargetEntities.Count() > 0)
            return m_aQueriedTargetEntities[0];
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    // Returns closest entity relative to point
    IEntity GetClosestEntity(vector relativeTo)
    {
        IEntity closest = null;
        float sqDistance = float.MAX;
        foreach (IEntity ent : m_aQueriedTargetEntities)
        {
            float currentSqDist = vector.DistanceSq(ent.GetOrigin(), relativeTo);
            if (currentSqDist < sqDistance)
            {
                closest = ent;
                sqDistance = currentSqDist;
            }
        }
 
        return closest;
    }
}
#endif