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/";

    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_BuildingDestructionManagerComponent m_BuildingDestructionManager;
    protected SCR_SpawnerAIGroupManagerComponent m_SpawnerAIGroupManager;
    protected bool                          m_bHasKeyboard;

    protected SCR_LoadoutManager m_pLoadoutManager;

    protected SCR_DataCollectorComponent m_DataCollectorComponent;
 
    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 ScriptInvokerVoid m_OnHUDManagerChanged = new ScriptInvokerVoid();
    ref ScriptInvoker<bool> m_OnGameInstallComplete = new ScriptInvoker();
 
    protected ref ScriptCallQueue m_Callqueue = new ScriptCallQueue();
 
    protected ref SCR_ResourceGrid m_ResourceGrid;
    protected ref SCR_ResourceSystemSubscriptionManager m_ResourceSystemSubscriptionManager;
 
    //------------------------------------------------------------------------------------------------
    // destructor
    void ~ArmaReforgerScripted()
    {
        g_ARGame = null;
    }
 
    //------------------------------------------------------------------------------------------------
    IEntity SpawnEntityPrefabEx(ResourceName prefab, bool randomizeEditableVariant, BaseWorld world = null, EntitySpawnParams params = null)
    {
        Resource prefabResource = Resource.Load(prefab);
        if (!prefabResource.IsValid())
            return null;
 
        if (!randomizeEditableVariant)
            return SpawnEntityPrefab(prefabResource, world, params);
 
        return SpawnEntityPrefab(Resource.Load(SCR_EditableEntityComponentClass.GetRandomVariant(prefab)), world, params);
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvokerVoid GetOnHUDManagerChanged()
    {
        return m_OnHUDManagerChanged;
    }
 
    //------------------------------------------------------------------------------------------------
    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;
    }
 
    //------------------------------------------------------------------------------------------------
    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;
    }
 
    //------------------------------------------------------------------------------------------------
    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 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";
 
        ESaveGameType enabledSaveTypes = 0;
        if (pHeader)
            enabledSaveTypes = pHeader.m_eSaveTypes;
 
        GetSaveGameManager().SetEnabledSaveTypes(enabledSaveTypes);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnCinematicStart()
    {
        Print("Cinematic start", LogLevel.DEBUG);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnCinematicEnd()
    {
        Print("Cinematic end", LogLevel.DEBUG);
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnGameInstallComplete()
    {
        m_OnGameInstallComplete.Invoke(false);
    }
 
    //------------------------------------------------------------------------------------------------
    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
        const string format = "Kick cause code: group=%1 '%2', reason=%3 '%4'";
        string strDetail = string.Format(format, groupInt, group, reasonInt, reason);
        Print(strDetail, 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";
                reason = typename.EnumToString(RplError, reasonInt);
                return true;
            }
            case KickCauseGroup.BATTLEYE_INIT:
            {
                group = "BATTLEYE_INIT";
                reason = typename.EnumToString(BattlEyeInitError, reasonInt);
                return true;
            }
            case KickCauseGroup.BATTLEYE:
            {
                group = "BATTLEYE";
                reason = typename.EnumToString(BattlEyeKickReason, reasonInt);
                return true;
            }
            case KickCauseGroup.DATA:
            {
                group = "DATA";
                reason = typename.EnumToString(DataError, reasonInt);
                return true;
            }
            case KickCauseGroup2.PLATFORM:
            {
                group = "PLATFORM";
                reason = typename.EnumToString(PlatformKickReason, reasonInt);
                return true;
            }
            case KickCauseGroup2.PLAYER_MANAGER:
            {
                group = "PLAYER_MANAGER";
                reason = typename.EnumToString(SCR_PlayerManagerKickReason, reasonInt);
                return true;
            }
        }
 
        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)
    {
        if (GetGame().InPlayMode())
            m_CoresManager = SCR_GameCoresManager.CreateCoresManager();
 
        WidgetManager.SetCursor(0);
    }
 
    //------------------------------------------------------------------------------------------------
    override bool OnGameStart()
    {
        m_bGameStarted = true;
        const RplMode currentMode = RplSession.Mode();
 
        #ifdef ENABLE_DIAG
        if (currentMode != 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");
 
        //Scripted systems
        DiagMenu.RegisterMenu(SCR_DebugMenuID.DEBUGUI_SCRIPTS_MENU, "Scripts", "Physics");
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_SHOW_INTERIOR_BOUNDING_BOX, "", "Show interior bounding box", "Scripts");
        #endif
 
        if (!GetWorldEntity() || currentMode != RplMode.Client)
        {
            m_bAreGameFlagsObtained = true;
            InvokeGameFlags();
        }
 
        AddActionListeners();
 
        if (GetGame().InPlayMode() && m_CoresManager)
            m_CoresManager.OnGameStart();
 
        m_SessionErrorHandler = new RplSessionErrorHandler();
 
#ifndef PLATFORM_CONSOLE
        if (System.IsCLIParam("listScenarios"))
            SCR_GameLogHelper.LogScenariosConfPaths();
 
        m_bHasKeyboard = true;
        
        if (!FileIO.FileExists("$profile:.save\\settings\\customInputConfigs"))
            FileIO.MakeDirectory("$profile:.save\\settings\\customInputConfigs");
#endif
 
#ifdef PLATFORM_CONSOLE
        SCR_SettingsManager settingsManager = GetSettingsManager();
 
        //setup default quality settings for consoles
        if (settingsManager)
        {
            SCR_SettingsManagerVideoModule settingsVideoModule = SCR_SettingsManagerVideoModule.Cast(settingsManager.GetModule(ESettingManagerModuleType.SETTINGS_MANAGER_VIDEO));
 
            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_PERFORMANCE);
                    else if (lastUsedPresetID == -1 && System.GetPlatform() == EPlatform.XBOX_SERIES_X)
                        settingsVideoModule.SetConsolePreset(EVideoQualityPreset.SERIES_X_PRESET_PERFORMANCE);
                    else if (lastUsedPresetID == -1 && System.GetPlatform() == EPlatform.PS5)
                        settingsVideoModule.SetConsolePreset(EVideoQualityPreset.PS5_PERFORMANCE);
                    else if (lastUsedPresetID == -1 && System.GetPlatform() == EPlatform.PS5_PRO)
                        settingsVideoModule.SetConsolePreset(EVideoQualityPreset.PS5_PRO_PERFORMANCE);
 
                    if (lastUsedPresetID != -1)
                        settingsVideoModule.SetConsolePreset(lastUsedPresetID);
                }
            }
        }
