SCR_CampaignBuildingEditorComponent.c

Go to the documentation of this file.

// Attached on EditorModeBuilding prefab
[ComponentEditorProps(category: "GameScripted/Editor", description: "Main conflict component for handling building editor mode", icon: "WBData/ComponentEditorProps/componentEditor.png")]
class SCR_CampaignBuildingEditorComponentClass : SCR_BaseEditorComponentClass
{
}
 
//------------------------------------------------------------------------------------------------
 
class SCR_CampaignBuildingEditorComponent : SCR_BaseEditorComponent
{
    protected ref array<SCR_CampaignBuildingProviderComponent> m_aProvidersComponents = {};
    protected ref array<RplId> m_aProvidersRplIds = {};
    protected SCR_ContentBrowserEditorComponent m_ContentBrowserManager;
    protected SCR_CampaignBuildingProviderComponent m_ForcedProviderComponent;
    protected bool m_bViewObstructed;
    protected ScriptedGameTriggerEntity m_BuildingAreaTrigger;
 
    protected ref ScriptInvoker m_OnProviderChanged;
    protected ref ScriptInvokerBool m_OnObstructionEventTriggered;
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnProviderChanged()
    {
        if (!m_OnProviderChanged)
            m_OnProviderChanged = new ScriptInvoker();
 
        return m_OnProviderChanged;
    }
    
    //------------------------------------------------------------------------------------------------
    ScriptInvokerBool GetOnObstructionEventTriggered()
    {
        if (!m_OnObstructionEventTriggered)
            m_OnObstructionEventTriggered = new ScriptInvokerBool();
 
        return m_OnObstructionEventTriggered;
    }
 
    //------------------------------------------------------------------------------------------------
    void AddProviderEntityEditorComponent(notnull SCR_CampaignBuildingProviderComponent providerComponent)
    {
        if (m_aProvidersComponents.Contains(providerComponent))
            return;
 
        SCR_MilitaryBaseComponent base = providerComponent.GetMilitaryBaseComponent();
        if (base)
            m_aProvidersComponents.InsertAt(providerComponent, 0);
        else
            m_aProvidersComponents.Insert(providerComponent);
 
        GetOnProviderChanged().Invoke(m_aProvidersComponents[0]);
    }
 
