SCR_EditablePlayerDelegateComponent.c

Go to the documentation of this file.

[ComponentEditorProps(category: "GameScripted/Editor (Editables)", description: "", icon: "WBData/ComponentEditorProps/componentEditor.png")]
class SCR_EditablePlayerDelegateComponentClass : SCR_EditableEntityComponentClass
{
}


class SCR_EditablePlayerDelegateComponent : SCR_EditableEntityComponent
{
    [RplProp(onRplName: "OnRplPlayerID")]
    protected int m_iPlayerID = 0;
    
    [RplProp(onRplName: "OnRplLimitedEditor")]
    protected bool m_bHasLimitedEditor;
    
    protected SCR_EditableEntityComponent m_ControlledEntity; //--- Don't use RplProp(), controlled entity cannot be found on client using Replication.FindItem() right after being spawned
    protected RplId m_EntityID = RplId.Invalid();
    
    protected ref ScriptInvoker m_OnUIReset = new ScriptInvoker();
    protected ref ScriptInvoker m_OnLimitedEditorChanged = new ScriptInvoker();
    
    //------------------------------------------------------------------------------------------------
    void InitPlayerDelegate(SCR_EditorManagerEntity editorManager, int playerID)
    {
        if (m_iPlayerID != 0)
            return;
        
        m_iPlayerID = playerID;
        OnRplPlayerID();
        
        m_bHasLimitedEditor = editorManager.IsLimited();
        editorManager.GetOnLimitedChange().Insert(OnEditorLimitedChange); //--- No Remove() later needed - delegate is removed when the manager is
        
        Replication.BumpMe();
    }
 