#endif
 
        const SCR_AdditionalGameModeSettingsComponent additionalSettingsComp = SCR_AdditionalGameModeSettingsComponent.GetInstance();
        if (additionalSettingsComp && ((currentMode == RplMode.Listen || currentMode == RplMode.Dedicated) && System.IsCLIParam("enableNightGrain")))
            additionalSettingsComp.SetNightNoiseEffectState_S(false);
 
        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_GroupsManagerComponent groupManager = SCR_GroupsManagerComponent.GetInstance();
        if (!groupManager || !groupManager.IsGroupMenuAllowed())
            return null;
 
        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 playerMenu = menuManager.FindMenuByPreset(ChimeraMenuPreset.PlayerListMenu);
        if (playerMenu)
            return null;
 
        MenuBase menu = menuManager.FindMenuByPreset(ChimeraMenuPreset.GroupMenu);
        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();
 
        if (GetGame().InPlayMode() && m_CoresManager)
            m_CoresManager.OnGameEnd();
    }
 
    override protected void OnBeforeWorldCleanup()
    {
        if (GetGame().InPlayMode() && m_CoresManager)
            m_CoresManager.OnBeforeWorldCleanup();
    }
    
    //------------------------------------------------------------------------------------------------
    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 (!m_bHasKeyboard && !isGamepad)
            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(UIConstants.MENU_ACTION_OPEN, EActionTrigger.DOWN, OnMenuOpen);
 
        #ifdef WORKBENCH
            inputManager.AddActionListener(UIConstants.MENU_ACTION_OPEN_WB, EActionTrigger.DOWN, OnMenuOpen);
        #endif
    }
 
    //------------------------------------------------------------------------------------------------
    void RemoveActionListeners()
    {
        InputManager inputManager = GetInputManager();
        inputManager.RemoveActionListener("ShowScoreboard", EActionTrigger.DOWN, OnShowPlayerList);
        inputManager.RemoveActionListener("ShowGroupMenu", EActionTrigger.DOWN, OnShowGroupMenu);
        inputManager.RemoveActionListener(UIConstants.MENU_ACTION_OPEN, EActionTrigger.DOWN, OnMenuOpen);
 
        #ifdef WORKBENCH
            inputManager.RemoveActionListener(UIConstants.MENU_ACTION_OPEN_WB, 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 (GetGame().InPlayMode() && m_CoresManager)
            m_CoresManager.OnUpdate(timeslice);
    }
 
    //------------------------------------------------------------------------------------------------
    void SetHUDManager(SCR_HUDManagerComponent hud)
    {
        if (m_HUDManager == hud)
            return;
 
        m_HUDManager = hud;
 
        m_OnHUDManagerChanged.Invoke();
    }
 
    //------------------------------------------------------------------------------------------------
    void RegisterLoadoutManager(SCR_LoadoutManager instance)
    {
        // Ignore calls outside of ChimeraWorld (e.g., ResourceBrowser)
        if (!instance || !ChimeraWorld.CastFrom(instance.GetWorld()))
            return;
 
        if (m_pLoadoutManager)
        {
            Print("Trying to register a SCR_LoadoutManager, but one is already registered!", LogLevel.ERROR);
            Print(string.Format("  oldEntity: %1", m_pLoadoutManager), LogLevel.ERROR);
            Print(string.Format("  newEntity: %1", instance), LogLevel.ERROR);
            return;
        }
 
        m_pLoadoutManager = instance;
        if (!m_pLoadoutManager)
            return;
 
        SCR_FactionManager factionMgr = SCR_FactionManager.Cast(GetFactionManager());
        if (factionMgr)
            factionMgr.UpdateCustomLoadoutSupportState(m_pLoadoutManager);
    }
 
    //------------------------------------------------------------------------------------------------
    void UnregisterLoadoutManager(SCR_LoadoutManager instance)
    {
        // Ignore calls outside of ChimeraWorld (e.g., ResourceBrowser)
        if (instance && !ChimeraWorld.CastFrom(instance.GetWorld()))
            return;
 
        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 protected ref Managed GetSessionDataStats()
    {
        if (m_DataCollectorComponent)
            return m_DataCollectorComponent.GetSessionDataStats();
 
        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, string.Empty, 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()
    {
        const 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 (IsPlatformGameConsole())
        {
            if (!isConnected)
                SCR_GamepadRemovalUI.OpenGamepadRemovalDialog();
            else
                SCR_GamepadRemovalUI.CloseGamepadRemovalDialog();
        }
        #endif
    }
 
    override void OnUserSignedOut()
    {
        GetGame().GetMenuManager().OpenMenu(ChimeraMenuPreset.MainMenu);
    }
}
 
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