SCR_CampaignBuildingStartUserAction.c

Go to the documentation of this file.

//------------------------------------------------------------------------------------------------
class SCR_CampaignBuildingStartUserAction : ScriptedUserAction
{
    [Attribute(desc: "Action name if supplies are disabled")]
    protected LocalizedString m_sActionNameNoSupplies;
    
    protected SCR_ResourceSystemSubscriptionHandleBase m_ResourceSubscriptionHandleConsumer;
    protected RplId m_ResourceInventoryPlayerComponentRplId;
    protected SCR_ResourceComponent m_ResourceComponent;
    protected SCR_ResourceConsumer m_ResourceConsumer;
    protected SCR_CampaignBuildingProviderComponent m_ProviderComponent;
    protected Physics m_ProviderPhysics;
    protected RplComponent m_RplComponent;
    protected DamageManagerComponent m_DamageManager;
    protected SCR_CompartmentAccessComponent m_CompartmentAccess;
    protected bool m_bUseRankLimitedAccess;
    protected bool m_bTemporarilyBlockedAccess;
    protected bool m_bAccessCanBeBlocked;
    protected bool m_bRankLimitationCanBeUsed;
 
    protected const int PROVIDER_SPEED_TO_REMOVE_BUILDING_SQ = 1;
    protected const int TEMPORARY_BLOCKED_ACCESS_RESET_TIME = 1000;
    
    //------------------------------------------------------------------------------------------------
    protected override void Init(IEntity pOwnerEntity, GenericComponent pManagerComponent)
    {
        m_RplComponent = RplComponent.Cast(GetOwner().FindComponent(RplComponent));
        InitializeSuppliesComponent();
        
        m_DamageManager = DamageManagerComponent.Cast(GetOwner().FindComponent(DamageManagerComponent));
        
        if (GetGame().GetPlayerController())
            m_ResourceInventoryPlayerComponentRplId = Replication.FindId(SCR_ResourcePlayerControllerInventoryComponent.Cast(GetGame().GetPlayerController().FindComponent(SCR_ResourcePlayerControllerInventoryComponent)));
        
        if (m_ProviderComponent && m_ProviderComponent.ObstrucViewWhenEnemyInRange())
            m_bAccessCanBeBlocked = true;
        
        BaseGameMode gameMode = GetGame().GetGameMode();
        if (gameMode)
            m_bRankLimitationCanBeUsed = SCR_XPHandlerComponent.Cast(gameMode.FindComponent(SCR_XPHandlerComponent));
    }
    
    //------------------------------------------------------------------------------------------------
    void InitializeSuppliesComponent()
    {
        IEntity mainParent = SCR_EntityHelper.GetMainParent(GetOwner(), true);
        m_ProviderPhysics = mainParent.GetPhysics();
        m_ProviderComponent = SCR_CampaignBuildingProviderComponent.Cast(GetOwner().FindComponent(SCR_CampaignBuildingProviderComponent));
    }
    
    //------------------------------------------------------------------------------------------------
    override void PerformAction(IEntity pOwnerEntity, IEntity pUserEntity)
    {
        int playerID = GetGame().GetPlayerManager().GetPlayerIdFromControlledEntity(pUserEntity);
        m_ProviderComponent.RequestBuildingMode(playerID, true);
    }
    