    //------------------------------------------------------------------------------------------------
    override int GetPlayerID()
    {
        return m_iPlayerID;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnLimitedEditorChanged()
    {
        return m_OnLimitedEditorChanged;
    }
 
    //------------------------------------------------------------------------------------------------
    bool HasLimitedEditor()
    {
        return m_bHasLimitedEditor;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetControlledEntity(IEntity controlledEntity)
    {
        RplId entityID = Replication.FindItemId(SCR_EditableEntityComponent.GetEditableEntity(controlledEntity));
        SetControlledEntityOwner(entityID);
        Rpc(SetControlledEntityOwner, entityID);
    }
 
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void SetControlledEntityOwner(RplId entityID)
    {
        m_EntityID = entityID;
        m_ControlledEntity = SCR_EditableEntityComponent.Cast(Replication.FindItem(entityID));
 
        m_OnUIReset.Invoke();
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_EditableEntityComponent GetControlledEntity()
    {
        return m_ControlledEntity;
    }
    
    //--- OnRpl methods
 
    //------------------------------------------------------------------------------------------------
    protected void OnRplPlayerID()
    {
        if (!SCR_EditorManagerEntity.GetInstance())
        {
            //--- Initialized before the editor - wait
            SCR_EditorManagerCore editorManagerCore = SCR_EditorManagerCore.Cast(SCR_EditorManagerCore.GetInstance(SCR_EditorManagerCore));
            if (editorManagerCore)
            {
                editorManagerCore.Event_OnEditorManagerInitOwner.Insert(OnRplPlayerID);
                return;
            }
        }
        else
        {
            SCR_EditorManagerCore editorManagerCore = SCR_EditorManagerCore.Cast(SCR_EditorManagerCore.GetInstance(SCR_EditorManagerCore));
            if (editorManagerCore)
                editorManagerCore.Event_OnEditorManagerInitOwner.Remove(OnRplPlayerID);
        }
        
        SCR_PlayerDelegateEditorComponent delegateManager = SCR_PlayerDelegateEditorComponent.Cast(SCR_PlayerDelegateEditorComponent.GetInstance(SCR_PlayerDelegateEditorComponent, true));
        if (delegateManager)
        delegateManager.RegisterDelegate(this);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnRplLimitedEditor()
    {
        m_OnLimitedEditorChanged.Invoke(m_iPlayerID, m_bHasLimitedEditor);
    }
    
    //--- Invokers
 
    //------------------------------------------------------------------------------------------------
    protected void OnEditorLimitedChange(bool isLimited)
    {
        m_bHasLimitedEditor = isLimited;
        OnRplLimitedEditor();
        Replication.BumpMe();
    }
    
    //------------------------------------------------------------------------------------------------
    protected bool FetchControlledEntity()
    {
        if (!m_ControlledEntity)
        {
            if (m_EntityID == RplId.Invalid())
                return false;
            
            m_ControlledEntity = SCR_EditableEntityComponent.Cast(Replication.FindItem(m_EntityID));
            if (!m_ControlledEntity)
                return false;
        }
 
        return true;
    }
 
    //--- Overrides
    override EEditableEntityType GetEntityType(IEntity owner = null)
    {
        if (m_ControlledEntity)
            return m_ControlledEntity.GetEntityType(owner);
        else
            return super.GetEntityType(owner);
    }
 
    //------------------------------------------------------------------------------------------------
    override SCR_UIInfo GetInfo(IEntity owner = null)
    {
        if (FetchControlledEntity())
        {
            SCR_UIInfo info = m_ControlledEntity.GetInfo(owner);
            return info;
        }
        else
        {
            return super.GetInfo();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override ScriptInvoker GetOnUIReset()
    {
        return m_OnUIReset;
    }
 
    //------------------------------------------------------------------------------------------------
    override Faction GetFaction()
    {
        if (m_iPlayerID > 0)
        {
            SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
            if (factionManager)
                return factionManager.GetPlayerFaction(m_iPlayerID);
        }
 
        FactionAffiliationComponent factionAffiliation = FactionAffiliationComponent.Cast(m_Owner.FindComponent(FactionAffiliationComponent));
        if (factionAffiliation)
            return factionAffiliation.GetAffiliatedFaction();
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    override SCR_EditableEntityComponent GetAIGroup()
    {
        if (FetchControlledEntity())
            return m_ControlledEntity.GetAIGroup();
        else
            return null;
    }
 
    //------------------------------------------------------------------------------------------------
    override SCR_EditableEntityComponent GetVehicle()
    {
        if (FetchControlledEntity())
            return m_ControlledEntity.GetVehicle();
        else
            return null;
    }
 
    //------------------------------------------------------------------------------------------------
    override float GetHealth()
    {
        if (FetchControlledEntity())
            return m_ControlledEntity.GetHealth();
        else
            return 1;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool GetEntityBudgetCost(out notnull array<ref SCR_EntityBudgetValue> outBudgets, IEntity owner = null)
    {
        // Return true and empty cost array, avoid fallback entityType cost
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool GetPos(out vector pos)
    {
        if (FetchControlledEntity())
            return m_ControlledEntity.GetPos(pos);
        else
            return false;
    }
 
    //------------------------------------------------------------------------------------------------
    override string GetLogText(string prefix = "")
    {
        return super.GetLogText(prefix) + string.Format(", ctrl: %1", m_ControlledEntity);
    }
 
    //--- JIP on server
 
    //------------------------------------------------------------------------------------------------
    override bool RplSave(ScriptBitWriter writer)
    {
        if (!super.RplSave(writer))
            return false;
        
        RplId controlledEntityRplID = Replication.FindItemId(m_ControlledEntity);
        writer.WriteRplId(controlledEntityRplID);
        
        return true;
    }
 
    //--- JIP on client
 
    //------------------------------------------------------------------------------------------------
    override bool RplLoad(ScriptBitReader reader)
    {
        if (!super.RplLoad(reader))
            return false;
        
        RplId controlledEntityRplID;
        reader.ReadRplId(controlledEntityRplID);
        
        SetControlledEntityOwner(controlledEntityRplID);
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnPostInit(IEntity owner)
    {
        super.OnPostInit(owner);
        
        owner.SetFlags(EntityFlags.NO_LINK, true);
    }
 
    //------------------------------------------------------------------------------------------------
    // destructor
    void ~SCR_EditablePlayerDelegateComponent()
    {
        SCR_PlayerDelegateEditorComponent delegateManager = SCR_PlayerDelegateEditorComponent.Cast(SCR_PlayerDelegateEditorComponent.GetInstance(SCR_PlayerDelegateEditorComponent));
        if (delegateManager)
            delegateManager.UnegisterDelegate(this);
    }
}