SCR_BaseGameMode.c

Go to the documentation of this file.

#ifdef GMSTATS
#define GM_AI_STATS
#endif
#ifdef AISTATS
#define GM_AI_STATS
#endif

class SCR_BaseGameModeClass : BaseGameModeClass
{
}

//------------------------------------------------------------------------------------------------
/*
                                            SCR_BaseGameMode
 
Brief:
    SCR_BaseGameMode is the skeleton of all game modes which connects some of the critical aspects of spawning.
 
Important:
    A. Components and expansion:
        1. SCR_BaseGameMode automatically gathers all attached components of SCR_BaseGameModeComponent type.
        These can be used to receive events from the game mode and expand game mode functionality in modular blocks.
 
        2. SCR_RespawnSystemComponent is a component that allows to store and select player faction, loadout and spawn points
        This system is closely tied to game modes and also requires FactionManager or LoadoutManager in the world.
 
        3. SCR_RespawnHandlerComponent is a component that provides a game mode with a way of respawning.
        These can be either very generic (automatic, menu selection) and interchangable or completely game mode specific.
 
        4. Additional components like
            SCR_RespawnTimerComponent: That allows to add a timer between each respawn
            SCR_ScoringSystemComponent: That allows handling of score when a player kills or is killed
 
 
    If you want to make a system which only requires to hook on game mode events, SCR_BaseGameMode is most likely the way to go.
    Inherit the component and implement methods which you require. If you need to have a very game specific implementation that
    cannot work standalone you will have to inherit SCR_BaseGameMode and plug the communication yourself.
 
 
    B. Instances and logic:
        1. SCR_BaseGameMode is a unique entity in the world, there can currently be only one game mode.
        2. SCR_RespawnSystemComponent is a unique component attached to the game mode, there can currently be only one respawn system.
        3. SCR_RespawnHandlerComponent is a unique component attached to the game mode, there can currently be only one respawn handler.
        4. SCR_RespawnComponent is a component attached to individual PlayerController instances.
            Due to the nature of PlayerController, only the server can access all RespawnComponent(s).
            The local client will always be only to access their local RespawnComponent.
 
            For the local component you can use GetGame().GetPlayerController().GetRespawnComponent();
            For other clients as the authority you can use GetGame().GetPlayerManager().GetPlayerRespawnComponent(int playerId);
 
            This component serves as communication between the authority and client for the SCR_RespawnSystemComponent.
            If you need to request a faction, loadout or spawn point selection as the client, navigate through the component.
 
            If you need to SET a faction, loadout or spawn point as the AUTHORITY, use SCR_RespawnSystemComponent's
            DoSetPlayerFaction, DoSetPlayerLoadout and DoSetPlayerSpawnPoint method(s).
 
            If you need to convert object instances to their id/indices, you can use SCR_RespawnSystemComponent's
            GetFactionIndex, GetLoadoutIndex, GetSpawnPointIndex method(s) and/or
            GetFactionByIndex, GetLoadoutByIndex, GetSpawnPointByIdentity.
 
 
    C. Game State
        There are three game states in total that you can use, two of which are optional.
            1. Pre-game:
                This state is automatically skipped unless a
                    SCR_BaseGameModeStateComponent that has SCR_EGameModeState.PREGAME as its affiliated state
                is attached to the game mode.
 
                The SCR_PreGameGameModeStateComponent can be used to allow a time-based pre-game duration.
 
            2. Game
                This is the core game loop.
 
                By default this state is infinite, unless a
                    SCR_BaseGameModeStateComponent that has SCR_EGameModeState.GAME as its affiliated state
                is attached to the game mode with a duration set.
 
                The SCR_GameGameModeStateComponent can be used to allow a time-based pre-game duration.
 
            3. Post-game
                This is your game-over state, you can automatically transition into new world, restart the session,
                have player voting, display scoreboard or end-game screens, as desired.
 
                In addition this transition carries along SCR_GameModeEndData, providing the authority and all
                clients with additional data that can notify the gamemode about e.g. win condition, or end reason
                as implemented per game mode.
 
                This state can also have its logic expanded similarly to the Pre-game by using
                    SCR_BaseGameModeStateComponent that has SCR_EGameModeState.POSTGAME as its affiliated state
                attached to the game mode.
 
                The SCR_PostGameGameModeStateComponent can be used for this.
 
 
        You can always retrieve current game state by calling GetState() (see SCR_GameModeState)
        or IsRunning() if you're interested in the core game loop only.
 
        On each state change SCR_BaseGameMode.OnGameStateChanged() is called on both the server and all clients.
        In additionaly as implemented in this class it will automatically call OnGameModeStart() and OnGameModeEnd()
        based on the state the game is transitioning into.
*/
 
//------------------------------------------------------------------------------------------------
//~ ScriptInvokers
void SCR_BaseGameMode_OnPlayerDisconnected(int playerId, KickCauseCode cause = KickCauseCode.NONE, int timeout = -1);
typedef func SCR_BaseGameMode_OnPlayerDisconnected;
 
//~ Player or controllable entity was killed/destroyed
void SCR_BaseGameMode_OnControllableDestroyed(notnull SCR_InstigatorContextData instigatorContextData);
typedef func SCR_BaseGameMode_OnControllableDestroyed;
 
//~ Generic Event that sends over player ID
void SCR_BaseGameMode_PlayerId(int playerId);
typedef func SCR_BaseGameMode_PlayerId;
 
//~ Generic event that sends over player ID and Entity
void SCR_BaseGameMode_PlayerIdAndEntity(int playerId, IEntity player);
typedef func SCR_BaseGameMode_PlayerIdAndEntity;
 
//~ On Player role changed
void SCR_BaseGameMode_OnPlayerRoleChanged(int playerId, EPlayerRole roleFlags);
typedef func SCR_BaseGameMode_OnPlayerRoleChanged;
 
void SCR_BaseGameMode_OnResourceEnabledChanged(array<EResourceType> disabledResourceTypes);
typedef func SCR_BaseGameMode_OnResourceEnabledChanged;
 
void OnPreloadFinished();
typedef func OnPreloadFinished;
typedef ScriptInvokerBase<OnPreloadFinished> OnPreloadFinishedInvoker;
 
 
//------------------------------------------------------------------------------------------------
class SCR_BaseGameMode : BaseGameMode
{
    #ifdef ENABLE_DIAG
    #define GAME_MODE_DEBUG
    #endif
 
    #ifdef GAME_MODE_DEBUG
        static bool s_DebugRegistered = false;
    #endif
 
    const static string WB_GAME_MODE_CATEGORY = "Game Mode";
 
    protected ref ScriptInvoker Event_OnGameStart = new ScriptInvoker();
    protected ref ScriptInvoker m_OnGameEnd = new ScriptInvoker();
 
    //~ Player events
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerId> m_OnPlayerAuditSuccess = new ScriptInvokerBase<SCR_BaseGameMode_PlayerId>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerId> m_OnPlayerAuditFail = new ScriptInvokerBase<SCR_BaseGameMode_PlayerId>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerId> m_OnPlayerAuditTimeouted = new ScriptInvokerBase<SCR_BaseGameMode_PlayerId>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerId> m_OnPlayerAuditRevived = new ScriptInvokerBase<SCR_BaseGameMode_PlayerId>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerId> m_OnPlayerConnected = new ScriptInvokerBase<SCR_BaseGameMode_PlayerId>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerId> m_OnPlayerRegistered = new ScriptInvokerBase<SCR_BaseGameMode_PlayerId>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_OnPlayerDisconnected> m_OnPlayerDisconnected = new ScriptInvokerBase<SCR_BaseGameMode_OnPlayerDisconnected>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_OnPlayerDisconnected> m_OnPostCompPlayerDisconnected = new ScriptInvokerBase<SCR_BaseGameMode_OnPlayerDisconnected>(); //~ Called after the GameMode Components are notified that a player was disconnected
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerIdAndEntity> m_OnPlayerSpawned = new ScriptInvokerBase<SCR_BaseGameMode_PlayerIdAndEntity>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_OnControllableDestroyed> m_OnPlayerKilled = new ScriptInvokerBase<SCR_BaseGameMode_OnControllableDestroyed>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_OnControllableDestroyed> m_OnControllableDestroyed = new ScriptInvokerBase<SCR_BaseGameMode_OnControllableDestroyed>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_PlayerIdAndEntity> m_OnPlayerDeleted = new ScriptInvokerBase<SCR_BaseGameMode_PlayerIdAndEntity>();
    protected ref ScriptInvokerBase<SCR_BaseGameMode_OnPlayerRoleChanged> m_OnPlayerRoleChange = new ScriptInvokerBase<SCR_BaseGameMode_OnPlayerRoleChanged>();
 
    protected ref ScriptInvoker m_OnWorldPostProcess = new ScriptInvoker();
    protected ref ScriptInvoker m_OnControllableSpawned = new ScriptInvoker();
    protected ref ScriptInvoker m_OnControllableDeleted = new ScriptInvoker();
    protected ref ScriptInvoker m_OnGameModeEnd = new ScriptInvoker();
 
    protected ref ScriptInvokerBase<SCR_BaseGameMode_OnResourceEnabledChanged> m_OnResourceTypeEnabledChanged;
 
    protected SCR_EPauseReason m_ePauseReasons;
 
    //------------------------------------------------------------------------------------------------
    //
    // World Editor attributes meant for Debug or Testing
    //
    [Attribute("0", uiwidget: UIWidgets.Flags, "Test Game Flags for when you run mission via WE.", "", ParamEnumArray.FromEnum(EGameFlags), WB_GAME_MODE_CATEGORY)]
    protected EGameFlags m_eTestGameFlags;
 