    //------------------------------------------------------------------------------------------------
    override bool CanBePerformedScript(IEntity user)
    {
        if (!m_ProviderComponent || m_bTemporarilyBlockedAccess)
            return false;
        
        if (m_bRankLimitationCanBeUsed && m_ProviderComponent.GetAccessRank() > GetUserRank(user))
        {
            FactionAffiliationComponent factionAffiliationComp = FactionAffiliationComponent.Cast(user.FindComponent(FactionAffiliationComponent));
            if (!factionAffiliationComp)
                return false;
            
            string rankName;
            SCR_Faction faction = SCR_Faction.Cast(factionAffiliationComp.GetAffiliatedFaction());
            if (faction)
                rankName = faction.GetRankName(m_ProviderComponent.GetAccessRank());
                
            SetCannotPerformReason(rankName);
            return false;
        }
        
        if (m_bAccessCanBeBlocked)
        {
            SetTemporaryBlockedAccess();
        
            if (m_bTemporarilyBlockedAccess)
            {
                SetCannotPerformReason("#AR-Campaign_Action_ShowBuildPreviewEnemyPresence");
                return false;
            }
        }
 
        return true;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_ECharacterRank GetUserRank(notnull IEntity user)
    {
        int playerId = GetGame().GetPlayerManager().GetPlayerIdFromControlledEntity(user);
        PlayerController playerController = GetGame().GetPlayerManager().GetPlayerController(playerId);
        if (!playerController)
            return SCR_ECharacterRank.INVALID;
        
        return SCR_CharacterRankComponent.GetCharacterRank(playerController.GetControlledEntity());
    }
    
    //------------------------------------------------------------------------------------------------
    override bool CanBeShownScript(IEntity user)
    {
        if (!m_ProviderComponent)
            return false;
 
        if (!m_CompartmentAccess)
        {
            m_CompartmentAccess = SCR_CompartmentAccessComponent.Cast(user.FindComponent(SCR_CompartmentAccessComponent));
            
            SCR_PlayerController playerController = SCR_PlayerController.Cast(GetGame().GetPlayerController());
            if (playerController)
                playerController.m_OnControlledEntityChanged.Insert(SetNewCompartmentComponent);
            
            return false;
        }
        
        if (m_CompartmentAccess.IsGettingIn())
            return false;
        
        // Don't quit if the providerPhysics doesn't exist. The provider might not have one.
        if (m_ProviderPhysics)
        {
            vector velocity = m_ProviderPhysics.GetVelocity();
            if ((velocity.LengthSq()) > PROVIDER_SPEED_TO_REMOVE_BUILDING_SQ)
                return false;
        }
        
        // Don't show the action if player is within any vehicle.
        ChimeraCharacter char = ChimeraCharacter.Cast(user);
        if (!char || char.IsInVehicle())
            return false;
        
        // No action if the provider is destroyed
        if (m_DamageManager)
        {
            if (m_DamageManager.GetState() == EDamageState.DESTROYED)
                return false;
        }
                
        return m_ProviderComponent.IsCharacterFactionSame(user);
    }
    
    //------------------------------------------------------------------------------------------------
    override bool GetActionNameScript(out string outName)
    {           
        if (!m_ResourceComponent)
            m_ResourceComponent = m_ProviderComponent.GetResourceComponent();
        
        if (!m_ResourceComponent.IsResourceTypeEnabled() && !m_sActionNameNoSupplies.IsEmpty())
        {
            outName = m_sActionNameNoSupplies;
            return true;
        }
            
        if (!m_ResourceComponent
        ||  !m_ResourceConsumer && !m_ResourceComponent.GetConsumer(EResourceGeneratorID.DEFAULT, EResourceType.SUPPLIES, m_ResourceConsumer))
            return false;
        
        if (!m_ResourceInventoryPlayerComponentRplId || !m_ResourceInventoryPlayerComponentRplId.IsValid())
            m_ResourceInventoryPlayerComponentRplId = Replication.FindId(SCR_ResourcePlayerControllerInventoryComponent.Cast(GetGame().GetPlayerController().FindComponent(SCR_ResourcePlayerControllerInventoryComponent)));
        
        if (m_ResourceSubscriptionHandleConsumer)
            m_ResourceSubscriptionHandleConsumer.Poke();
        else
            m_ResourceSubscriptionHandleConsumer = GetGame().GetResourceSystemSubscriptionManager().RequestSubscriptionListenerHandleGraceful(m_ResourceConsumer, m_ResourceInventoryPlayerComponentRplId);
        
        ActionNameParams[0] = string.ToString(m_ResourceConsumer.GetAggregatedResourceValue());
        
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    override bool HasLocalEffectOnlyScript()
    {
        return true;
    }
            
    //------------------------------------------------------------------------------------------------
    //\param[in] from Entity from which the ownership is being pased
    //\param[in] to Entity to which the ownership is passed
    void SetNewCompartmentComponent(IEntity from, IEntity to)
    {
        if (to)
            m_CompartmentAccess = SCR_CompartmentAccessComponent.Cast(to.FindComponent(SCR_CompartmentAccessComponent));
    }
    
    //------------------------------------------------------------------------------------------------
    void SetTemporaryBlockedAccess()
    {
        IEntity masterProvider = m_ProviderComponent.GetMasterProviderEntity();
        if (!masterProvider)
            return;
        
        SCR_CampaignBuildingProviderComponent masterProviderComponent = SCR_CampaignBuildingProviderComponent.Cast(masterProvider.FindComponent(SCR_CampaignBuildingProviderComponent));
        if (!masterProviderComponent)
            return;
        
        GetGame().GetWorld().QueryEntitiesBySphere(GetOwner().GetOrigin(), masterProviderComponent.GetBuildingRadius(), EvaluateEntity, null, EQueryEntitiesFlags.DYNAMIC);
        GetGame().GetCallqueue().CallLater(ResetTemporaryBlockedAccess, TEMPORARY_BLOCKED_ACCESS_RESET_TIME, false);
    }
    
    //------------------------------------------------------------------------------------------------
    void ResetTemporaryBlockedAccess()
    {
        m_bTemporarilyBlockedAccess = false;
    }
    
    //------------------------------------------------------------------------------------------------
    //\param[in] ent Entity to evaluate by this filter.
    bool EvaluateEntity(IEntity ent)
    {
        if (!ent)
            return true;
        
        SCR_ChimeraCharacter char = SCR_ChimeraCharacter.Cast(ent);
        if (!char)
            return true;
        
        SCR_CharacterDamageManagerComponent charDamageManager = SCR_CharacterDamageManagerComponent.Cast(char.FindComponent(SCR_CharacterDamageManagerComponent));
        if (!charDamageManager || charDamageManager.GetState() == EDamageState.DESTROYED)
            return true;
        
        if (!m_ProviderComponent.IsEnemyFaction(char))
            return true;
        
        CharacterControllerComponent charControl = char.GetCharacterController();
        if (!charControl)
            return true;
        
        int playerId = GetGame().GetPlayerManager().GetPlayerIdFromControlledEntity(ent);
        if (playerId == 0)
        {
            AIControlComponent ctrComp = charControl.GetAIControlComponent();
            if (!ctrComp)
                return true;
            
            if (ctrComp.IsAIActivated())
            {
                m_bTemporarilyBlockedAccess = true;
                return false;
            }
        }
        else
        {
            m_bTemporarilyBlockedAccess = true;
            return false;
        }
        
        return true;
    }
}