SCR_ReconnectComponent.c

Go to the documentation of this file.

class SCR_ReconnectData
{
    WorldTimestamp m_ValidUntil;

    IEntity m_ReservedEntity;
 
    // Add modded properties here from e.g. player controller that should be reapplied on reconnect onto the new controller.
}
 
[EntityEditorProps(category: "GameScripted/GameMode", description: "")]
class SCR_ReconnectComponentClass : SCR_BaseGameModeComponentClass
{
}

class SCR_ReconnectComponent : SCR_BaseGameModeComponent
{
    // How many seconds a player has time to reconnect before the data expires and the character is removed.
    protected int m_iReconnectTime = 120;
 
    static SCR_ReconnectComponent s_Instance;
 
    ref map<UUID, ref SCR_ReconnectData> m_mReconnectData = new map<UUID, ref SCR_ReconnectData>();
 
    //------------------------------------------------------------------------------------------------
    static SCR_ReconnectComponent GetInstance()
    {
        return s_Instance;
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void OnPostInit(IEntity owner)
    {
        SetEventMask(owner, EntityEvent.INIT);
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void EOnInit(IEntity owner)
    {
        RplComponent rplComp = RplComponent.Cast(owner.FindComponent(RplComponent));
        if (!GetGame().InPlayMode() || !rplComp || rplComp.IsProxy())
            return;
 
        s_Instance = this;
 
        SCR_DSConfig config();
        if (GetGame().GetBackendApi().GetRunningDSConfig(config))
            m_iReconnectTime = config.operating.slotReservationTimeout;
    }
 
    //------------------------------------------------------------------------------------------------
    int GetReconnectTimeout()
    {
        return m_iReconnectTime;
    }
 
    //------------------------------------------------------------------------------------------------
    void UpdateExpieryCheck()
    {
        ScriptCallQueue callqueue = GetGame().GetCallqueue();
        if (m_mReconnectData.IsEmpty())
        {
            callqueue.Remove(CheckExpiery);
            return;
        }
 
        // Remove expired data and associated char every second (config is in seconds interval. Less frequent check leads to inaccuracy)
        if (callqueue.GetRemainingTime(CheckExpiery) < 0)
            callqueue.CallLater(CheckExpiery, 1000, true);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void CheckExpiery()
    {
        if (m_mReconnectData.IsEmpty())
            return;
 
        const WorldTimestamp timestamp = GetGame().GetWorld().GetTimestamp();
 
        array<UUID> expired = {};
        foreach (UUID identity, SCR_ReconnectData data : m_mReconnectData)
        {
            if (!IsDataExpired(data, timestamp))
                continue;
 
            HandleDataExpiery(data);
            expired.Insert(identity);
        }
 
        if (!expired.IsEmpty())
        {
            foreach (UUID identity : expired)
            {
                m_mReconnectData.Remove(identity);
            }
 
            UpdateExpieryCheck();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    bool HandlePlayerDisconnect(int playerId, KickCauseCode cause)
    {
        const KickCauseGroup2 group = KickCauseCodeAPI.GetGroup(cause);
        if (group != RplKickCauseGroup.REPLICATION)
            return false;
 
        const int reason = KickCauseCodeAPI.GetReason(cause);
        if (reason == RplError.SHUTDOWN)
            return false;
 
        const SCR_ReconnectData data = StoreData(playerId);
        if (!IsDataRelevant(data))
            return false;
 
        const UUID identity = SCR_PlayerIdentityUtils.GetPlayerIdentityId(playerId);
        m_mReconnectData.Set(identity, data);
 
        UpdateExpieryCheck();
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    bool HandlePlayerReconnect(int playerId)
    {
        const UUID identity = SCR_PlayerIdentityUtils.GetPlayerIdentityId(playerId);
        SCR_ReconnectData data;
        if (!m_mReconnectData.Take(identity, data))
            return false;
 
        if (IsDataRelevant(data))
            ApplyData(playerId, data);
 
        UpdateExpieryCheck();
        return GetGame().GetPlayerManager().GetPlayerControlledEntity(playerId) != null;
    }
 
    //------------------------------------------------------------------------------------------------
    protected notnull SCR_ReconnectData StoreData(int playerId)
    {
        SCR_ReconnectData data();
        data.m_ReservedEntity = GetGame().GetPlayerManager().GetPlayerControlledEntity(playerId);
        if (m_iReconnectTime > 0)
            data.m_ValidUntil = GetGame().GetWorld().GetTimestamp().PlusSeconds(m_iReconnectTime);
 
        return data;
    }
 
    //------------------------------------------------------------------------------------------------
    protected bool IsDataRelevant(notnull SCR_ReconnectData data)
    {
        const ChimeraCharacter character = ChimeraCharacter.Cast(data.m_ReservedEntity);
        return character && !character.GetCharacterController().IsDead();
    }
 
    //------------------------------------------------------------------------------------------------
    protected bool IsDataExpired(notnull SCR_ReconnectData data, WorldTimestamp timestamp)
    {
        return data.m_ValidUntil && data.m_ValidUntil.Less(timestamp);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void HandleDataExpiery(notnull SCR_ReconnectData data)
    {
        if (!IsDataRelevant(data))
            return; // Not relevant anymore, so we are not going to do anything with it.
 
        auto respawn = SCR_RespawnSystemComponent.GetInstance();
        if (respawn)
            respawn.OnPlayerEntityCleanup_S(data.m_ReservedEntity);
 
        RplComponent.DeleteRplEntity(data.m_ReservedEntity, false);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void ApplyData(int playerId, notnull SCR_ReconnectData data)
    {
        SCR_PlayerController playerController = SCR_PlayerController.Cast(GetGame().GetPlayerManager().GetPlayerController(playerId));
        const ChimeraCharacter character = ChimeraCharacter.Cast(data.m_ReservedEntity);
        playerController.SetInitialMainEntity(character);
 
        const Faction faction = SCR_FactionManager.SGetFaction(character);
        if (faction)
        {
            SCR_PlayerFactionAffiliationComponent playerFactionComp = SCR_PlayerFactionAffiliationComponent.Cast(playerController.FindComponent(SCR_PlayerFactionAffiliationComponent));
            if (playerFactionComp)
                playerFactionComp.SetFaction_S(faction);
        }
 
        SCR_RespawnSystemComponent.GetInstance().EmitPlayerEntityChange_S(playerId, null, character);
 
        SCR_ReconnectSynchronizationComponent syncComp = SCR_ReconnectSynchronizationComponent.Cast(playerController.FindComponent(SCR_ReconnectSynchronizationComponent));
        if (syncComp)
            syncComp.CreateReconnectDialog();
 
        SCR_EditorManagerCore core = SCR_EditorManagerCore.Cast(SCR_EditorManagerCore.GetInstance(SCR_EditorManagerCore));
        if (core)
            core.OnPlayerSpawn(playerId, character);
    }
}