    [Attribute("1", uiwidget: UIWidgets.CheckBox, "When false, then Game mode need to handle its very own spawning. If true, then simple default logic is used to spawn and respawn automatically.", category: WB_GAME_MODE_CATEGORY)]
    protected bool m_bAutoPlayerRespawn;
 
    [Attribute("1", uiwidget: UIWidgets.CheckBox, "When true, allows players to freely swap their faction after initial assignment.", category: WB_GAME_MODE_CATEGORY)]
    protected bool m_bAllowFactionChange;
 
    [Attribute("30", UIWidgets.Slider, params: "-1 600 1", desc: "Time in seconds after which the mission is reloaded upon completion or -1 to disable it.", category: WB_GAME_MODE_CATEGORY)]
    private float m_fAutoReloadTime;
 
    //------------------------------------------------------------------------------------------------
    //
    // Game End Screen States info
    //

    [RplProp(onRplName: "OnGameStateChanged")]
    private SCR_EGameModeState m_eGameState = SCR_EGameModeState.PREGAME;

    [RplProp()]
    private ref SCR_GameModeEndData m_pGameEndData = new SCR_GameModeEndData();
 
    [Attribute("1", uiwidget: UIWidgets.CheckBox, "If checked the elapsed time will only advance if at least one player is present on the server.", category: WB_GAME_MODE_CATEGORY)]
    protected bool m_bAdvanceTimeRequiresPlayers;

    [RplProp(condition: RplCondition.NoOwner)]
    protected float m_fTimeElapsed;

    [RplProp()]
    protected bool m_bAllowControls = true;

    protected float m_fTimeCorrectionInterval = 10.0;

    protected float m_fLastTimeCorrection;

    [RplProp()]
    protected bool m_bIsHosted;
 
    //------------------------------------------------------------------------------------------------
    //
    // Required components
    //
    protected RplComponent m_RplComponent;
    protected SCR_GameModeHealthSettings m_pGameModeHealthSettings;
    protected SCR_RespawnSystemComponent m_pRespawnSystemComponent;
    protected SCR_BaseScoringSystemComponent m_ScoringSystemComponent;
    protected SCR_RespawnTimerComponent m_RespawnTimerComponent;

    protected ref array<SCR_BaseGameModeComponent> m_aAdditionalGamemodeComponents = new array<SCR_BaseGameModeComponent>();

    protected ref map<int, vector> m_mPlayerSpawnPosition = new map<int, vector>();

    protected ref map<SCR_EGameModeState, SCR_BaseGameModeStateComponent> m_mStateComponents = new map<SCR_EGameModeState, SCR_BaseGameModeStateComponent>();

    [Attribute("1", category: WB_GAME_MODE_CATEGORY)]
    protected bool m_bUseSpawnPreload;

    [Attribute("0", desc: "Is the autotune radio feature enabled in this gamemode")]
    protected bool m_bAutotuneEnabled;
 
    protected ref SCR_SpawnPreload m_SpawnPreload;
    protected ref OnPreloadFinishedInvoker m_OnPreloadFinished;
 
    //~ Any Resource types that is set here is a disabled resource type
    [Attribute(desc: "List of disabled Resource Types in the GameMode.", uiwidget: UIWidgets.SearchComboBox, enums: ParamEnumArray.FromEnum(EResourceType), category: "Game Mode"), RplProp(onRplName: "OnResourceTypeEnabledChanged")]
    protected ref array<EResourceType> m_aDisabledResourceTypes;
 
    //~ Time stamp when end game was called
    protected WorldTimestamp m_GameEndTimeStamp = null;
 
    //------------------------------------------------------------------------------------------------
    bool IsResourceTypeEnabled(EResourceType resourceType = EResourceType.SUPPLIES)
    {
        return !m_aDisabledResourceTypes.Contains(resourceType);
    }
 
