SCR_BaseCompartmentManagerComponent.c

Go to the documentation of this file.

class SCR_BaseCompartmentManagerComponentClass : BaseCompartmentManagerComponentClass
{
    [Attribute("0", desc: "Will block supply actions if one or more compartments are occupied as well as blocking player get in actions if there are supplies. This is a hotfix until proper solution as it simply disables some player actions on the surface rather than with proper logic and does not effect AI")]
    protected bool m_bBlockSuppliesIfOccupied;
 
    //------------------------------------------------------------------------------------------------
    bool ShouldBlockSuppliesIfOccupied()
    {
        return m_bBlockSuppliesIfOccupied;
    }
}
 
class SCR_BaseCompartmentManagerComponent : BaseCompartmentManagerComponent
{
    //Compartment slots associated with crew
    static const ref array<ECompartmentType> CREW_COMPARTMENT_TYPES = {ECompartmentType.PILOT, ECompartmentType.TURRET};
    
    //Compartment slots associated with passengers
    static const ref array<ECompartmentType> PASSENGER_COMPARTMENT_TYPES = {ECompartmentType.CARGO};
    
    //~ Default Occupant spawning
    protected ref array<BaseCompartmentSlot> m_aCompartmentsToSpawnDefaultOccupant;
    protected ref array<IEntity> m_aSpawnedDefaultOccupants;
    protected AIGroup m_SpawnedOccupantsAIGroup;
    protected bool m_bIsSpawningDefaultOccupants;
    protected ref ScriptInvoker Event_OnDoneSpawningDefaultOccupants; //~ Send over SCR_BaseCompartmentManagerComponent, array of spawned characters (IEntity) as well as bool WasCanceled
    protected ref array<ref array<ECompartmentType>> m_aDefaultOccupantsCompartmentTypesToSpawn = {}; //~ Keeps track of the default occupants types that need to be spawned. The types grouped together will be spawned in the same group
    
    //------------------------------------------------------------------------------------------------
    bool BlockSuppliesIfOccupied()
    {
        SCR_BaseCompartmentManagerComponentClass data = SCR_BaseCompartmentManagerComponentClass.Cast(GetComponentData(GetOwner()));
        if (!data)
            return false;
 
        return data.ShouldBlockSuppliesIfOccupied();
    }
 
