SCR_RequiredDeployablePart.c

Go to the documentation of this file.

class SCR_RequiredDeployablePart : ScriptAndConfig
{
    [Attribute(uiwidget: UIWidgets.ResourcePickerThumbnail, desc: "Prefab which is going to be required in order to deploy the main entity", params: "et")]
    protected ResourceName m_sPrefab;
 
    [Attribute(defvalue: "1", desc: "How many required prefabs need to be found in order to meet this requirement", params: "1 inf 1")]
    protected int m_iNumberOfRequiredPrefabs;
 
    [Attribute(desc: "Localized string used to tell the player which part he is missing when wont be found")]
    protected LocalizedString m_sPartName;
 
    [Attribute(defvalue: "1", desc: "Dictates whether elements found for this requirement are meant to be deleted upon deployment")]
    protected bool m_bDeletePartsOnDeployment;
 
    [Attribute(defvalue: "0", desc: "Should game detach the magazines from weapons that are used for this requirement")]
    protected bool m_bDetachMagazinesWhenUsed;
 
    protected ref array<IEntity> m_aFoundEntities;
 
    //------------------------------------------------------------------------------------------------
    ResourceName GetPrefab()
    {
        return m_sPrefab;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetNumberOfRequiredPrefabs(int newValue)
    {
        m_iNumberOfRequiredPrefabs = newValue;
    }
 
    //------------------------------------------------------------------------------------------------
    int GetNumberOfRequiredPrefabs()
    {
        return m_iNumberOfRequiredPrefabs;
    }
 
    //------------------------------------------------------------------------------------------------
    LocalizedString GetPartName()
    {
        return m_sPartName;
    }
 
    //------------------------------------------------------------------------------------------------
    LocalizedString GetMissingPartName()
    {
        return m_sPartName;
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsRequirementMet(out int difference)
    {
        difference = m_iNumberOfRequiredPrefabs;
        if (!m_aFoundEntities)
            return false;
 
        difference -= m_aFoundEntities.Count();
        return difference == 0;
    }
 
    //------------------------------------------------------------------------------------------------
    int GetNumberOfFoundEntities()
    {
        if (!m_aFoundEntities)
            return 0;
 
        return m_aFoundEntities.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    bool ShouldDeleteFoundEntities()
    {
        return m_bDeletePartsOnDeployment;
    }
 
    //------------------------------------------------------------------------------------------------
    array<IEntity> GetFoundEntities()
    {
        return m_aFoundEntities;
    }
 
    //------------------------------------------------------------------------------------------------
    bool EvaluateFoundEntity(vector origin, float distanceSqToFoundEntity, notnull BaseContainer foundPrefab, notnull IEntity foundEntity)
    {
        Resource res = Resource.Load(m_sPrefab);
        if (!res.IsValid())
            return false;
 
        BaseResourceObject resObject = res.GetResource();
        if (!resObject)
            return false;
 
        BaseContainer requiredPrefab = resObject.ToBaseContainer();
        if (requiredPrefab != foundPrefab)
            return false;
 
        if (!m_aFoundEntities || m_aFoundEntities.Count() < m_iNumberOfRequiredPrefabs)
        {
            AddFoundEntity(foundEntity);
            return true;
        }
 
        foreach (int id, IEntity foundElement : m_aFoundEntities)
        {
            if (vector.DistanceSq(foundElement.GetOrigin(), origin) <= distanceSqToFoundEntity)
                continue;
 
            ReplaceFoundEntity(foundEntity, id);
            return true;
        }
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    bool DeleteFoundEntity(int id, notnull IEntity user)
    {
        if (!m_aFoundEntities || !m_aFoundEntities.IsIndexValid(id))
            return false;
 
        IEntity deletedEntity = m_aFoundEntities[id];
        if (!deletedEntity)
            return false;
 
        if (m_bDetachMagazinesWhenUsed)
            SCR_MultiPartDeployableItemComponent.TryRemoveMagazineFromWeapons(deletedEntity, user);
 
        GetGame().GetCallqueue().CallLater(SCR_EntityHelper.DeleteEntityAndChildren, param1: deletedEntity);//to give the time for the RPC calls to be sent
        m_aFoundEntities.Remove(id);
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    void AddFoundEntity(notnull IEntity entity)
    {
        if (!m_aFoundEntities)
            m_aFoundEntities = {entity};
        else if (!m_aFoundEntities.Contains(entity))
            m_aFoundEntities.Insert(entity);
    }
 
    //------------------------------------------------------------------------------------------------
    void ReplaceFoundEntity(notnull IEntity entity, int id)
    {
        if (!m_aFoundEntities || m_aFoundEntities.IsEmpty())
            return;
 
        if (!m_aFoundEntities.IsIndexValid(id) || m_aFoundEntities.Contains(entity))
            return;
 
        m_aFoundEntities[id] = entity;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_RequiredDeployablePart DeepClone()
    {
        return SCR_RequiredDeployablePart.Cast(Clone());
    }
}