SCR_FactionCallsignData.c

Go to the documentation of this file.

class SCR_FactionCallsignData
{
    protected ref map<int, ref SCR_CallsignCompanyData> m_mCompanyCallsigns = new map<int, ref SCR_CallsignCompanyData>();
    protected ref map<int, ref SCR_CallsignCompanyData> m_mCompanyOverflowCallsigns = new map<int, ref SCR_CallsignCompanyData>();
 
    protected int m_iOverflowIndex;
    protected bool m_bRandomizedCallsigns;
 
    //------------------------------------------------------------------------------------------------
    // constructor
    void SCR_FactionCallsignData(SCR_FactionCallsignInfo factionCallsignInfo)
    {
        m_iOverflowIndex = factionCallsignInfo.GetCompanyOverflowIndex();
        m_bRandomizedCallsigns = factionCallsignInfo.GetIsAssignedRandomly();
 
        array<ref SCR_CallsignInfo> companyArray = {};
        factionCallsignInfo.GetCompanyArray(companyArray);
        int count = companyArray.Count();
 
        for(int i = 0; i < count; i++)
        {
            SCR_CallsignCompanyData companyData = SCR_CallsignCompanyData();
            companyData.Init(factionCallsignInfo);
 
            //Check if overflow company and add it to correct map
            if (i < m_iOverflowIndex)
                m_mCompanyCallsigns.Insert(i, companyData);
            //Overflow means it only grabs these if non of the default companies are available
            else
                m_mCompanyOverflowCallsigns.Insert(i, companyData);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetRandomCallsign(out int company, out int platoon, out int squad)
    {
        SCR_CallsignCompanyData randomCompany;
        int random;
 
        //Default companies still available
        if (!m_mCompanyCallsigns.IsEmpty())
        {
            random = Math.RandomInt(0, m_mCompanyCallsigns.Count());
            company = m_mCompanyCallsigns.GetKey(random);
            randomCompany = m_mCompanyCallsigns.GetElement(random);
        }
 
        //Use overflow companies
        else if (!m_mCompanyOverflowCallsigns.IsEmpty())
        {
            random = Math.RandomInt(0, m_mCompanyOverflowCallsigns.Count());
            company = m_mCompanyOverflowCallsigns.GetKey(random);
            randomCompany = m_mCompanyOverflowCallsigns.GetElement(random);
        }
        //No companies available
        else
        {
            return false;
        }
 
        randomCompany.GetRandomCallsign(platoon, squad);
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    // TODO: availible -> available
    bool GetFirstAvailibleCallsign(out int firstAvailableCompany, out int firstAvailablePlatoon, out int firstAvailableSquad)
    {
        firstAvailableCompany = int.MAX;
        SCR_CallsignCompanyData firstAvailableCompanyData;
 
        //Default companies still available
        if (!m_mCompanyCallsigns.IsEmpty())
        {
            foreach (int index, SCR_CallsignCompanyData company: m_mCompanyCallsigns)
            {
                if (index < firstAvailableCompany)
                {
                    firstAvailableCompany = index;
                    firstAvailableCompanyData = company;
                }
            }
        }
        //Use overflow companies
        else if (!m_mCompanyOverflowCallsigns.IsEmpty())
        {
            foreach (int index, SCR_CallsignCompanyData company: m_mCompanyOverflowCallsigns)
            {
                if (index < firstAvailableCompany)
                {
                    firstAvailableCompany = index;
                    firstAvailableCompanyData = company;
                }
            }
        }
        //No companies available
        else
        {
            return false;
        }
 
        firstAvailableCompanyData.GetFirstAvailibleCallsign(firstAvailablePlatoon, firstAvailableSquad);
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetSpecificCompanyCallsign(out int company, out int platoon, out int squad)
    {
         SCR_CallsignCompanyData companyData;
 
        //Get specific company
        if (!m_mCompanyCallsigns.Find(company, companyData))
            m_mCompanyOverflowCallsigns.Find(company, companyData);
 
        //Specific company found
        if (companyData)
        {
            if (!m_bRandomizedCallsigns)
                companyData.GetFirstAvailibleCallsign(platoon, squad);
            else
                companyData.GetRandomCallsign(platoon, squad);
        }
        //Company not available, use default logics
        else
        {
            if (!m_bRandomizedCallsigns)
                return GetFirstAvailibleCallsign(company, platoon, squad);
            else
                return GetRandomCallsign(company, platoon, squad);
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetGroupRoleSpecificCompanyCallsign(notnull SCR_AIGroup group, out int company, out int platoon, out int squad)
    {
        SCR_Faction groupFaction = SCR_Faction.Cast(group.GetFaction());
        if (!groupFaction)
            return false;
 
        SCR_FactionCallsignInfo factionCallsignInfo = groupFaction.GetCallsignInfo();
        if (!factionCallsignInfo)
            return false;
 
        array<int> companyIndexes = {};
        SCR_EGroupRole groupRole = group.GetGroupRole();
        if (!factionCallsignInfo.GetGroupRoleSpecificCompanies(groupRole, companyIndexes))
            return false;
 
        company = int.MAX;
        SCR_CallsignCompanyData companyData;
        foreach (int companyIndex : companyIndexes)
        {
            if (!m_mCompanyCallsigns.Find(companyIndex, companyData))
                continue;
 
            if (!companyData || !companyData.GetFirstAvailableSquadCallsign(platoon, squad))
                continue;
 
            company = companyIndex;
            break;
        }
 
        if (company != int.MAX)
            return true;
 
        // No available companies for group, use one of the overflow companies instead
        if (!m_mCompanyOverflowCallsigns.IsEmpty())
            return false;
 
        int overflowCompaniesCount = m_mCompanyOverflowCallsigns.Count();
        int companyIndex;
        for (int i = 0; i < overflowCompaniesCount; i++)
        {
            companyIndex = m_mCompanyOverflowCallsigns.GetKey(i);
            if (!m_mCompanyCallsigns.Find(companyIndex, companyData))
                continue;
 
            if (!companyData || !companyData.GetFirstAvailableSquadCallsign(platoon, squad))
                continue;
 
            company = companyIndex;
            break;
        }
 
        // Return false if no available company found in group role specific companies nor overflow companies
        return company != int.MAX;
    }
 
    //------------------------------------------------------------------------------------------------
    void AddCallsign(int companyIndex, int platoonIndex, int squadIndex)
    {
        SCR_CallsignCompanyData companyData;
 
        if (companyIndex < m_iOverflowIndex)
        {
            if (m_mCompanyCallsigns.Find(companyIndex, companyData))
            {
                companyData.AddCallsign(platoonIndex, squadIndex);
            }
            else
            {
                companyData = new SCR_CallsignCompanyData();
                companyData.AddCallsign(platoonIndex, squadIndex);
                m_mCompanyCallsigns.Insert(companyIndex, companyData);
            }
        }
        else
        {
            if (m_mCompanyOverflowCallsigns.Find(companyIndex, companyData))
            {
                companyData.AddCallsign(platoonIndex, squadIndex);
            }
            else
            {
                companyData = new SCR_CallsignCompanyData();
                companyData.AddCallsign(platoonIndex, squadIndex);
                m_mCompanyOverflowCallsigns.Insert(companyIndex, companyData);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void RemoveCallsign(int companyIndex, int platoonIndex, int squadIndex)
    {
        SCR_CallsignCompanyData companyData;
 
        if (companyIndex < m_iOverflowIndex)
        {
            if (m_mCompanyCallsigns.Find(companyIndex, companyData))
            {
                //Check if all platoons are used then remove company
                if (companyData.RemoveCallsign(platoonIndex, squadIndex))
                {
                    m_mCompanyCallsigns.Remove(companyIndex);
                }
            }
        }
        else
        {
            if (m_mCompanyOverflowCallsigns.Find(companyIndex, companyData))
            {
                //Check if all platoons are used then remove company
                if (companyData.RemoveCallsign(platoonIndex, squadIndex))
                {
                    m_mCompanyOverflowCallsigns.Remove(companyIndex);
                }
            }
        }
    }
}