    //------------------------------------------------------------------------------------------------
    void GetCompartmentsOfType(inout array<BaseCompartmentSlot> outCompartments, ECompartmentType compartmentType)
    {
        array<BaseCompartmentSlot> compartments = {}; GetCompartments(compartments);
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            if (compartment && compartment.GetType() == compartmentType)
                outCompartments.Insert(compartment);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void GetCompartmentsOfTypes(inout array<BaseCompartmentSlot> outCompartments, notnull array<ECompartmentType> compartmentTypes)
    {
        outCompartments.Clear();
        array<BaseCompartmentSlot> compartments = {}; 
        GetCompartments(compartments);
        
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            if (compartment && compartmentTypes.Contains(compartment.GetType()))
                outCompartments.Insert(compartment);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void GetFreeCompartmentsOfType(inout array<BaseCompartmentSlot> outCompartments, ECompartmentType compartmentType, bool checkHasValidOccupantPrefab = false)
    {
        array<BaseCompartmentSlot> compartments = {}; GetCompartments(compartments);
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            if (compartment && compartment.GetType() == compartmentType && !compartment.IsOccupied() && compartment.IsCompartmentAccessible() && (!checkHasValidOccupantPrefab || (checkHasValidOccupantPrefab && !compartment.GetDefaultOccupantPrefab().IsEmpty())))
                outCompartments.Insert(compartment);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    BaseCompartmentSlot GetFirstFreeCompartmentOfType(ECompartmentType compartmentType, bool checkHasValidOccupantPrefab = false)
    {
        array<BaseCompartmentSlot> compartments = {}; GetCompartments(compartments);
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            if (compartment && compartment.GetType() == compartmentType && !compartment.IsOccupied() && compartment.IsCompartmentAccessible() && (!checkHasValidOccupantPrefab || (checkHasValidOccupantPrefab && !compartment.GetDefaultOccupantPrefab().IsEmpty())))
                return compartment;
        }
        
        return null;
    }
    
    //------------------------------------------------------------------------------------------------
    BaseCompartmentSlot GetFirstFreeCompartmentOfType(typename compartmentClass, bool checkHasValidOccupantPrefab = false)
    {
        array<BaseCompartmentSlot> compartments = {}; 
        GetCompartments(compartments);
        
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            if (compartment.Type() != compartmentClass)
                continue;
            
            if (!compartment.IsOccupied() && compartment.IsCompartmentAccessible() && (!checkHasValidOccupantPrefab || !compartment.GetDefaultOccupantPrefab().IsEmpty()))
                return compartment;
        }
        
        return null;
    }
    
    //------------------------------------------------------------------------------------------------
    bool HasFreeCompartmentOfTypes(notnull array<ECompartmentType> compartmentTypes)
    {
        array<BaseCompartmentSlot> compartments = {}; 
        
        foreach (ECompartmentType type: compartmentTypes)
        {
            compartments.Clear();
            GetCompartmentsOfType(compartments, type);
            
            foreach (BaseCompartmentSlot compartment: compartments)
            {
                if (!compartment.IsOccupied() && compartment.IsCompartmentAccessible())
                    return true;
            }
        }
        
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetOccupantCount()
    {
        array<IEntity> occupants = {};
        GetOccupants(occupants);
        
        return occupants.Count();
    }
 
    //------------------------------------------------------------------------------------------------
    void GetOccupants(inout array<IEntity> occupants)
    {
        array<BaseCompartmentSlot> compartments = {}; GetCompartments(compartments);
        IEntity occupant;
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            occupant = compartment.GetOccupant();
            if (occupant)
                occupants.Insert(occupant);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void GetOccupantsOfType(inout array<IEntity> occupants, ECompartmentType compartmentType)
    {
        array<BaseCompartmentSlot> compartments = {}; GetCompartmentsOfType(compartments, compartmentType);
        IEntity occupant;
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            occupant = compartment.GetOccupant();
            if (occupant)
                occupants.Insert(occupant);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void DamageOccupants(float damage, EDamageType damageType, notnull Instigator instigator, bool damageWhileGetIn = false, bool damageWhileGetOut = false)
    {
        if (damage == 0)
            return;
        
        array<BaseCompartmentSlot> compartments = {}; 
        GetCompartments(compartments);
        
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            if (compartment)
            {
                compartment.DamageOccupant(damage, damageType, instigator, damageWhileGetIn, damageWhileGetOut);
                if (damageType == EDamageType.COLLISION)
                    compartment.ScreenShakeOccupant(damage);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void KillOccupants(notnull Instigator instigator, bool eject = false, bool gettingIn = false, bool gettingOut = false)
    {
        array<BaseCompartmentSlot> compartments = {};
        GetCompartments(compartments);
 
        foreach (BaseCompartmentSlot compartment : compartments)
        {
            if (compartment)
                compartment.KillOccupant(instigator, eject, gettingIn, gettingOut);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    bool EjectRandomOccupants(float ejectionChance = -1, bool ejectUnconscious = false, out bool allEjectedImmediately = true, bool ejectOnTheSpot = false)
    {
        array<BaseCompartmentSlot> compartments = {};
        GetCompartments(compartments);
 
        bool characterEjected;
        bool ejectedImmediately;
        allEjectedImmediately = true;
        foreach (BaseCompartmentSlot compartment : compartments)
        {
            // if ejectionChance is <0, eject if random > compartmentChance
            float random = Math.RandomFloat01();
            if (ejectionChance < 0)
            {
                if (random > compartment.GetRandomEjectionChance())
                    continue;
            }// if ejectionChance is 0>&&<1, eject if random > ejectionChance 
            else if (ejectionChance > 0 && ejectionChance < 1)
            {
                if (random > ejectionChance)
                    continue;
            }
            // else if (ejectionChance ==  1) force eject
            if (compartment)
            {
                characterEjected = compartment.EjectOccupant(ejectionChance == 1, ejectUnconscious, ejectedImmediately, ejectOnTheSpot) || characterEjected;
                allEjectedImmediately = allEjectedImmediately && ejectedImmediately;
            }
        }
 
        return characterEjected;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetCompartmentsAccessibleForAI(bool accessible)
    {
        array<BaseCompartmentSlot> compartments = {}; 
        GetCompartments(compartments);
        
        foreach (BaseCompartmentSlot compartment: compartments)
            compartment.SetCompartmentAccessible(accessible);
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnDoneSpawningDefaultOccupants()
    {
        if (!Event_OnDoneSpawningDefaultOccupants)
            Event_OnDoneSpawningDefaultOccupants = new ScriptInvoker;
        
        return Event_OnDoneSpawningDefaultOccupants;
    }
    
    //------------------------------------------------------------------------------------------------
    void SetAllCompartmentsAccessibleOfTypes(notnull array<ECompartmentType> compartmentTypes, bool setAccessible)
    {
        array<BaseCompartmentSlot> compartments = {};
        GetCompartmentsOfTypes(compartments, compartmentTypes);
        
        foreach(BaseCompartmentSlot compartment: compartments)
        {           
            compartment.SetCompartmentAccessible(setAccessible);
        }
    }
    
    //--------------------------------------------------- Check can occupy with characters ---------------------------------------------------\\
 
    //------------------------------------------------------------------------------------------------
    bool CanOccupy(array<ECompartmentType> compartmentTypes, bool checkHasDefaultOccupantsData = true, FactionKey friendlyFaction = string.Empty, bool checkOccupyingFaction = true, bool checkForFreeCompartments = true)
    {
        if (m_bIsSpawningDefaultOccupants)
            return false;
        
        //~ Check if default character data is defined
        if (checkHasDefaultOccupantsData && !HasDefaultOccupantsDataForTypes(compartmentTypes))
            return false;
        
        //~ Check if all occupants in vehicle are friendly. If not return false
        if (checkOccupyingFaction && !IsOccupiedByFriendlies(friendlyFaction, true))
            return false;
 
        //~ Check if there is at least one free compartment. If not return false
        if (checkForFreeCompartments && !HasFreeCompartmentOfTypes(compartmentTypes))
            return false;
        
        return true;
    }   
    
    //--------------------------------------------------- Spawn default occupants ---------------------------------------------------\\
 
    //------------------------------------------------------------------------------------------------
    bool SpawnDefaultOccupants(notnull array<ECompartmentType> compartmentTypes)
    {
        //~ No compartment types given to spawn
        if (compartmentTypes.IsEmpty())
        {
            if (Event_OnDoneSpawningDefaultOccupants)
                Event_OnDoneSpawningDefaultOccupants.Invoke(this, null, true);
            
            return false;
        }
        
        //~ Check if is already spawning
        for(int i = 0; i < m_aDefaultOccupantsCompartmentTypesToSpawn.Count(); i++)
        {
            if (!m_aDefaultOccupantsCompartmentTypesToSpawn[i] || m_aDefaultOccupantsCompartmentTypesToSpawn[i].IsEmpty())
            {
                m_aDefaultOccupantsCompartmentTypesToSpawn.RemoveOrdered(i);
                i--;
                continue;
            }
            
            foreach(ECompartmentType type: compartmentTypes)
            {
                //~ Is already spawning the same type
                if (m_aDefaultOccupantsCompartmentTypesToSpawn[i].Contains(type))
                {
                    Print(string.Format("'SCR_BaseCompartmentManagerComponent' is already spawning default occupants of type %1!", typename.EnumToString(ECompartmentType, type)), LogLevel.WARNING);
                    return false; 
                }
            }
        }
        
        //~ Add to spawn list
        m_aDefaultOccupantsCompartmentTypesToSpawn.Insert(compartmentTypes);
        
        //~ Directly spawn in vehicle as not currently spawning anything
        if (!m_bIsSpawningDefaultOccupants)
        {
            return InitiateSpawnDefaultOccupants(compartmentTypes);
        }
        //~ Already spawning so wait until done
        else 
        {
            m_aCompartmentsToSpawnDefaultOccupant = {};
            foreach (ECompartmentType compartmentType: compartmentTypes)
            {
                GetFreeCompartmentsOfType(m_aCompartmentsToSpawnDefaultOccupant, compartmentType, true);
            }
            
            //~ Nothing to spawn in so cancel
            if (m_aCompartmentsToSpawnDefaultOccupant.IsEmpty())
                return false;
        }
        
        return true; 
    }
    
    //~ Actually initia
    protected bool InitiateSpawnDefaultOccupants(notnull array<ECompartmentType> compartmentTypes)
    {   
        m_bIsSpawningDefaultOccupants = true;
        m_aCompartmentsToSpawnDefaultOccupant = {};
        
        foreach (ECompartmentType compartmentType: compartmentTypes)
        {
            GetFreeCompartmentsOfType(m_aCompartmentsToSpawnDefaultOccupant, compartmentType, true);
        }
        
        //~ Nothing to spawn in so cancel
        if (m_aCompartmentsToSpawnDefaultOccupant.IsEmpty())
        {
            FinishedSpawningDefaultOccupants(true);         
            return false;
        }
            
        m_aSpawnedDefaultOccupants = {};
        m_SpawnedOccupantsAIGroup = null;
        
        GetGame().GetCallqueue().CallLater(SpawnDefaultOccupantEachFrame, 0, true);
        return true;
    }
    
    //~ Spawns a character each frame to take the load of the server
    protected void SpawnDefaultOccupantEachFrame()
    {
        BaseCompartmentSlot compartmentToFill = null;
        
        for(int i = 0; i < m_aCompartmentsToSpawnDefaultOccupant.Count(); i++)
        {
            //~ Invalid compartment so remove it from the list
            if (!m_aCompartmentsToSpawnDefaultOccupant[i] || m_aCompartmentsToSpawnDefaultOccupant[i].IsOccupied() || !m_aCompartmentsToSpawnDefaultOccupant[i].IsCompartmentAccessible())
            {
                m_aCompartmentsToSpawnDefaultOccupant.RemoveOrdered(i);
                i--;
                continue;
            }
            
            compartmentToFill = m_aCompartmentsToSpawnDefaultOccupant[i];
            m_aCompartmentsToSpawnDefaultOccupant.RemoveOrdered(i);
            break;
        }
        
        //~ No compartments found
        if (!compartmentToFill)
        {
            FinishedSpawningDefaultOccupants(false);
            return;
        }
        
        IEntity spawnedCharacter = compartmentToFill.SpawnDefaultCharacterInCompartment(m_SpawnedOccupantsAIGroup);
        if (!spawnedCharacter)
            return;
        
        
        m_aSpawnedDefaultOccupants.Insert(spawnedCharacter);
        
        if (m_aCompartmentsToSpawnDefaultOccupant.IsEmpty())
            FinishedSpawningDefaultOccupants(false);
    }
 
    //------------------------------------------------------------------------------------------------
    void CancelSpawningCharacters()
    {
        if (!m_aDefaultOccupantsCompartmentTypesToSpawn.IsEmpty() || m_bIsSpawningDefaultOccupants)
            FinishedSpawningDefaultOccupants(true);
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsSpawningDefaultOccupants()
    {
        return m_bIsSpawningDefaultOccupants;
    }
    
    //~ Called when finished spawning. Note that it will spawn more passengers if it has a queue
    protected void FinishedSpawningDefaultOccupants(bool wasCanceled)
    {
        m_bIsSpawningDefaultOccupants = false;
        SCR_CompartmentAccessComponent compartmentAccess;
        
        if (Event_OnDoneSpawningDefaultOccupants)
            Event_OnDoneSpawningDefaultOccupants.Invoke(this, m_aSpawnedDefaultOccupants, wasCanceled);
        
        m_aSpawnedDefaultOccupants = null;
        m_aCompartmentsToSpawnDefaultOccupant = null;
        GetGame().GetCallqueue().Remove(SpawnDefaultOccupantEachFrame);
        
        //~ Clear queue
        if (wasCanceled)
        {
            m_aDefaultOccupantsCompartmentTypesToSpawn.Clear();
        }
        //~ next in queue
        else 
        {       
            //~ Delete the one just spawned     
            m_aDefaultOccupantsCompartmentTypesToSpawn.RemoveOrdered(m_aDefaultOccupantsCompartmentTypesToSpawn.Count() -1);
            //~ Spawn the entities that where waiting to be spawned
            if (!m_aDefaultOccupantsCompartmentTypesToSpawn.IsEmpty())
                InitiateSpawnDefaultOccupants(m_aDefaultOccupantsCompartmentTypesToSpawn[0]);
        }
    }
    
    //--------------------------------------------------- Vehicle occupied by friendly ---------------------------------------------------\\
 
    //------------------------------------------------------------------------------------------------
    bool IsOccupiedByFriendlies(FactionKey vehicleFactionKey, bool allFriendly, bool trueIfEmpty = true)
    {
        //~ No given string so cannot check
        if (vehicleFactionKey.IsEmpty())
            return false;
        
        array<BaseCompartmentSlot> compartments = {}; 
        GetCompartments(compartments);
        
        if (compartments.IsEmpty())
            return false;
        
        //~ No faction manager so return false
        SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
        if (!factionManager)
            return false;
        
        IEntity occupant; 
        FactionAffiliationComponent factionAffiliationComponent;
        Faction occupantFaction;
        Faction vehicleFaction = factionManager.GetFactionByKey(vehicleFactionKey);
        bool friendlyFound = false;
        bool occupantFound = false;
        
        //~ Go over each compartment and see if it is occupied and if the enetity is an enemy or neutral to the given faction
        foreach (BaseCompartmentSlot compartment: compartments)
        {
            occupant = compartment.GetOccupant();
            
            if (!occupant)
                continue;
            
            occupantFound = true;
            
            factionAffiliationComponent = FactionAffiliationComponent.Cast(occupant.FindComponent(FactionAffiliationComponent));
            if (!factionAffiliationComponent)
                continue;
            
            occupantFaction = factionAffiliationComponent.GetAffiliatedFaction();
            
            //~ Same faction so is friendly
            if (occupantFaction.GetFactionKey() == vehicleFactionKey)
                return true;
            
            //~ Occupent is friendly
            if (vehicleFaction.IsFactionFriendly(occupantFaction))
            {
                if (allFriendly)
                    friendlyFound = true;
                else 
                    return true;
            }
            //~ Occupent is not friendly!
            else 
            {
                return false;
            }
        }
        
        //~ No occupants found
        if (!occupantFound)
            return trueIfEmpty;
        
        //~ Multiple occupants found check if all must be friendly
        if (allFriendly)
            return friendlyFound;
        
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    bool AnyCompartmentsOccupiedOrLocked()
    {       
        //~ If vehicle check if it is occupied
        array<IEntity> occupants = {};
        GetOccupants(occupants);
            
        //~ Entity is occupied by characters
        if (!occupants.IsEmpty())
            return true;
            
        array<BaseCompartmentSlot> compartments = {};
        GetCompartments(compartments);
        
        foreach (BaseCompartmentSlot compartment : compartments)
        {
            if (!compartment)
                continue;
            
            //~ Vehicle currently has a locked compartment so is in use
            if (compartment.IsGetInLocked())
                return true;
        }
        
        return false;
    }
    
    //--------------------------------------------------- Has default occupent data set of type ---------------------------------------------------\\
 
    //------------------------------------------------------------------------------------------------
    bool HasDefaultOccupantsDataForTypes(array<ECompartmentType> compartmentTypes)
    {
        array<BaseCompartmentSlot> compartments = new array<BaseCompartmentSlot>;
        SCR_DefaultOccupantData defaultOccupantData;
        
        foreach (ECompartmentType compartmentType: compartmentTypes)
        {
            compartments.Clear();
            GetCompartmentsOfType(compartments, compartmentType);
            
            foreach (BaseCompartmentSlot compartment: compartments)
            {
                defaultOccupantData = compartment.GetDefaultOccupantData();
                
                if (defaultOccupantData && defaultOccupantData.IsValid())
                    return true;
            }
        }
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    // destructor
    void ~SCR_BaseCompartmentManagerComponent()
    {
        //~ Component destroyed before it could finish spawning all characters
        if (m_bIsSpawningDefaultOccupants)
            FinishedSpawningDefaultOccupants(true);
    }
}