    //------------------------------------------------------------------------------------------------
    int GetDisabledResourceTypes(inout notnull array<EResourceType> disabledResourceTypes)
    {
        disabledResourceTypes.Copy(m_aDisabledResourceTypes);
        return disabledResourceTypes.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    void SetResourceTypeEnabled(bool enable, EResourceType resourceType = EResourceType.SUPPLIES, int playerID = -1)
    {
        int index = m_aDisabledResourceTypes.Find(resourceType);
 
        //~ Already Enabled/Disabled
        if ((index < 0) == enable)
            return;
 
        if (!enable)
            m_aDisabledResourceTypes.Insert(resourceType);
        else
            m_aDisabledResourceTypes.Remove(index);
 
        Replication.BumpMe();
 
        //~ Call on resourceType changed for server as well
        if (IsMaster())
            OnResourceTypeEnabledChanged();
 
        if (resourceType == EResourceType.SUPPLIES)
        {
            if (enable)
                SCR_NotificationsComponent.SendToEveryone(ENotification.EDITOR_ATTRIBUTES_ENABLE_GLOBAL_SUPPLY_USAGE, playerID);
            else
                SCR_NotificationsComponent.SendToEveryone(ENotification.EDITOR_ATTRIBUTES_DISABLE_GLOBAL_SUPPLY_USAGE, playerID);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnResourceTypeEnabledChanged()
    {
        if (m_OnResourceTypeEnabledChanged)
            m_OnResourceTypeEnabledChanged.Invoke(m_aDisabledResourceTypes);
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvokerBase<SCR_BaseGameMode_OnResourceEnabledChanged> GetOnResourceTypeEnabledChanged()
    {
        if (!m_OnResourceTypeEnabledChanged)
            m_OnResourceTypeEnabledChanged = new ScriptInvokerBase<SCR_BaseGameMode_OnResourceEnabledChanged>();
 
        return m_OnResourceTypeEnabledChanged;
    }
 
    //------------------------------------------------------------------------------------------------
    bool CanStartSpawnPreload()
    {
        ChimeraWorld world = GetGame().GetWorld();
        return (!world.IsGameTimePaused() && m_bUseSpawnPreload);
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsRunning()
    {
        return m_eGameState == SCR_EGameModeState.GAME;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_EGameModeState GetState()
    {
        return m_eGameState;
    }
 
    //------------------------------------------------------------------------------------------------
    sealed bool IsMaster()
    {
        return (!m_RplComponent || m_RplComponent.IsMaster());
    }
 
    //------------------------------------------------------------------------------------------------
    float GetElapsedTime()
    {
        return m_fTimeElapsed;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetTimeLimit()
    {
        SCR_BaseGameModeStateComponent stateComponent = GetStateComponent(SCR_EGameModeState.GAME);
        if (stateComponent)
            return stateComponent.GetDuration();
 
        return 0.0;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetRemainingTime()
    {
        float timeLimit = GetTimeLimit();
        if (!IsRunning() || timeLimit <= 0)
            return -1;
 
        float time = timeLimit - GetElapsedTime();
        if (time < 0)
            time = 0;
 
        return time;
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsHosted()
    {
        return m_bIsHosted;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnGameStateChanged()
    {
        SCR_EGameModeState newState = GetState();
        Print("SCR_BaseGameMode::OnGameStateChanged = " + SCR_Enum.GetEnumName(SCR_EGameModeState, newState));
 
        //We handle the OnGameModeEnd and OnGameModeStart events here
        //Because this is the only replicated call.
        //And we propagate it to the components here for robusty in case of overriding those methods
        switch (newState)
        {
            case SCR_EGameModeState.POSTGAME:
                OnGameModeEnd(m_pGameEndData);
                foreach (SCR_BaseGameModeComponent component : m_aAdditionalGamemodeComponents)
                {
                    component.OnGameModeEnd(m_pGameEndData);
                }
                break;
 
            case SCR_EGameModeState.GAME:
                OnGameModeStart();
                foreach (SCR_BaseGameModeComponent component : m_aAdditionalGamemodeComponents)
                {
                    component.OnGameModeStart();
                }
                break;
        }
 
        // Dispatch events
        foreach (SCR_BaseGameModeComponent component : m_aAdditionalGamemodeComponents)
        {
            component.OnGameStateChanged(newState);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void CachePlayerSpawnPosition(int playerID, vector position)
    {
        m_mPlayerSpawnPosition.Set(playerID, position);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_RespawnSystemComponent GetRespawnSystemComponent()
    {
        return m_pRespawnSystemComponent;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_GameModeHealthSettings GetGameModeHealthSettings()
    {
        return m_pGameModeHealthSettings;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_BaseScoringSystemComponent GetScoringSystemComponent()
    {
        return m_ScoringSystemComponent;
    }
 
    //------------------------------------------------------------------------------------------------
    void StartGameMode()
    {
        if (!IsMaster())
            return;
 
        if (IsRunning())
        {
            Print("Trying to start a gamemode that is already running.", LogLevel.WARNING);
            return;
        }
 
#ifdef ENABLE_DIAG
        if (!Replication.IsRunning()) // You cannot pause in MP, thus this option is only available in SP
            DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_SINGLEPLAYER_DISABLE_TIME_PAUSE, "", "Disable time pause", "Game");
#endif
 
        m_fTimeElapsed = 0.0;
        m_eGameState = SCR_EGameModeState.GAME;
        Replication.BumpMe();
 
        // Raise event for authority
        OnGameStateChanged();
    }
 
    //------------------------------------------------------------------------------------------------
    protected bool CanStartGameMode()
    {
        SCR_BaseGameModeStateComponent pregame = GetStateComponent(SCR_EGameModeState.PREGAME);
        if (!pregame)
            return true;
 
        return pregame.CanAdvanceState(SCR_EGameModeState.GAME);
    }
 
    //------------------------------------------------------------------------------------------------
    void EndGameMode(SCR_GameModeEndData endData)
    {
        if (!IsMaster())
            return;
 
        // Already over
        if (!IsRunning())
        {
            Print("Trying to end a gamemode that is not running.", LogLevel.WARNING);
            return;
        }
 
        if (endData == null)
            endData = SCR_GameModeEndData.CreateSimple();
 
        m_pGameEndData = endData;
        m_eGameState = SCR_EGameModeState.POSTGAME;
        Replication.BumpMe();
 
        // Raise event for authority
        OnGameStateChanged();
    }

    SCR_GameModeEndData GetEndGameData()
    {
        if (m_eGameState != SCR_EGameModeState.POSTGAME)
            return null;
        else
            return m_pGameEndData;
    }
 
    ScriptInvoker GetOnGameStart()
    {
        return Event_OnGameStart;
    }
    ScriptInvoker GetOnGameEnd()
    {
        return m_OnGameEnd;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerId> GetOnPlayerAuditSuccess()
    {
        return m_OnPlayerAuditSuccess;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerId> GetOnPlayerAuditFail()
    {
        return m_OnPlayerAuditFail;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerId> GetOnPlayerAuditTimeouted()
    {
        return m_OnPlayerAuditTimeouted;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerId> GetOnPlayerAuditRevived()
    {
        return m_OnPlayerAuditRevived;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerId> GetOnPlayerConnected()
    {
        return m_OnPlayerConnected;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerId> GetOnPlayerRegistered()
    {
        return m_OnPlayerRegistered;
    }
    ScriptInvokerBase<SCR_BaseGameMode_OnPlayerDisconnected> GetOnPlayerDisconnected()
    {
        return m_OnPlayerDisconnected;
    }

    ScriptInvokerBase<SCR_BaseGameMode_OnPlayerDisconnected> GetOnPostCompPlayerDisconnected()
    {
        return m_OnPostCompPlayerDisconnected;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerIdAndEntity> GetOnPlayerSpawned()
    {
        return m_OnPlayerSpawned;
    }
    ScriptInvokerBase<SCR_BaseGameMode_OnControllableDestroyed> GetOnPlayerKilled()
    {
        return m_OnPlayerKilled;
    }
    ScriptInvokerBase<SCR_BaseGameMode_PlayerIdAndEntity> GetOnPlayerDeleted()
    {
        return m_OnPlayerDeleted;
    }
    ScriptInvokerBase<SCR_BaseGameMode_OnPlayerRoleChanged> GetOnPlayerRoleChange()
    {
        return m_OnPlayerRoleChange;
    }
    ScriptInvoker GetOnWorldPostProcess()
    {
        return m_OnWorldPostProcess;
    }
    ScriptInvoker GetOnControllableSpawned()
    {
        return m_OnControllableSpawned;
    }
    ScriptInvokerBase<SCR_BaseGameMode_OnControllableDestroyed> GetOnControllableDestroyed()
    {
        return m_OnControllableDestroyed;
    }
    ScriptInvoker GetOnControllableDeleted()
    {
        return m_OnControllableDeleted;
    }

    ScriptInvoker GetOnGameModeEnd()
    {
        return m_OnGameModeEnd;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnGameModeStart()
    {
        #ifdef GM_AI_STATS
        if (IsGameModeStatisticsEnabled())
        {
            if (!SCR_GameModeStatistics.IsRecording())
                SCR_GameModeStatistics.StartRecording();
        }
        #endif
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnGameModeEnd(SCR_GameModeEndData endData)
    {
        HandleOnGameModeEndSaveData();
 
        ChimeraWorld world = GetGame().GetWorld();
        if (world)
            m_GameEndTimeStamp = world.GetLocalTimestamp();
 
        m_OnGameModeEnd.Invoke(endData);
 
        #ifdef GM_AI_STATS
        if (IsGameModeStatisticsEnabled())
        {
            if (SCR_GameModeStatistics.IsRecording())
                SCR_GameModeStatistics.StopRecording();
        }
        #endif
 
        // Automatically restart the session on game mode end if enabled
        float reloadTime = GetAutoReloadDelay();
        if (reloadTime > 0)
            GetGame().GetCallqueue().CallLater(RestartSession, reloadTime * 1000.0, false);
        else if (reloadTime == 0)
            RestartSession();
        else
            TryShutdownServer();
    }
 
    //------------------------------------------------------------------------------------------------
    protected void HandleOnGameModeEndSaveData()
    {
        if (!IsMaster())
            return;
 
        // After the game completes no more saving needs to be done
        GetGame().GetSaveGameManager().SetSavingAllowed(false);
 
        const PersistenceSystem persistence = PersistenceSystem.GetInstance();
        if (System.IsCLIParam("keepSessionSave") || (persistence && persistence.ShouldKeepSessionData()))
            return;
 
        // We only delete on DS or workbench for now
        #ifndef WORKBENCH
        if (RplSession.Mode() != RplMode.Dedicated)
            return;
        #endif
 
        if (persistence)
            persistence.ClearStorage(PersistenceSessionStorage);
 
        const SaveGame currentSave = GetGame().GetSaveGameManager().GetActiveSave();
        if (currentSave)
            GetGame().GetSaveGameManager().Purge(currentSave.GetMissionResource(), currentSave.GetPlaythroughNumber());
    }
 
    //------------------------------------------------------------------------------------------------
    WorldTimestamp GetGameEndTimeStamp()
    {
        return m_GameEndTimeStamp;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetAutoReloadDelay()
    {
        // Allow the server owner to override it via -autoReload=TIME
        string autoReloadTimeString;
        if (System.GetCLIParam("autoreload", autoReloadTimeString))
        {
            float val = -1;
            if (!autoReloadTimeString.IsEmpty() && autoReloadTimeString != "disabled")
                val = Math.Clamp(autoReloadTimeString.ToFloat(), -1, 600);
 
            return val;
        }
 
        return m_fAutoReloadTime;
    }

    protected void RestartSession()
    {
        if (!IsMaster())
            return;
 
        if (TryShutdownServer())
            return;
 
        GameStateTransitions.RequestScenarioRestart();
    }
 
    //------------------------------------------------------------------------------------------------
    // Attempts to shutdown the server when a CLI parameter is present
    protected sealed bool TryShutdownServer()
    {
        if (!System.IsConsoleApp() || !Replication.IsServer())
            return false;
 
        string outValue;
        if (System.GetCLIParam("autoshutdown", outValue))
        {
            GameStateTransitions.RequestGameTerminateTransition();
            return true;
        }
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnGameStart()
    {
        BackendApi backendApi = GetGame().GetBackendApi();
 
        if (IsMaster())
            backendApi.NewSession();
 
        super.OnGameStart();
        Event_OnGameStart.Invoke();
    }
 
    //------------------------------------------------------------------------------------------------
    void OnGameEnd()
    {
        m_OnGameEnd.Invoke();
 
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnGameEnd();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsFactionChangeAllowed()
    {
        return m_bAllowFactionChange;
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnPlayerAuditSuccess(int iPlayerID)
    {
        m_OnPlayerAuditSuccess.Invoke(iPlayerID);
 
        if (IsMaster())
            m_pRespawnSystemComponent.OnPlayerAuditSuccess_S(iPlayerID);
 
        // Dispatch event to child components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerAuditSuccess(iPlayerID);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnPlayerAuditFail(int iPlayerID)
    {
        m_OnPlayerAuditFail.Invoke(iPlayerID);
 
        // Dispatch event to child components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerAuditFail(iPlayerID);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnPlayerAuditTimeouted(int iPlayerID)
    {
        super.OnPlayerAuditTimeouted(iPlayerID);
        m_OnPlayerAuditTimeouted.Invoke(iPlayerID);
 
        // Dispatch event to child components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerAuditTimeouted(iPlayerID);
        }
    };
 
    //------------------------------------------------------------------------------------------------
    override void OnPlayerAuditRevived(int iPlayerID)
    {
        super.OnPlayerAuditRevived(iPlayerID);
        m_OnPlayerAuditRevived.Invoke(iPlayerID);
 
        // Dispatch event to child components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerAuditRevived(iPlayerID);
        }
    };
 
    //------------------------------------------------------------------------------------------------
    override void OnPlayerConnected(int playerId)
    {
        if (!m_bIsHosted)
        {
            m_bIsHosted = GetGame().GetPlayerManager().GetPlayerController(playerId).GetRplIdentity() == RplIdentity.Local();
            Replication.BumpMe();
        }
 
        m_OnPlayerConnected.Invoke(playerId);
        // Dispatch event to child components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerConnected(playerId);
        }
 
 
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnPlayerDisconnected(int playerId, KickCauseCode cause, int timeout)
    {
        m_OnPlayerDisconnected.Invoke(playerId, cause, timeout);
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerDisconnected(playerId, cause, timeout);
        }
        m_OnPostCompPlayerDisconnected.Invoke(playerId, cause, timeout);
 
        if (IsMaster())
        {
            IEntity character = GetGame().GetPlayerManager().GetPlayerControlledEntity(playerId);
            if (character)
            {
                // If driving a vehicle it should be stopped as gracefully as possible to avoid crashing into nearby obstacles with passengers.
                const CompartmentAccessComponent compAccess = CompartmentAccessComponent.Cast(character.FindComponent(CompartmentAccessComponent));
                if (compAccess)
                {
                    const PilotCompartmentSlot pilotCompartment = PilotCompartmentSlot.Cast(compAccess.GetCompartment());
                    if (pilotCompartment)
                    {
                        IEntity vehicle = pilotCompartment.GetVehicle();
                        CarControllerComponent carController = CarControllerComponent.Cast(vehicle.FindComponent(CarControllerComponent));
                        if (carController)
                        {
                            carController.Shutdown();
                            carController.StopEngine(false);
                            carController.SetPersistentHandBrake(true);
                        }
                        else
                        {
                            HelicopterControllerComponent heliController = HelicopterControllerComponent.Cast(vehicle.FindComponent(HelicopterControllerComponent));
                            if (heliController)
                            {
                                heliController.LockPilotControls(false);
                                heliController.SetPersistentWheelBrake(true);
                                heliController.SetAutohoverEnabled(true);
                            }
                        }
                    }
                }
            }
 
            // If conditions to allow reconnect pass, skip the entity delete
            SCR_ReconnectComponent reconnect = SCR_ReconnectComponent.GetInstance();
            if (reconnect && reconnect.HandlePlayerDisconnect(playerId, cause))
            {
                if (character)
                {
                    CharacterControllerComponent charController = CharacterControllerComponent.Cast(character.FindComponent(CharacterControllerComponent));
                    if (charController)
                        charController.SetMovement(0, vector.Forward);
 
                    character = null; // Avoid deleting it
                }
            }
 
            // RespawnSystemComponent is not a SCR_BaseGameModeComponent, so for now we have to propagate these events manually.
            m_pRespawnSystemComponent.OnPlayerDisconnected_S(playerId, cause, timeout);
 
            if (character)
            {
                m_pRespawnSystemComponent.OnPlayerEntityCleanup_S(character);
                RplComponent.DeleteRplEntity(character, false);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnPlayerRegistered(int playerId)
    {
        m_OnPlayerRegistered.Invoke(playerId);
 
        // RespawnSystemComponent is not a SCR_BaseGameModeComponent, so for now we have to
        // propagate these events manually.
        if (IsMaster())
            m_pRespawnSystemComponent.OnPlayerRegistered_S(playerId);
 
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerRegistered(playerId);
        }
 
        #ifdef GMSTATS
        if (IsGameModeStatisticsEnabled())
            SCR_GameModeStatistics.RecordConnection(playerId, GetGame().GetPlayerManager().GetPlayerName(playerId));
        #endif
 
        // TODO: Remove once peertools properly invoke the audit success from gamecode and identity is available already during registered event.
        if (RplSession.Mode() == RplMode.Listen && playerId > 1)
        {
            OnPlayerAuditSuccess(playerId);
        }
        else if (RplSession.Mode() == RplMode.Dedicated)
        {
            string configPath;
            if (!System.GetCLIParam("config", configPath) || configPath.IsEmpty())
                OnPlayerAuditSuccess(playerId);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected override bool HandlePlayerKilled(int playerId, IEntity playerEntity, IEntity killerEntity, notnull Instigator killer)
    {
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            // First component that returns false overrides the behaviour and can handle
            // the kill based on their respective needs
            if (!comp.HandlePlayerKilled(playerId, playerEntity, killerEntity, killer))
            {
                OnPlayerKilledHandled(playerId, playerEntity, killerEntity, killer);
                return false;
            }
        }
 
        // Handle automatically
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void LogKillEvent(notnull SCR_InstigatorContextData instigatorContext)
    {
        int victimPlayerId = instigatorContext.GetVictimPlayerID();
        if (victimPlayerId < 1)
            return; // only log killed players
 
        string incidentType;
        SCR_ECharacterDeathStatusRelations relation = instigatorContext.GetVictimKillerRelation();
        switch (relation)
        {
            case SCR_ECharacterDeathStatusRelations.KILLED_BY_ENEMY_PLAYER:
            case SCR_ECharacterDeathStatusRelations.KILLED_BY_ENEMY_AI:
                incidentType = " ENEMY";
                break;
 
            case SCR_ECharacterDeathStatusRelations.KILLED_BY_FRIENDLY_PLAYER:
            case SCR_ECharacterDeathStatusRelations.KILLED_BY_FRIENDLY_AI:
                incidentType = " TK";
                break;
 
            case SCR_ECharacterDeathStatusRelations.KILLED_BY_UNLIMITED_EDITOR:
                incidentType = " GM";
                break;
 
            default:
                incidentType = " " + typename.EnumToString(SCR_ECharacterDeathStatusRelations, relation);
                break;
        }
 
        string victimIdentity = SCR_PlayerIdentityUtils.GetPlayerLogInfo(victimPlayerId);
        
        int killerPlayerId = instigatorContext.GetKillerPlayerID();
        string killerIdentity;
        if (killerPlayerId < 1) // AI
            killerIdentity = " was killed by AI";
        else if (victimPlayerId == killerPlayerId) // suicide
            killerIdentity = " killed himself!";
        else
            killerIdentity = " was killed by " + SCR_PlayerIdentityUtils.GetPlayerLogInfo(killerPlayerId);
 
        SCR_ChimeraCharacter victim = SCR_ChimeraCharacter.Cast(instigatorContext.GetVictimEntity());
        vector corpsePosition;
        string victimPosition;
        string causeOfDeath;
        if (victim)
        {
            Faction faction = victim.GetFaction();
            if (faction)
                victimIdentity += " from " + faction.GetFactionKey() + " faction";
 
            corpsePosition = victim.GetOrigin();
            victimPosition = " at " + corpsePosition.ToString();
 
            if (relation != SCR_ECharacterDeathStatusRelations.KILLED_BY_UNLIMITED_EDITOR)
            {
                SCR_CharacterDamageManagerComponent dmgMgr = SCR_CharacterDamageManagerComponent.Cast(victim.GetDamageManager());
                array<ref BaseDamageEffect> damageHistory = {};
                dmgMgr.GetDamageHistory(damageHistory);
                BaseDamageEffect effect;
                EDamageType dmgType;
                HitZone hitZone;
                HitZone defaultHitZone = dmgMgr.GetDefaultHitZone();
                for (int i = damageHistory.Count() - 1; i >= 0; i--)
                {
                    effect = damageHistory[i];
                    if (!effect)
                    {
                        effect = null;
                        continue;
                    }
 
                    dmgType = effect.GetDamageType();
                    if (dmgType == EDamageType.HEALING && dmgType == EDamageType.REGENERATION)
                    {
                        effect = null;
                        continue;
                    }
 
                    if (dmgType == EDamageType.BLEEDING && effect.GetTotalDamage() < 1)
                    {
                        effect = null;
                        continue; // bleeding can be added at the moment when projectile deals lethal damage, and thus it may have not be the cause of death
                    }
 
                    if (effect.GetInstigator().GetInstigatorPlayerID() != killerPlayerId)
                    {
                        effect = null;
                        continue;
                    }
 
                    hitZone = effect.GetAffectedHitZone();
                    if (hitZone && hitZone != defaultHitZone && hitZone.GetName() != "Resilience")
                        break;
 
                    effect = null;
                }
 
                if (effect)
                {
                    causeOfDeath = " With last inflicted damage type " + typename.EnumToString(EDamageType, dmgType);
                    if (hitZone)
                        causeOfDeath += " to the '" + hitZone.GetName() + "' hit zone";
                }
            }
        }
 
        LogLevel logLevel = LogLevel.NORMAL;
 
        string messageType = "INFO";
        string killerPosition;
        string victimDisguiseState;
        if (relation != SCR_ECharacterDeathStatusRelations.KILLED_BY_UNLIMITED_EDITOR && victimPlayerId != killerPlayerId)
        {
            SCR_ChimeraCharacter killer = SCR_ChimeraCharacter.Cast(instigatorContext.GetKillerEntity());
            if (killer)
            {
                Faction faction = killer.GetFaction();
                if (faction)
                    killerIdentity += " from " + faction.GetFactionKey() + " faction";
 
                vector pos = killer.GetOrigin();
                killerPosition = string.Format(" who was at that time at %1 [%2m away from the corpse].", pos.ToString(), vector.Distance(pos, corpsePosition).ToString(lenDec: 1));
 
                if (killerPlayerId > 0)
                { // only check the position of the killer in case of players
                    TraceParam param = new TraceParam();
                    param.Start = pos + vector.Up * 0.1;
                    param.End = param.Start + vector.Up * (-1);
                    param.Flags = TraceFlags.WORLD | TraceFlags.ENTS;
                    param.Exclude = killer;
                    param.LayerMask = EPhysicsLayerPresets.Projectile;
                    float traceDistance = killer.GetWorld().TraceMove(param, FilterCallback);
                    if (traceDistance >= 1 && param.TraceEnt == null)
                    {
                        logLevel = LogLevel.WARNING;
                        killerPosition += " No surface found within 1m under that position!";
                        messageType = "WARNING";
                    }
                }
            }
            else if (killerPlayerId > 0)
            {
                Faction faction = SCR_FactionManager.SGetPlayerFaction(killerPlayerId);
                if (faction)
                    killerIdentity += " from " + faction.GetFactionKey() + " faction";
            }
 
            if (instigatorContext.GetVictimDisguiseType() == SCR_ECharacterDisguiseType.HOSTILE_FACTION)
                victimDisguiseState = " while being disguised as enemy";
        }
 
        PrintFormat("%1: KILL%2: %3%4%5%6%7%8", messageType, incidentType, victimIdentity, victimPosition, victimDisguiseState, killerIdentity, killerPosition, causeOfDeath, level: logLevel);
    }
 
    //------------------------------------------------------------------------------------------------
    protected bool FilterCallback(IEntity e)
    {
        if (!e)
            return false;
 
        IEntity parent = e.GetParent();
        while (parent)
        {
            if (ChimeraCharacter.Cast(parent))
                return false;
 
            parent = parent.GetParent();
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnPlayerKilled(int playerId, IEntity playerEntity, IEntity killerEntity, notnull Instigator killer)
    {
        super.OnPlayerKilled(playerId, playerEntity, killerEntity, killer);
 
        //~ Create instigator context data to determine what the relation is between victim and killer and control types of the victim and killer
        SCR_InstigatorContextData instigatorContextData = new SCR_InstigatorContextData(playerId, playerEntity, killerEntity, killer);
 
        //~ Send on player killed event
        m_OnPlayerKilled.Invoke(instigatorContextData);
 
 
        // RespawnSystemComponent is not a SCR_BaseGameModeComponent, so for now we have to
        // propagate these events manually.
        if (IsMaster())
            m_pRespawnSystemComponent.OnPlayerKilled_S(playerId, playerEntity, killerEntity, killer);
 
        // Dispatch events to children components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerKilled(instigatorContextData);
        }
 
        #ifdef GMSTATS
        if (IsGameModeStatisticsEnabled())
            SCR_GameModeStatistics.RecordDeath(playerId, playerEntity, killerEntity, killer);
        #endif
 
        //~ Call extended OnPlayerKilled
        OnPlayerKilledEx(instigatorContextData);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnPlayerKilledEx(notnull SCR_InstigatorContextData instigatorContextData);
 
    //------------------------------------------------------------------------------------------------
    protected void OnPlayerKilledHandled(int playerId, IEntity playerEntity, IEntity killerEntity, notnull Instigator killer)
    {
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
            comp.OnPlayerKilledHandled(playerId, playerEntity, killerEntity, killer);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnPlayerDeleted(int playerId, IEntity player)
    {
        // RespawnSystemComponent is not a SCR_BaseGameModeComponent, so for now we have to
        // propagate these events manually.
        if (IsMaster())
            m_pRespawnSystemComponent.OnPlayerDeleted_S(playerId);
 
        //super.OnPlayerDeleted(playerId, player);
        m_OnPlayerDeleted.Invoke(playerId, player);
 
        // Dispatch events to children components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerDeleted(playerId, player);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnPlayerRoleChange(int playerId, EPlayerRole roleFlags)
    {
        m_OnPlayerRoleChange.Invoke(playerId, roleFlags);
 
        // Dispatch events to children components
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnPlayerRoleChange(playerId, roleFlags);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override event void OnWorldPostProcess(World world)
    {
        m_OnWorldPostProcess.Invoke(world);
 
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnWorldPostProcess(world);
        }
    };
 
    //------------------------------------------------------------------------------------------------
    /*
        When a controllable entity is spawned, this event is raised.
        \param entity Spawned entity that raised this event
    */
    protected override void OnControllableSpawned(IEntity entity)
    {
        super.OnControllableSpawned(entity);
        m_OnControllableSpawned.Invoke(entity);
 
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnControllableSpawned(entity);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    /*
        When a controllable entity is destroyed, this event is raised.
        \param entity Destroyed entity that raised this event
        \param killerEntity Entity that killed the entity (can be null)
        \param killer Instigator entity that destroyed our victim
    */
    protected override void OnControllableDestroyed(IEntity entity, IEntity killerEntity, notnull Instigator instigator)
    {
        super.OnControllableDestroyed(entity, killerEntity, instigator);
 
        //~ Create instigator context data to determine what the relation is between victim and killer and control types of the victim and killer
        SCR_InstigatorContextData instigatorContextData = new SCR_InstigatorContextData(-1, entity, killerEntity, instigator);
        m_OnControllableDestroyed.Invoke(instigatorContextData);
 
        //~ Debug print to see death types of characters
        if (ChimeraCharacter.Cast(entity) && DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_CHARACTER_KILLED_LOG))
        {
            Print("Character Killed: " + typename.EnumToString(SCR_ECharacterDeathStatusRelations, instigatorContextData.GetVictimKillerRelation()) +
            " | Victim: " + typename.EnumToString(SCR_ECharacterControlType, instigatorContextData.GetVictimCharacterControlType()) + ", id: " + instigatorContextData.GetVictimPlayerID() + ", Disguise type: " + typename.EnumToString(SCR_ECharacterDisguiseType, instigatorContextData.GetVictimDisguiseType()) +
            " | Killer: " + typename.EnumToString(SCR_ECharacterControlType, instigatorContextData.GetKillerCharacterControlType()) + ", id: " + instigatorContextData.GetKillerPlayerID() + ", Disguise type: " + typename.EnumToString(SCR_ECharacterDisguiseType, instigatorContextData.GetKillerDisguiseType()),
            LogLevel.NORMAL);
        }
 
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnControllableDestroyed(instigatorContextData);
        }
 
        //~ Call extended OnControllableDestroyed
        OnControllableDestroyedEx(instigatorContextData);
        if (IsMaster())
            LogKillEvent(instigatorContextData);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnControllableDestroyedEx(notnull SCR_InstigatorContextData instigatorContextData);
 
    //------------------------------------------------------------------------------------------------
    /*
        Prior to a controllable entity being DELETED, this event is raised.
        Controllable entity is such that has BaseControllerComponent and can be
        possessed either by a player, an AI or stay unpossessed.
        \param entity Entity about to be deleted
    */
    protected override void OnControllableDeleted(IEntity entity)
    {
        super.OnControllableDeleted(entity);
        m_OnControllableDeleted.Invoke(entity);
 
        foreach (SCR_BaseGameModeComponent comp : m_aAdditionalGamemodeComponents)
        {
            comp.OnControllableDeleted(entity);
        }
 
        // Ensure that controlled entity is a player
        const int playerId = GetGame().GetPlayerManager().GetPlayerIdFromControlledEntity(entity);
        if (playerId > 0)
            OnPlayerDeleted(playerId, entity);
    }
 
    //------------------------------------------------------------------------------------------------
    void OnSpawnPlayerEntityFailure_S(SCR_SpawnRequestComponent requestComponent, SCR_SpawnHandlerComponent handlerComponent, IEntity entity, SCR_SpawnData data, SCR_ESpawnResult reason)
    {
        foreach (SCR_BaseGameModeComponent component : m_aAdditionalGamemodeComponents)
            component.OnSpawnPlayerEntityFailure_S(requestComponent, handlerComponent, entity, data, reason);
    }
 
    //------------------------------------------------------------------------------------------------
    void OnPlayerEntityChanged_S(int playerId, IEntity previousEntity, IEntity newEntity)
    {
    }

    bool PreparePlayerEntity_S(SCR_SpawnRequestComponent requestComponent, SCR_SpawnHandlerComponent handlerComponent, SCR_SpawnData data, IEntity entity)
    {
        // Example(s):
        //  - load some data from storage, fill inventory with stored items
        //  - apply loaded data by setting provided entity to bleed for a certain amount
        //  - drop character unconscious?
 
        foreach (SCR_BaseGameModeComponent component : m_aAdditionalGamemodeComponents)
        {
            if (!component.PreparePlayerEntity_S(requestComponent, handlerComponent, data, entity))
                return false;
        }
 
        // Entity preparation has succeeded
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    void OnPlayerSpawnFinalize_S(SCR_SpawnRequestComponent requestComponent, SCR_SpawnHandlerComponent handlerComponent, SCR_SpawnData data, IEntity entity)
    {
        SCR_SpawnPointSpawnData spawnPointData = SCR_SpawnPointSpawnData.Cast(data);
        if (spawnPointData)
        {
            OnPlayerSpawnOnPoint_S(requestComponent, handlerComponent, entity, spawnPointData);
        }
 
        foreach (SCR_BaseGameModeComponent component : m_aAdditionalGamemodeComponents)
            component.OnPlayerSpawnFinalize_S(requestComponent, handlerComponent, data, entity);
 
        SCR_PlayerLoadoutComponent loadoutComp = SCR_PlayerLoadoutComponent.Cast(requestComponent.GetPlayerController().FindComponent(SCR_PlayerLoadoutComponent));
        if (!SCR_PossessSpawnData.Cast(data) // hotfix when player is spawned through game master, their loadout would change to the saved loadout
            && loadoutComp && loadoutComp.GetLoadout())
            loadoutComp.GetLoadout().OnLoadoutSpawned(GenericEntity.Cast(entity), requestComponent.GetPlayerId());
 
        m_OnPlayerSpawned.Invoke(requestComponent.GetPlayerId(), entity);
    }
 
    //------------------------------------------------------------------------------------------------
    void OnPlayerSpawnOnPoint_S(SCR_SpawnRequestComponent requestComponent, SCR_SpawnHandlerComponent handlerComponent, IEntity entity, SCR_SpawnPointSpawnData spawnPointData)
    {
        SCR_PlayerLoadoutComponent loadoutComp = SCR_PlayerLoadoutComponent.Cast(requestComponent.GetPlayerController().FindComponent(SCR_PlayerLoadoutComponent));
 
        //~ Update supplies of base or spawn point
        ConsumeSuppliesOnPlayerSpawn_S(requestComponent.GetPlayerId(), spawnPointData.GetSpawnPoint(), loadoutComp);
 
        //~ Consume Military Supply Allocation
        ConsumeMilitarySupplyAllocationOnPlayerSpawn_S(requestComponent, spawnPointData.GetSpawnPoint(), loadoutComp);
    }
 
    //------------------------------------------------------------------------------------------------
    //~ Consume supplies for spawning
    protected void ConsumeSuppliesOnPlayerSpawn_S(int playerID, IEntity spawnPoint, SCR_PlayerLoadoutComponent loadoutComp)
    {
        SCR_CampaignMilitaryBaseComponent base;
        SCR_ResourceComponent resourceComp;
 
        int spawnSupplyCost = 0;
        if (loadoutComp)
            spawnSupplyCost = SCR_ArsenalManagerComponent.GetLoadoutCalculatedSupplyCost(loadoutComp.GetLoadout(), false, playerID, null, spawnPoint, base, resourceComp);
 
        if (spawnSupplyCost > 0)
        {
            if (base)
                base.AddSupplies(spawnSupplyCost * -1);
            else if (resourceComp)
                SCR_ResourceSystemHelper.ConsumeResources(resourceComp, spawnSupplyCost, false);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    // Consume Military Supply Allocation for spawning
    // param[in] requestComponent
    // param[in] spawnPoint
    // param[in] loadoutComponent
    protected void ConsumeMilitarySupplyAllocationOnPlayerSpawn_S(SCR_SpawnRequestComponent requestComponent, IEntity spawnPoint, SCR_PlayerLoadoutComponent loadoutComponent)
    {
        if (!SCR_ArsenalManagerComponent.IsMilitarySupplyAllocationEnabled())
            return;
 
        SCR_ArsenalManagerComponent arsenalManager;
        if (!SCR_ArsenalManagerComponent.GetArsenalManager(arsenalManager))
            return;
 
        int spawnCost = arsenalManager.GetLoadoutMilitarySupplyAllocationCost(loadoutComponent.GetLoadout(), requestComponent.GetPlayerId());
        if (spawnCost <= 0)
            return;
 
        SCR_PlayerController playerController = SCR_PlayerController.Cast(requestComponent.GetPlayerController());
        if (!playerController)
            return;
 
        SCR_PlayerSupplyAllocationComponent playerSupplyAllocationComponent = SCR_PlayerSupplyAllocationComponent.Cast(playerController.FindComponent(SCR_PlayerSupplyAllocationComponent));
        if (!playerSupplyAllocationComponent)
            return;
 
        playerSupplyAllocationComponent.AddPlayerAvailableAllocatedSupplies(-1 * spawnCost);
    }
 
    //------------------------------------------------------------------------------------------------
    void OnPlayerLoadoutSet_S(SCR_PlayerLoadoutComponent loadoutComponent, SCR_BasePlayerLoadout loadout)
    {
    }
 
    //------------------------------------------------------------------------------------------------
    void OnPlayerFactionSet_S(SCR_PlayerFactionAffiliationComponent factionComponent, Faction faction)
    {
    }
 
    //------------------------------------------------------------------------------------------------
    bool CanPlayerSpawn_S(SCR_SpawnRequestComponent requestComponent, SCR_SpawnHandlerComponent handlerComponent, SCR_SpawnData data, out SCR_ESpawnResult result = SCR_ESpawnResult.SPAWN_NOT_ALLOWED)
    {
        if (m_RespawnTimerComponent)
        {
            int playerId = requestComponent.GetPlayerId();
 
            // If player has not been enqueued yet, ignore the spawn timer
            if (m_RespawnTimerComponent.IsPlayerEnqueued(playerId))
            {
                float spawnPointTime = 0;
                if (data.IsInherited(SCR_SpawnPointSpawnData))
                {
                    SCR_SpawnPointSpawnData spData = SCR_SpawnPointSpawnData.Cast(data);
                    spawnPointTime = spData.GetSpawnPoint().GetRespawnTime();
                }
 
                if (!m_RespawnTimerComponent.GetCanPlayerSpawn(playerId, spawnPointTime))
                {
                    result = SCR_ESpawnResult.NOT_ALLOWED_TIMER;
                    return false;
                }
            }
        }
 
        SCR_SpawnPointSpawnData spawnPointData = SCR_SpawnPointSpawnData.Cast(data);
        if (!spawnPointData)
            return true;
 
        //~ Check if spawn point has enough supplies
        SCR_CampaignMilitaryBaseComponent base;
        SCR_ResourceComponent resourceComp;
 
        int spawnSupplyCost = 0;
 
        SCR_PlayerLoadoutComponent loadoutComp = SCR_PlayerLoadoutComponent.Cast(requestComponent.GetPlayerController().FindComponent(SCR_PlayerLoadoutComponent));
        if (loadoutComp)
            spawnSupplyCost = SCR_ArsenalManagerComponent.GetLoadoutCalculatedSupplyCost(loadoutComp.GetLoadout(), false, requestComponent.GetPlayerId(), null, spawnPointData.GetSpawnPoint(), base, resourceComp);
 
        if (base)
        {
            //~ Check if there are enough supplies for base
            if (base.GetSupplies() < spawnSupplyCost)
            {
                result = SCR_ESpawnResult.NOT_ALLOWED_NOT_ENOUGH_SUPPLIES;
                return false;
            }
        }
        else if (resourceComp)
        {
            //~ Check if there are enough supplies for Resource comp
            float availableSupplies;
            if (SCR_ResourceSystemHelper.GetAvailableResources(resourceComp, availableSupplies))
            {
                if (availableSupplies < spawnSupplyCost)
                {
                    result = SCR_ESpawnResult.NOT_ALLOWED_NOT_ENOUGH_SUPPLIES;
                    return false;
                }
            }
        }
 
        if (SCR_ArsenalManagerComponent.IsMilitarySupplyAllocationEnabled())
        {
            SCR_PlayerArsenalLoadout arsenalLoadout = SCR_PlayerArsenalLoadout.Cast(loadoutComp.GetLoadout());
            PlayerController playerController = requestComponent.GetPlayerController();
            SCR_ArsenalManagerComponent arsenalManager;
 
            //~ Check if player has enough Available Allocated Supplies to spawn with a custom loadout
            if (arsenalLoadout && playerController && SCR_ArsenalManagerComponent.GetArsenalManager(arsenalManager))
            {
                SCR_PlayerSupplyAllocationComponent playerSupplyAllocationComponent = SCR_PlayerSupplyAllocationComponent.Cast(playerController.FindComponent(SCR_PlayerSupplyAllocationComponent));
                if (playerSupplyAllocationComponent && !playerSupplyAllocationComponent.HasPlayerEnoughAvailableAllocatedSupplies(arsenalManager.GetLoadoutMilitarySupplyAllocationCost(arsenalLoadout, playerController.GetPlayerId())))
                {
                    result = SCR_ESpawnResult.NOT_ALLOWED_NOT_ENOUGH_AVAILABLE_ALLOCATED_SUPPLIES;
                    return false;
                }
            }
        }
 
        result = SCR_ESpawnResult.OK;
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    int GetPlayerRemainingRespawnTime(int playerID)
    {
        // Respawn timers
        if (m_RespawnTimerComponent)
            return m_RespawnTimerComponent.GetPlayerRemainingTime(playerID);
 
        return 0;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool RplSave(ScriptBitWriter writer)
    {
        EGameFlags gameFlags = GetGame().GetGameFlags();
        writer.WriteIntRange(gameFlags, 0, (EGameFlags.Last<<1) - 1);
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool RplLoad(ScriptBitReader reader)
    {
        EGameFlags gameFlags;
        reader.ReadIntRange(gameFlags, 0, (EGameFlags.Last<<1) - 1);
 
        GetGame().SetGameFlags(gameFlags, true);
 
        return true;
    }
 
    #ifdef GAME_MODE_DEBUG
 
    //------------------------------------------------------------------------------------------------
    void Diag_DrawPlayersWindow()
    {
        //DbgUI.Begin("SCR_BaseGameMode: Players Diag");
        array<int> connectedPlayers = {};
        GetGame().GetPlayerManager().GetPlayers(connectedPlayers);
 
        array<int> disconnectedPlayers = {};
        GetGame().GetPlayerManager().GetDisconnectedPlayers(disconnectedPlayers);
 
        DbgUI.Begin("SCR_BaseGameMode: Connected players");
        {
            for (int i = 0, cnt = connectedPlayers.Count(); i < cnt; i++)
            {
                int playerId = connectedPlayers[i];
                Diag_DrawPlayerInfo(playerId);
            }
        }
        DbgUI.End();
        DbgUI.Begin("SCR_BaseGameMode: Disconnected players");
        {
            for (int i = 0, cnt = disconnectedPlayers.Count(); i < cnt; i++)
            {
                int playerId = disconnectedPlayers[i];
                Diag_DrawPlayerInfo(playerId);
            }
        }
        DbgUI.End();
    }
 
    //------------------------------------------------------------------------------------------------
    void Diag_DrawPlayerInfo(int playerId)
    {
        string tmp = string.Format("Player %1: (name: %2)", playerId, GetGame().GetPlayerManager().GetPlayerName(playerId));
        array<string> extra = {};
 
        // Fetch faction info (if present)
        SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
        if (factionManager)
        {
            string factionKey = "None";
            Faction faction = factionManager.GetPlayerFaction(playerId);
            if (faction)
            {
                factionKey = faction.GetFactionKey();
            }
 
            extra.Insert(string.Format("Faction: %1", factionKey));
        }
 
        // Fetch loadout info (if present)
        SCR_LoadoutManager loadoutManager = GetGame().GetLoadoutManager();
        if (loadoutManager)
        {
            string loadoutKey = "None";
            SCR_BasePlayerLoadout loadout = loadoutManager.GetPlayerLoadout(playerId);
            if (loadout)
            {
                loadoutKey = loadout.GetLoadoutName();
            }
 
            extra.Insert(string.Format("Loadout: %1", loadoutKey));
        }
 
        // If any additional info is present, start formatting
        if (!extra.IsEmpty())
        {
            const string separator = "\n   ";
            for (int i = 0, count = extra.Count(); i < count; i++)
            {
                tmp += string.Format("%1%2", separator, extra[i]);
            }
        }
 
        DbgUI.Text(tmp);
    }
 
    //------------------------------------------------------------------------------------------------
    void Diag_DrawControlledEntitiesWindow()
    {
        array<int> allPlayers = {};
        GetGame().GetPlayerManager().GetAllPlayers(allPlayers);
 
        DbgUI.Begin("SCR_BaseGameMode: Controlled Entities");
        {
            for (int i = 0, cnt = allPlayers.Count(); i < cnt; i++)
            {
                int playerId = allPlayers[i];
                Diag_DrawControlledEntityInfo(playerId);
            }
        }
        DbgUI.End();
    }
 
    //------------------------------------------------------------------------------------------------
    void Diag_DrawControlledEntityInfo(int playerId)
    {
        string tmp = string.Format("Player %1: (name: %2)", playerId, GetGame().GetPlayerManager().GetPlayerName(playerId));
        array<string> extra = {};
 
        // IsConnected?
        if (GetGame().GetPlayerManager().IsPlayerConnected(playerId))
        {
            extra.Insert("IsConnected: True");
        }
        else
            extra.Insert("IsConnected: False");
 
        // Controlled entity
        IEntity controlledEntity = GetGame().GetPlayerManager().GetPlayerControlledEntity(playerId);
        if (controlledEntity)
        {
            extra.Insert(string.Format("Entity: %1", controlledEntity));
 
            RplComponent rplComponent = RplComponent.Cast(controlledEntity.FindComponent(RplComponent));
            if (rplComponent)
            {
                extra.Insert(string.Format("RplId: %1", rplComponent.Id()));
            }
        }
        else
        {
            extra.Insert("Entity: None");
        }
 
 
        // If any additional info is present, start formatting
        if (!extra.IsEmpty())
        {
            const string separator = "\n   ";
            for (int i = 0, count = extra.Count(); i < count; i++)
            {
                tmp += string.Format("%1%2", separator, extra[i]);
            }
        }
 
        DbgUI.Text(tmp);
    }
 
    //------------------------------------------------------------------------------------------------
    void Diag_DrawComponentsWindow()
    {
        DbgUI.Begin("SCR_BaseGameMode: Components");
        {
            int numComponents = m_aAdditionalGamemodeComponents.Count();
            DbgUI.Text(string.Format("NumComponents: %1", numComponents));
 
            for (int i = 0; i < numComponents; i++)
            {
                Diag_DrawComponentInfo(i, m_aAdditionalGamemodeComponents[i]);
            }
        }
        DbgUI.End();
    }
 
    //------------------------------------------------------------------------------------------------
    void Diag_DrawComponentInfo(int index, SCR_BaseGameModeComponent component)
    {
        DbgUI.Text(string.Format("%1: %2", index, component));
    }
 
    //------------------------------------------------------------------------------------------------
    void Diag_DrawGameModeWindow()
    {
        DbgUI.Begin("SCR_BaseGameMode");
        {
            string elapsedTime = string.Format("Elapsed time: %1 s", GetElapsedTime());
            DbgUI.Text(elapsedTime);
 
            string running = string.Format("IsRunning: %1", IsRunning());
            DbgUI.Text(running);
 
            string state = string.Format("State: %1", SCR_Enum.GetEnumName(SCR_EGameModeState, GetState()));
            DbgUI.Text(state);
 
            string flags = string.Format("TestFlags: %1 (%2)", SCR_Enum.FlagsToString(EGameFlags, m_eGameState), m_eGameState);
            DbgUI.Text(flags);
 
            if (IsMaster())
            {
                DbgUI.Spacer(16);
                DbgUI.Text("Authority details:");
 
                float autoReloadDelay = GetAutoReloadDelay();
                if (autoReloadDelay > 0)
                {
                    DbgUI.Text(string.Format("Auto reload: %1 seconds.", autoReloadDelay));
                }
                else
                {
                    DbgUI.Text("Auto reload: Disabled.");
                }
 
                DbgUI.Spacer(16);
 
                if (DbgUI.Button("End Session"))
                    EndGameMode(SCR_GameModeEndData.CreateSimple(EGameOverTypes.FACTION_DRAW));
 
                if (DbgUI.Button("Restart Session"))
                    RestartSession();
            }
        }
        DbgUI.End();
    }
    #endif
 
    //------------------------------------------------------------------------------------------------
    void HandleOnTasksInitialized();
 
    //------------------------------------------------------------------------------------------------
    protected void SetLocalControls(bool enabled)
    {
        PlayerController playerController = GetGame().GetPlayerController();
        if (playerController)
        {
            IEntity controlledEntity = playerController.GetControlledEntity();
            if (controlledEntity)
            {
                ChimeraCharacter character = ChimeraCharacter.Cast(controlledEntity);
                if (character)
                {
                    CharacterControllerComponent controller = character.GetCharacterController();
                    if (controller)
                    {
                        bool doDisable = !enabled;
                        controller.SetDisableWeaponControls(doDisable);
                        controller.SetDisableMovementControls(doDisable);
                    }
                }
            }
        }
    }
 
    #ifdef GM_AI_STATS
    private float m_fLastRecordTime;
 
    private float m_fLastFlushTime;
    private float m_fFlushRecordInterval = 10000; // 10s
 
    //------------------------------------------------------------------------------------------------
    private void UpdateStatistics(IEntity owner)
    {
        // Create new records only ever so often
        float timeStamp = owner.GetWorld().GetWorldTime();
        if (timeStamp > m_fLastRecordTime + SCR_GameModeStatistics.RECORD_INTERVAL_MS)
        {
            m_fLastRecordTime = timeStamp;
 
            #ifdef GMSTATS
            PlayerManager pm = GetGame().GetPlayerManager();
            array<int> players = {};
            pm.GetPlayers(players);
 
            foreach (int pid : players)
            {
                IEntity ctrlEnt = pm.GetPlayerControlledEntity(pid);
                if (!ctrlEnt)
                    continue;
 
                SCR_GameModeStatistics.RecordMovement(ctrlEnt, pid);
            }
            #endif
            #ifdef AISTATS
            auto aiWorld = SCR_AIWorld.Cast(GetGame().GetAIWorld());
            if (aiWorld)
            {
                array<AIAgent> aiAgents = {};
                aiWorld.GetAIAgents(aiAgents);
                foreach (AIAgent agent : aiAgents)
                {
                    SCR_GameModeStatistics.RecordAILOD(agent);
                }
            }
            #endif
        }
 
        // Flush data if recording in smaller intervals
        if (timeStamp > m_fLastFlushTime + m_fFlushRecordInterval)
        {
            m_fLastFlushTime = timeStamp;
            if (IsGameModeStatisticsEnabled())
            {
                if (SCR_GameModeStatistics.IsRecording())
                    SCR_GameModeStatistics.Flush();
            }
        }
    }
    #endif
 
    //------------------------------------------------------------------------------------------------
    bool GetAllowControls()
    {
        return m_bAllowControls;
    }
 
    //------------------------------------------------------------------------------------------------
    protected bool GetAllowControlsTarget()
    {
        SCR_BaseGameModeStateComponent stateComponent = GetStateComponent(GetState());
        if (stateComponent)
            return stateComponent.GetAllowControls();
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_BaseGameModeStateComponent GetStateComponent(SCR_EGameModeState state)
    {
        SCR_BaseGameModeStateComponent stateComponent;
        if (m_mStateComponents.Find(state, stateComponent))
            return stateComponent;
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    bool PauseGame(bool pause, SCR_EPauseReason reason = SCR_EPauseReason.SYSTEM)
    {
        if (!CanBePaused())
            return false;
 
#ifdef ENABLE_DIAG
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_SINGLEPLAYER_DISABLE_TIME_PAUSE))
            pause = false;
#endif
 
        if (pause)
            m_ePauseReasons = m_ePauseReasons | reason;
        else
            m_ePauseReasons = m_ePauseReasons &~ reason;
 
        ChimeraWorld world = GetGame().GetWorld();
        world.PauseGameTime(m_ePauseReasons != 0);
 
        // Audio
        if (m_ePauseReasons != 0)
        {
            if (SCR_Enum.HasFlag(m_ePauseReasons, SCR_EPauseReason.MUSIC))
            {
                AudioSystem.Pause((1 << AudioSystem.SFX) | (1 << AudioSystem.Dialog) | (1 << AudioSystem.Music));
            }
            else
            {
                AudioSystem.Pause((1 << AudioSystem.SFX) | (1 << AudioSystem.Dialog));
                AudioSystem.Resume(1 << AudioSystem.Music);
            }
        }
        else
        {
            AudioSystem.Resume((1 << AudioSystem.SFX) | (1 << AudioSystem.Dialog) | (1 << AudioSystem.Music));
        }
 
        return !pause && m_ePauseReasons != 0 || pause;
    }
 
    //------------------------------------------------------------------------------------------------
    bool CanBePaused()
    {
        return !Replication.IsRunning();
    }
 
    //------------------------------------------------------------------------------------------------
    // TODO@AS: Small thing, but get rid of m_fTimeElapsed and use
    // some sort of m_fStartTime and Replication.Time() instead!
    override void EOnFrame(IEntity owner, float timeSlice)
    {
        #ifdef GM_AI_STATS
        if (IsGameModeStatisticsEnabled())
            UpdateStatistics(owner);
        #endif
 
        if (m_bUseSpawnPreload && m_SpawnPreload)
            HandleSpawnPreload(timeSlice);
 
        // Allow to accumulate time in pre-game too.
        SCR_BaseGameModeStateComponent pregameComponent = GetStateComponent(SCR_EGameModeState.PREGAME);
        bool isPregame = GetState() == SCR_EGameModeState.PREGAME;
        // Increment elapsed time on every machine
        bool isRunning = IsRunning();
        if (isRunning || isPregame)
        {
            bool canAdvanceTime = true;
 
            // Check if any players are present; if using "advance time requires players"
            // we will only advance the time if at least one player is present;
            // this is fairly easy to do, because dedicated (headless) server does not
            // count as a player in the PlayerManager
            if (m_bAdvanceTimeRequiresPlayers)
            {
                int playerCount = GetGame().GetPlayerManager().GetPlayerCount();
                if (playerCount == 0)
                    canAdvanceTime = false;
            }
 
            if (canAdvanceTime)
                m_fTimeElapsed += timeSlice;
        }
 
        // As the authority make corrections as needed
        if (IsMaster())
        {
            if (m_fTimeElapsed >= m_fLastTimeCorrection + m_fTimeCorrectionInterval)
            {
                Replication.BumpMe();
                m_fLastTimeCorrection = m_fTimeElapsed;
            }
 
            // Transition from pre-game to game if possible
            // Either fully automatic transition (no component)
            // or state-driven transition based on component logic
            if (isPregame && (!pregameComponent || pregameComponent.CanAdvanceState(SCR_EGameModeState.GAME)))
            {
                if (CanStartGameMode())
                    StartGameMode();
            }
            else
            {
                // Time limit end game transition to post-game if possible
                if (IsRunning())
                {
                    SCR_BaseGameModeStateComponent gameState = GetStateComponent(SCR_EGameModeState.GAME);
                    if (gameState && gameState.CanAdvanceState(SCR_EGameModeState.POSTGAME))
                    {
                        // Clamp time to maximum
                        m_fTimeElapsed = Math.Clamp(m_fTimeElapsed, 0, gameState.GetDuration());
 
                        // Terminate session
                        SCR_GameModeEndData data = SCR_GameModeEndData.CreateSimple(EGameOverTypes.EDITOR_FACTION_DRAW); // TODO: Once FACTION_DRAW or TIME_LIMIT works..
                        EndGameMode(data);
                    }
                }
            }
 
            // Update controls state
            bool shouldAllowControls = GetAllowControlsTarget();
            if (shouldAllowControls != m_bAllowControls)
            {
                m_bAllowControls = shouldAllowControls;
                Replication.BumpMe();
            }
        }
 
 
        // Should we disable local player controls?
        bool allowControls = GetAllowControls();
        SetLocalControls(allowControls);
 
        #ifdef GAME_MODE_DEBUG
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_GAME_MODE))
        {
            Diag_DrawGameModeWindow();
            Diag_DrawComponentsWindow();
            Diag_DrawPlayersWindow();
            Diag_DrawControlledEntitiesWindow();
        }
        #endif
    }
 
    //------------------------------------------------------------------------------------------------
    override void EOnInit(IEntity owner)
    {
        // Set Test Game Flags
        #ifdef WORKBENCH
            if (GetGame().GetWorldEntity() && !GetGame().AreGameFlagsObtained())
            {
                GetGame().SetGameFlags(m_eTestGameFlags, false);
            }
        #endif
 
        //~ Remove any duplicate entries
        if (m_aDisabledResourceTypes.IsEmpty())
        {
            //~ TODO: Make this cleaner
 
            set<EResourceType> duplicateRemoveSet = new set<EResourceType>();
 
            foreach (EResourceType resourceType : m_aDisabledResourceTypes)
            {
                duplicateRemoveSet.Insert(resourceType);
            }
 
            m_aDisabledResourceTypes.Clear();
            foreach (EResourceType resourceType : duplicateRemoveSet)
            {
                m_aDisabledResourceTypes.Insert(resourceType);
            }
        }
 
        // Find required components
        m_RplComponent = RplComponent.Cast(owner.FindComponent(RplComponent));
        m_pRespawnSystemComponent = SCR_RespawnSystemComponent.Cast(owner.FindComponent(SCR_RespawnSystemComponent));
        m_RespawnTimerComponent = SCR_RespawnTimerComponent.Cast(owner.FindComponent(SCR_RespawnTimerComponent));
        m_ScoringSystemComponent = SCR_BaseScoringSystemComponent.Cast(owner.FindComponent(SCR_BaseScoringSystemComponent));
        m_pGameModeHealthSettings = SCR_GameModeHealthSettings.Cast(owner.FindComponent(SCR_GameModeHealthSettings));
 
        if (!m_RplComponent)
            Print("SCR_BaseGameMode is missing RplComponent!", LogLevel.ERROR);
        if (!m_pRespawnSystemComponent)
            Print("SCR_BaseGameMode is missing SCR_RespawnSystemComponent!", LogLevel.WARNING);
 
        if (!m_aAdditionalGamemodeComponents)
            m_aAdditionalGamemodeComponents = new array<SCR_BaseGameModeComponent>();
 
        array<Managed> additionalComponents = new array<Managed>();
        int count = owner.FindComponents(SCR_BaseGameModeComponent, additionalComponents);
 
        m_aAdditionalGamemodeComponents.Clear();
        for (int i = 0; i < count; i++)
        {
            SCR_BaseGameModeComponent comp = SCR_BaseGameModeComponent.Cast(additionalComponents[i]);
            m_aAdditionalGamemodeComponents.Insert(comp);
        }
 
        // Find and sort state components
        array<Managed> stateComponents = new array<Managed>();
        int stateCount = owner.FindComponents(SCR_BaseGameModeStateComponent, stateComponents);
        for (int i = 0; i < stateCount; i++)
        {
            SCR_BaseGameModeStateComponent stateComponent = SCR_BaseGameModeStateComponent.Cast(stateComponents[i]);
            SCR_EGameModeState state = stateComponent.GetAffiliatedState();
            // Invalid state
            if (state < 0)
            {
                Print("Skipping one of SCR_BaseGameStateComponent(s), invalid affiliated state!", LogLevel.ERROR);
                continue;
            }
 
            if (m_mStateComponents.Contains(state))
            {
                string stateName = SCR_Enum.GetEnumName(SCR_EGameModeState, state);
                Print("Skipping one of SCR_BaseGameStateComponent(s), duplicate component for state: " + stateName + "!", LogLevel.ERROR);
                continue;
            }
 
            m_mStateComponents.Insert(state, stateComponent);
        }
    }
 
    /*
        Preload handling
    */
 
    //------------------------------------------------------------------------------------------------
    OnPreloadFinishedInvoker GetOnPreloadFinished()
    {
        if (!m_OnPreloadFinished)
            m_OnPreloadFinished = new OnPreloadFinishedInvoker();
 
        return m_OnPreloadFinished;
    }
 
    //------------------------------------------------------------------------------------------------
    void StartSpawnPreload(vector position)
    {
        m_SpawnPreload = SCR_SpawnPreload.PreloadSpawnPosition(position);
        if (!m_SpawnPreload && m_OnPreloadFinished)
            m_OnPreloadFinished.Invoke();
 
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetAutotuneEnabled()
    {
        return m_bAutotuneEnabled;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void HandleSpawnPreload(float timeSlice)
    {
        bool finished = m_SpawnPreload.Update(timeSlice);
        if (finished)
        {
            m_SpawnPreload = null;
            if (m_OnPreloadFinished)
                m_OnPreloadFinished.Invoke();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    // constructor
    void SCR_BaseGameMode(IEntitySource src, IEntity parent)
    {
        #ifdef GAME_MODE_DEBUG
        if (!s_DebugRegistered)
        {
            DiagMenu.RegisterMenu(SCR_DebugMenuID.DEBUGUI_GAME_MODE_MENU, "GameMode", "");
            DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_GAME_MODE, "", "Game Mode", "GameMode");
            DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_CHARACTER_KILLED_LOG, "", "Show kill log", "GameMode");
            s_DebugRegistered = true;
        }
        #endif
 
        Activate();
        SetEventMask(EntityEvent.INIT | EntityEvent.FRAME);
    }
 
    //------------------------------------------------------------------------------------------------
    // destructor
    void ~SCR_BaseGameMode()
    {
        #ifdef GAME_MODE_DEBUG
            DiagMenu.Unregister(SCR_DebugMenuID.DEBUGUI_GAME_MODE);
            s_DebugRegistered = false;
        #endif
 
        #ifdef GM_AI_STATS
        if (SCR_GameModeStatistics.IsRecording())
            SCR_GameModeStatistics.StopRecording();
        #endif
    }
 
    #ifdef GM_AI_STATS
    //------------------------------------------------------------------------------------------------
    private bool IsGameModeStatisticsEnabled()
    {
        // not authority
        if (m_RplComponent && !m_RplComponent.IsMaster())
            return false;
 
        return GetGame().InPlayMode();
    }
    #endif
}