    //------------------------------------------------------------------------------------------------
    void RemoveProviderEntityEditorComponent(SCR_CampaignBuildingProviderComponent providerComponent)
    {
        if (m_ForcedProviderComponent == providerComponent)
            SetForcedProvider(null);
 
        m_aProvidersComponents.RemoveItemOrdered(providerComponent);
 
        if (!m_aProvidersComponents.IsEmpty())
            GetOnProviderChanged().Invoke(m_aProvidersComponents[0]);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_CampaignBuildingProviderComponent GetProviderComponent(bool getMasterProviderComponent = false)
    {
        SCR_CampaignBuildingProviderComponent temporaryProviderComponent;
        if (m_ForcedProviderComponent)
            temporaryProviderComponent = m_ForcedProviderComponent;
 
        if (m_aProvidersComponents.IsEmpty())
            return null;
 
        temporaryProviderComponent = m_aProvidersComponents[0];
        
        if (getMasterProviderComponent && temporaryProviderComponent && temporaryProviderComponent.UseMasterProvider())
            return SCR_CampaignBuildingProviderComponent.Cast(GetMasterProviderEntity().FindComponent(SCR_CampaignBuildingProviderComponent));
        
        return temporaryProviderComponent;
    }
    
    //------------------------------------------------------------------------------------------------
    void SetForcedProvider(SCR_CampaignBuildingProviderComponent forcedProviderComponent = null)
    {
        m_ForcedProviderComponent = forcedProviderComponent;
    }
 
    //------------------------------------------------------------------------------------------------
    int GetProviderEntitiesCount()
    {
        return m_aProvidersComponents.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsActiveProvider(notnull SCR_CampaignBuildingProviderComponent providerComponent)
    {
        if (providerComponent == m_ForcedProviderComponent)
            return true;
 
        // there exist a forced provider and it's not a tested entity, then it can't be an active provider. ToDo: Zamyslet se a zeptat
        if (m_ForcedProviderComponent)
            return false;
 
        if (!m_aProvidersComponents.IsEmpty() && m_aProvidersComponents[0] == providerComponent)
            return true;
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetProviderResourceComponent(out SCR_ResourceComponent resourceComponent)
    {
        if (m_aProvidersComponents.IsEmpty())
            return false;
 
        resourceComponent = SCR_ResourceComponent.FindResourceComponent(GetProviderEntity());
        
        if (resourceComponent)
            return true;
 
        IEntity parent = GetProviderEntity();
        
        while (parent)
        {
            resourceComponent = SCR_ResourceComponent.FindResourceComponent(parent);
            
            if (resourceComponent)
                return true;
 
            parent = parent.GetParent();
        }
        
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    EEditableEntityBudget GetShownBudget()
    {
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent();
        if (!providerComponent)
            return -1;
        
        return providerComponent.GetShownBudget();
    }
 
    //------------------------------------------------------------------------------------------------
    [Obsolete("SCR_CampaignBuildingEditorComponent.GetProviderResourceComponent() should be used instead.")]
    bool GetProviderSuppliesComponent(out SCR_CampaignSuppliesComponent suppliesComponent)
    {
        if (m_aProvidersComponents.IsEmpty())
            return false;
 
        IEntity parent = GetProviderEntity();
        while (parent)
        {
            suppliesComponent = SCR_CampaignSuppliesComponent.Cast(parent.FindComponent(SCR_CampaignSuppliesComponent));
            if (suppliesComponent)
                return true;
 
            parent = parent.GetParent();
        }
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_FactionAffiliationComponent GetProviderFactionComponent()
    {
        if (m_aProvidersComponents.IsEmpty())
            return null;
 
        SCR_FactionAffiliationComponent factionComp;
        IEntity parent = GetProviderEntity();
        while (parent)
        {
            factionComp = SCR_FactionAffiliationComponent.Cast(parent.FindComponent(SCR_FactionAffiliationComponent));
            if (factionComp)
                return factionComp;
 
            parent = parent.GetParent();
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptedGameTriggerEntity GetTrigger()
    {       
        return m_BuildingAreaTrigger;
    }
 
    //------------------------------------------------------------------------------------------------
    //~  This function will add/remove the faction label of the saved editor state. Thus displaying the correct faction entities in the menu
    protected void AddRemoveFactionLabel(SCR_Faction faction, bool addLabel)
    {
        if (!faction)
            return;
 
        m_ContentBrowserManager.AddRemoveLabelOfPersistentBrowserState(faction.GetFactionLabel(), addLabel);
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptedGameTriggerEntity SpawnClientTrigger()
    {
        BaseGameMode gameMode = GetGame().GetGameMode();
 
        SCR_CampaignBuildingManagerComponent buildingManagerComponent = SCR_CampaignBuildingManagerComponent.Cast(gameMode.FindComponent(SCR_CampaignBuildingManagerComponent));
        if (!buildingManagerComponent)
            return null;
 
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent();
        if (!providerComponent)
            return null;
        
        IEntity provider = GetProviderEntity(providerComponent.UseMasterProvider());
        if (!provider)
            return null;
 
        Resource resource = Resource.Load(buildingManagerComponent.GetClientTriggerResourceName());
        if (!resource || !resource.IsValid())
            return null;
 
        EntitySpawnParams params = new EntitySpawnParams();
        params.TransformMode = ETransformMode.LOCAL;
        params.Parent = provider;
 
        return ScriptedGameTriggerEntity.Cast(GetGame().SpawnEntityPrefab(resource, provider.GetWorld(), params));
    }
 
    //---- REFACTOR NOTE START: Has a hot fix for content browser as for some reason it would show an empty entry. So we skip an entry from the catalog and simply hide it ----
    //------------------------------------------------------------------------------------------------
    override protected void EOnEditorActivate()
    {
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent(true);
        if (!providerComponent)
            return;
        
        if (!System.IsConsoleApp() && GetGame().GetPlayerController())
        {
            m_BuildingAreaTrigger = SpawnClientTrigger();
 
            if (m_BuildingAreaTrigger)
            {
                m_BuildingAreaTrigger.SetSphereRadius(providerComponent.GetBuildingRadius());
 
                SCR_CampaignBuildingAreaMeshComponent areaMeshComponent = SCR_CampaignBuildingAreaMeshComponent.Cast(m_BuildingAreaTrigger.FindComponent(SCR_CampaignBuildingAreaMeshComponent));
                if (areaMeshComponent && areaMeshComponent.ShouldEnableFrameUpdateDuringEditor())
                {
                    areaMeshComponent.ActivateEveryFrame();
                    areaMeshComponent.GenerateAreaMesh();
                }
 
                m_BuildingAreaTrigger.SetFlags(EntityFlags.VISIBLE, false);
            }
        }
        
        if (providerComponent.ObstrucViewWhenEnemyInRange())
            SetOnEnterEvent();
 
        m_ContentBrowserManager = SCR_ContentBrowserEditorComponent.Cast(SCR_ContentBrowserEditorComponent.GetInstance(SCR_ContentBrowserEditorComponent));
 
        FactionAffiliationComponent factionComponent = GetProviderFactionComponent();
        if (!factionComponent)
            return;
 
        Faction buildingFaction;
        if (SCR_VehicleFactionAffiliationComponent.Cast(factionComponent))
            buildingFaction = factionComponent.GetDefaultAffiliatedFaction();
        else
        {
            buildingFaction = factionComponent.GetAffiliatedFaction();
 
            if (!buildingFaction)
                buildingFaction = factionComponent.GetDefaultAffiliatedFaction();
        }
 
        if (buildingFaction)
            AddRemoveFactionLabel(SCR_Faction.Cast(buildingFaction), true);
 
        array<SCR_EditorContentBrowserSaveStateDataUI> contentBrowserStates = {};
        int tabsCount = m_ContentBrowserManager.GetContentBrowserTabStates(contentBrowserStates);
 
        for (int i = 0; i < tabsCount; i++)
        {
            if (!contentBrowserStates[i])
                continue;
            
            //~ Todo: Fix first tab being broken
            //~ Hotfix for first tab being broken
            if (i == 0 || !CanBeShown(contentBrowserStates[i]))
                m_ContentBrowserManager.SetStateTabVisible(i, false);
        }
 
        ToggleBuildingTool(false);
 
        SCR_CampaignBuildingProviderComponent nonMasterProviderComponent = GetProviderComponent(false);
        if (!nonMasterProviderComponent)
            return;
 
        if (!nonMasterProviderComponent.UseAllAvailableProviders())
            return;
 
        array<SCR_MilitaryBaseComponent> bases = {};
        int basesCount = nonMasterProviderComponent.GetBases(bases);
        if (basesCount > 0)
        {
            bases[0].GetOnMilitaryBaseRegistered().Insert(OnMilitaryBaseRegistrationChanged);
            bases[0].GetOnMilitaryBaseUnregistered().Insert(OnMilitaryBaseRegistrationChanged);
        }
    }
    //---- REFACTOR NOTE END ----
 
    //------------------------------------------------------------------------------------------------
    bool CanBeShown(notnull SCR_EditorContentBrowserSaveStateDataUI tab)
    {
        if (!TabContainLabel(tab))
            return false;
 
        return tab.CanBeShown(GetProviderEntity(), m_Manager.GetPlayerID());
    }
    
    //------------------------------------------------------------------------------------------------
    bool IsViewObstructed()
    {
        return m_bViewObstructed;
    }
 
    //------------------------------------------------------------------------------------------------
    bool TabContainLabel(SCR_EditorContentBrowserSaveStateDataUI tab)
    {
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent();
        if (!providerComponent)
            return false;
 
        array<EEditableEntityLabel> labels = providerComponent.GetAvailableTraits();
        if (labels.Contains(EEditableEntityLabel.SERVICE_HQ) && !SCR_CampaignBuildingProviderComponent.CanBeUsedToEstablishBase(providerComponent.GetOwner(), m_Manager.GetPlayerID()))
            labels.RemoveItem(EEditableEntityLabel.SERVICE_HQ);
 
        foreach (EEditableEntityLabel label : labels)
        {
            if (tab.ContainsLabel(label))
                return true;
        }
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsProviderBase()
    {
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent();
        if (!providerComponent)
            return false;
 
        return providerComponent.GetMilitaryBaseComponent();
    }
 
    //------------------------------------------------------------------------------------------------
    void ToggleBuildingTool(bool mode)
    {
        IEntity player = EntityUtils.GetPlayer();
        if (!player)
            return;
 
        SCR_GadgetManagerComponent gadgetManager = SCR_GadgetManagerComponent.GetGadgetManager(player);
        if (!gadgetManager)
            return;
        
        SCR_CampaignBuildingGadgetToolComponent gadgetComponent = SCR_CampaignBuildingGadgetToolComponent.Cast(gadgetManager.GetHeldGadgetComponent());
        if (!gadgetComponent)
            return;
                
        if (mode)
            gadgetComponent.ToolToHand();
        else
            gadgetComponent.ToolToInventory();
    }
    
    //------------------------------------------------------------------------------------------------
    protected void SetOnEnterEvent()
    {
        SCR_FreeRoamBuildingClientTriggerEntity trigger = SCR_FreeRoamBuildingClientTriggerEntity.Cast(GetTrigger());
        if (!trigger)
            return;
        
        trigger.GetOnEntityEnterTrigger().Insert(EntityEnterTrigger);
        trigger.GetOnEntityLeaveTrigger().Insert(EntityLeaveTrigger);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void EntityEnterTrigger(IEntity ent)
    {
        if (CanBlockView(ent))
        {
            SetOnEntityKilled(ent);
            
            // show the notification and rise an event only when this is for the first time.
            if (!m_bViewObstructed && m_OnObstructionEventTriggered)
            {
                m_OnObstructionEventTriggered.Invoke(true);
                SCR_NotificationsComponent.SendLocal(ENotification.EDITOR_ENEMY_IN_AREA);
                m_bViewObstructed = true;
            }
        }
    }
    
    //------------------------------------------------------------------------------------------------
    // Called when entity leaves the trigger. Can be also when the entity is killed or deleted.
    protected void EntityLeaveTrigger(IEntity ent)
    {           
        if (!ent)
            return;
        
        if (CanBlockView(ent))
            RemoveOnEntityKilled(ent);
        
        ScriptedGameTriggerEntity trigger = GetTrigger();
        if (!trigger)
            return;
        
        trigger.QueryEntitiesInside();
        array<IEntity> entitiesInside = {};
        trigger.GetEntitiesInside(entitiesInside);
        
        // Check if in trigger is still present any entity that can block the view. If so, don't continue.
        foreach (IEntity entity : entitiesInside)
        {
            // The entity that triggers an event as the leaving one is still on the list of entities present in trigger, skip it.
            if (ent == entity)
                continue;
            
            if (entity && CanBlockView(entity))
                return;
        }
        
        if (m_OnObstructionEventTriggered)
            m_OnObstructionEventTriggered.Invoke(false);
        
        m_bViewObstructed = false;
    }
    
    //------------------------------------------------------------------------------------------------
    protected bool CanBlockView(notnull IEntity ent)
    {
        SCR_ChimeraCharacter character = SCR_ChimeraCharacter.Cast(ent);
        if (!character)
            return false;
        
        CharacterControllerComponent charControl = character.GetCharacterController();
        if (!charControl || charControl.GetLifeState() == ECharacterLifeState.DEAD)
            return false;
 
        int playerId = SCR_PossessingManagerComponent.GetPlayerIdFromControlledEntity(ent);
        if (playerId == 0)
        {           
            AIControlComponent ctrComp = charControl.GetAIControlComponent();
            if (ctrComp && !ctrComp.IsAIActivated())
                return false;
        }
 
        foreach (SCR_CampaignBuildingProviderComponent providerComponent : m_aProvidersComponents)
        {
            if (!providerComponent || !providerComponent.IsEnemyFaction(character))
                continue;
 
            return true;
        }
        
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    void SetOnEntityKilled(IEntity ent)
    {
        SCR_EditableCharacterComponent editableCharacter = SCR_EditableCharacterComponent.Cast(ent.FindComponent(SCR_EditableCharacterComponent));
        if (!editableCharacter)
            return;
        
        editableCharacter.GetOnDestroyed().Insert(EntityLeaveTrigger);
        editableCharacter.GetOnDeleted().Insert(EntityLeaveTrigger);
    }
    
    //------------------------------------------------------------------------------------------------
    void RemoveOnEntityKilled(IEntity ent)
    {
        SCR_EditableCharacterComponent editableCharacter = SCR_EditableCharacterComponent.Cast(ent.FindComponent(SCR_EditableCharacterComponent));
        if (!editableCharacter)
            return;
        
        editableCharacter.GetOnDestroyed().Remove(EntityLeaveTrigger);
        editableCharacter.GetOnDeleted().Remove(EntityLeaveTrigger);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ECharacterRank GetUserRank()
    {
        int playerId = SCR_PlayerController.GetLocalPlayerId();
 
        PlayerController playerController = GetGame().GetPlayerManager().GetPlayerController(playerId);
        if (!playerController)
            return SCR_ECharacterRank.INVALID;
 
        return SCR_CharacterRankComponent.GetCharacterRank(playerController.GetControlledEntity());
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void EOnEditorOpenServer()
    {
        SCR_MilitaryBaseComponent base;
 
        IEntity provider = GetProviderEntity();
        if (provider)
        {
            SCR_CampaignBuildingProviderComponent providerComponent = SCR_CampaignBuildingProviderComponent.Cast(provider.FindComponent(SCR_CampaignBuildingProviderComponent));
            if (!providerComponent)
                return;
 
            base = providerComponent.GetMilitaryBaseComponent();
        }
 
        if (base)
            return;
 
        GetGame().GetWorld().QueryEntitiesBySphere(GetProviderEntity().GetOrigin(), GetProviderComponent().GetBuildingRadius(), AssociateCompositionsToProvider, null, EQueryEntitiesFlags.ALL);
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void EOnEditorCloseServer()
    {
        ToggleBuildingTool(true);
 
        IEntity provider = GetProviderEntity();
        if (!provider)
            return;
 
        // In case the provider of the building was the base, don't remove it's stamp from component. So the composition can't be build from another providers
        SCR_CampaignBuildingProviderComponent providerComponent = SCR_CampaignBuildingProviderComponent.Cast(provider.FindComponent(SCR_CampaignBuildingProviderComponent));
        if (!providerComponent)
            return;
 
        SCR_MilitaryBaseComponent base = providerComponent.GetMilitaryBaseComponent();
        if (base)
            return;
 
        GetGame().GetWorld().QueryEntitiesBySphere(GetProviderEntity().GetOrigin(), GetProviderComponent().GetBuildingRadius(), UnassignCompositionProvider, null, EQueryEntitiesFlags.ALL);
    }
 
    //------------------------------------------------------------------------------------------------
    bool AssociateCompositionsToProvider(IEntity ent)
    {
        SCR_EditableEntityComponent editableComponent = SCR_EditableEntityComponent.Cast(ent.FindComponent(SCR_EditableEntityComponent));
        if (!editableComponent || editableComponent.GetParentEntity())
            return true;
 
        SCR_CampaignBuildingCompositionComponent comp = SCR_CampaignBuildingCompositionComponent.Cast(ent.FindComponent(SCR_CampaignBuildingCompositionComponent));
        if (!comp)
            return true;
 
        // compositioni has no owner, set one.
        if (comp.GetProviderEntity() == null)
            comp.SetProviderEntityServer(GetProviderEntity());
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    bool UnassignCompositionProvider(IEntity ent)
    {
        SCR_EditableEntityComponent editableComponent = SCR_EditableEntityComponent.Cast(ent.FindComponent(SCR_EditableEntityComponent));
        if (!editableComponent || editableComponent.GetParentEntity())
            return true;
 
        SCR_CampaignBuildingCompositionComponent comp = SCR_CampaignBuildingCompositionComponent.Cast(ent.FindComponent(SCR_CampaignBuildingCompositionComponent));
        if (!comp)
            return true;
 
        if (comp.GetProviderEntity() == GetProviderEntity())
            comp.SetProviderEntityServer(null);
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void EOnEditorPostActivate()
    {
        if (!m_RplComponent.IsOwner())
            return;
 
        if (!m_aProvidersComponents.IsEmpty() || m_ForcedProviderComponent)
            return;
 
        SCR_CampaignBuildingNetworkComponent buildingNetworkingComp = SCR_CampaignBuildingNetworkComponent.Cast(SCR_PlayerController.s_pLocalPlayerController.FindComponent(SCR_CampaignBuildingNetworkComponent));
        if (buildingNetworkingComp)
            buildingNetworkingComp.RequestBuildModeProvider();
    }
 
    //------------------------------------------------------------------------------------------------
    void SendProviders_S()
    {
        if (m_aProvidersComponents.IsEmpty() && !m_ForcedProviderComponent)
            m_Manager.Close();
 
        RplComponent providerRplComp;
        array<RplId> providerIds = {};
        foreach (SCR_CampaignBuildingProviderComponent providerComp : m_aProvidersComponents)
        {
            if (!providerComp)
                continue;
 
            providerRplComp = SCR_EntityHelper.GetEntityRplComponent(providerComp.GetOwner());
            if (providerRplComp)
                providerIds.Insert(providerRplComp.Id());
        }
 
        RplId forcedProviderId = RplId.Invalid();
        if (m_ForcedProviderComponent)
        {
            providerRplComp = SCR_EntityHelper.GetEntityRplComponent(m_ForcedProviderComponent.GetOwner());
            if (providerRplComp)
                forcedProviderId = providerRplComp.Id();
        }
 
        if (forcedProviderId.IsValid() && providerIds.IsEmpty())
        {
            m_Manager.Close();
            return;
        }
 
        Rpc(RpcDo_SyncBuildModeProviders, providerIds, forcedProviderId);
    }
 
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Owner)]
    protected void RpcDo_SyncBuildModeProviders(array<RplId> providers, RplId forcedProvider)
    {
        RplComponent providerRplComp = RplComponent.Cast(Replication.FindItem(forcedProvider));
        IEntity providerEnt;
        SCR_CampaignBuildingProviderComponent providerComp;
        if (providerRplComp)
        {
            providerEnt = providerRplComp.GetEntity();
            providerComp = SCR_CampaignBuildingProviderComponent.Cast(providerEnt.FindComponent(SCR_CampaignBuildingProviderComponent));
            if (providerComp)
                SetForcedProvider(providerComp);
        }
 
        if (providers)
        {
            foreach (RplId providerRplId : providers)
            {
                providerRplComp = RplComponent.Cast(Replication.FindItem(providerRplId));
                if (!providerRplComp)
                    continue;
 
                providerEnt = providerRplComp.GetEntity();
                if (!providerEnt)
                    continue;
 
                providerComp = SCR_CampaignBuildingProviderComponent.Cast(providerEnt.FindComponent(SCR_CampaignBuildingProviderComponent));
                if (providerComp)
                    AddProviderEntityEditorComponent(providerComp);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void EOnEditorDeactivate()
    {
        ScriptedGameTriggerEntity trigger = GetTrigger();
        if (trigger)
        {
            IEntity ent = trigger.GetParent();
            if (ent)
                ent.RemoveChild(trigger);
        
            trigger.Update();
            SCR_EntityHelper.DeleteEntityAndChildren(trigger);
        }
 
        FactionAffiliationComponent factionComponent = GetProviderFactionComponent();
        if (factionComponent)
        {
            // here we have to check both Affiliated faction and Default affiliated faction in case of vehicles. It's because vehicles can't have set a affiliated faction if no one is sitting inside (to prevent AI to shoot at empty vehicles)
            Faction buildingFaction = factionComponent.GetAffiliatedFaction();
 
            if (!buildingFaction)
                buildingFaction = factionComponent.GetDefaultAffiliatedFaction();
 
            if (buildingFaction)
                AddRemoveFactionLabel(SCR_CampaignFaction.Cast(buildingFaction), false);
        }
        
        ToggleBuildingTool(true);
 
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent(false);
        if (!providerComponent)
            return;
 
        if (!providerComponent.UseAllAvailableProviders())
            return;
 
        array<SCR_MilitaryBaseComponent> bases = {};
        int basesCount = providerComponent.GetBases(bases);
        if (basesCount > 0)
        {
            bases[0].GetOnMilitaryBaseRegistered().Remove(OnMilitaryBaseRegistrationChanged);
            bases[0].GetOnMilitaryBaseUnregistered().Remove(OnMilitaryBaseRegistrationChanged);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnMilitaryBaseRegistrationChanged(SCR_MilitaryBaseLogicComponent baseComponent)
    {
        SCR_CampaignBuildingProviderComponent provider = SCR_CampaignBuildingProviderComponent.Cast(baseComponent);
        if (!provider)
            return;
 
        UpdateTabs();
    }
 
    //------------------------------------------------------------------------------------------------
    void UpdateTabs()
    {
        if (!m_ContentBrowserManager)
            m_ContentBrowserManager = SCR_ContentBrowserEditorComponent.Cast(SCR_ContentBrowserEditorComponent.GetInstance(SCR_ContentBrowserEditorComponent));
 
        array<SCR_EditorContentBrowserSaveStateDataUI> contentBrowserStates = {};
        int tabsCount = m_ContentBrowserManager.GetContentBrowserTabStates(contentBrowserStates);
 
        for (int i = 0; i < tabsCount; i++)
        {
            if (!contentBrowserStates[i])
                continue;
 
            if (i == 0 || !CanBeShown(contentBrowserStates[i]))
                m_ContentBrowserManager.SetStateTabVisible(i, false);
            else
                m_ContentBrowserManager.SetStateTabVisible(i, true);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    // Return the entity which belongs to currently active provider componenet.
    IEntity GetProviderEntity(bool getMasterProvider = false)
    {
        if (getMasterProvider)
            return GetMasterProviderEntity();
        
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent();
        if (!providerComponent)
            return null;
 
        return providerComponent.GetOwner();
    }
    
    //------------------------------------------------------------------------------------------------
    IEntity GetMasterProviderEntity()
    {
        SCR_CampaignBuildingProviderComponent providerComponent = GetProviderComponent();
        if (!providerComponent)
            return null;
        
        return providerComponent.GetMasterProviderEntity();
    }
 
    //------------------------------------------------------------------------------------------------
    void SetProviderFromRplID()
    {
        int count = m_aProvidersRplIds.Count();
        for (int i = 0; i < count; i++)
        {
            RplComponent rplComp = RplComponent.Cast(Replication.FindItem(m_aProvidersRplIds[i]));
            if (!rplComp)
                continue;
 
            IEntity provider = rplComp.GetEntity();
            if (!provider)
                continue;
 
            SCR_CampaignBuildingProviderComponent providerComponent = SCR_CampaignBuildingProviderComponent.Cast(provider.FindComponent(SCR_CampaignBuildingProviderComponent));
            if (!providerComponent)
                continue;
 
            AddProviderEntityEditorComponent(providerComponent);
            m_aProvidersRplIds.RemoveOrdered(i);
            count--;
        }
 
        if (m_aProvidersRplIds.IsEmpty())
            SCR_CampaignBuildingProviderComponent.GetOnProviderCreated().Remove(SetProviderFromRplID);
    }
 
    //------------------------------------------------------------------------------------------------
    private void RequestRecreationOfEditors()
    {
        m_Manager.Close();
        m_Manager.RecreateEditorModes();
    }
 
    //------------------------------------------------------------------------------------------------
    override protected bool RplSave(ScriptBitWriter writer)
    {
        array<RplId> providers = {};
        RplComponent rplComp;
        IEntity provider;
        
        if (m_aProvidersComponents.Contains(null))
        {
            if (GetGame().IsDev())
                Debug.Error(string.Format("WARNING: SCR_CampaignBuildingEditorComponent.RplSave encountered a null in the list of providers while packing data for the editor %1, which belongs to the player %2", FilePath.StripPath(GetOwner().GetPrefabData().GetPrefabName().GetPath()), SCR_PlayerIdentityUtils.GetPlayerLogInfo(m_Manager.GetPlayerID())));
 
            GetGame().GetCallqueue().CallLater(RequestRecreationOfEditors); // wait with closing and recreation until we are done with sending information to the client
        }
 
        foreach (SCR_CampaignBuildingProviderComponent providerComponent : m_aProvidersComponents)
        {
            if (!providerComponent)
                continue;
 
            provider = providerComponent.GetOwner();
            if (!provider)
                continue;
 
            rplComp = SCR_EntityHelper.GetEntityRplComponent(provider);
            if (rplComp)
                providers.Insert(rplComp.Id());
        }
 
        int count = providers.Count();
        writer.WriteInt(count);
        foreach (RplId rplId : providers)
        {
            writer.WriteRplId(rplId);
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override protected bool RplLoad(ScriptBitReader reader)
    {
        RplId entityRplID;
        RplComponent rplComp;
        IEntity ent;
        int count;
        SCR_CampaignBuildingProviderComponent providerComponent;
        reader.ReadInt(count);
 
        for (int i = 0; i < count; i++)
        {
            reader.ReadRplId(entityRplID);
            if (!entityRplID.IsValid())
                continue;
 
            rplComp = RplComponent.Cast(Replication.FindItem(entityRplID));
            if (!rplComp)
            {
                m_aProvidersRplIds.Insert(entityRplID);
                continue;
            }
 
            ent = rplComp.GetEntity();
            if (!ent)
                continue;
 
            providerComponent = SCR_CampaignBuildingProviderComponent.Cast(ent.FindComponent(SCR_CampaignBuildingProviderComponent));
            if (providerComponent)
                AddProviderEntityEditorComponent(providerComponent);
        }
 
        if (!m_aProvidersRplIds.IsEmpty())
            SCR_CampaignBuildingProviderComponent.GetOnProviderCreated().Insert(SetProviderFromRplID);
 
        if (!m_aProvidersComponents.IsEmpty())
            GetOnProviderChanged().Invoke(m_aProvidersComponents[0]);
 
        return true;
    }
}