Ares
Public Member Functions | Public Attributes

SideExt::ExtData Class Reference

#include <src/Ext/Side/Body.h>

Inheritance diagram for SideExt::ExtData:
Extension< TT >

List of all members.

Public Member Functions

 ExtData (const DWORD Canary, TT *const OwnerObject)
virtual ~ExtData ()
virtual size_t Size () const
virtual void LoadFromINIFile (TT *pThis, CCINIClass *pINI)
virtual void Initialize (TT *pThis)
virtual void InvalidatePointer (void *ptr)

Public Attributes

Customizable< InfantryTypeClass * > DefaultDisguise
Customizable< InfantryTypeClass * > Crew
Customizable< int > SurvivorDivisor
TypeList< BuildingTypeClass * > BaseDefenses
TypeList< int > BaseDefenseCounts
TypeList< InfantryTypeClass * > * ParaDropFallbackTypes
TypeList< int > * ParaDropFallbackNum
TypeList< TechnoTypeClass * > ParaDrop
TypeList< int > ParaDropNum
ValueableIdx< int,
AircraftTypeClass > 
ParaDropPlane
Customizable< AnimTypeClass * > Parachute_Anim
int SidebarMixFileIndex
bool SidebarYuriFileNames
char EVATag [0x20]

Constructor & Destructor Documentation

SideExt::ExtData::ExtData ( const DWORD  Canary,
TT *const  OwnerObject 
) [inline]
                                                                   : Extension<TT>(Canary, OwnerObject),
                        ParaDropPlane (-1),
                        Parachute_Anim (&RulesClass::Instance->Parachute)
                {
                        *EVATag = 0;
                };
virtual SideExt::ExtData::~ExtData ( ) [inline, virtual]
                                   {

                }

Member Function Documentation

void SideExt::ExtData::Initialize ( TT pThis) [virtual]
{
        char* pID = pThis->ID;

        //are these necessary?
        this->BaseDefenseCounts.Clear();
        this->BaseDefenses.Clear();
        this->ParaDrop.Clear();
        this->ParaDropNum.Clear();

        this->ParaDropPlane = AircraftTypeClass::FindIndex("PDPLANE");

        if(!_strcmpi(pID, "Nod")) { //Soviets

                for(int i = 0; i < RulesClass::Instance->SovietBaseDefenseCounts.Count; ++i) {
                        this->BaseDefenseCounts.AddItem(RulesClass::Instance->SovietBaseDefenseCounts.GetItem(i));
                }

                for(int i = 0; i < RulesClass::Instance->SovietBaseDefenses.Count; ++i) {
                        this->BaseDefenses.AddItem(RulesClass::Instance->SovietBaseDefenses.GetItem(i));
                }

                this->Crew.Bind(&RulesClass::Instance->SovietCrew);
                this->DefaultDisguise.Bind(&RulesClass::Instance->SovietDisguise);
                this->SurvivorDivisor.Bind(&RulesClass::Instance->SovietSurvivorDivisor);

                strcpy(this->EVATag, "Russian");

                this->ParaDropFallbackTypes = &RulesClass::Instance->SovParaDropInf;
                this->ParaDropFallbackNum = &RulesClass::Instance->SovParaDropNum;

                this->SidebarMixFileIndex = 2;
                this->SidebarYuriFileNames = false;

        } else if(!_strcmpi(pID, "ThirdSide")) { //Yuri

                for(int i = 0; i < RulesClass::Instance->ThirdBaseDefenseCounts.Count; ++i) {
                        this->BaseDefenseCounts.AddItem(RulesClass::Instance->ThirdBaseDefenseCounts.GetItem(i));
                }

                for(int i = 0; i < RulesClass::Instance->ThirdBaseDefenses.Count; ++i) {
                        this->BaseDefenses.AddItem(RulesClass::Instance->ThirdBaseDefenses.GetItem(i));
                }

                this->Crew.Bind(&RulesClass::Instance->ThirdCrew);
                this->DefaultDisguise.Bind(&RulesClass::Instance->ThirdDisguise);
                this->SurvivorDivisor.Bind(&RulesClass::Instance->ThirdSurvivorDivisor);

                strcpy(this->EVATag, "Yuri");

                this->ParaDropFallbackTypes = &RulesClass::Instance->YuriParaDropInf;
                this->ParaDropFallbackNum = &RulesClass::Instance->YuriParaDropNum;

                this->SidebarMixFileIndex = 2;
                this->SidebarYuriFileNames = true;

        } else { //Allies or any other country

                for(int i = 0; i < RulesClass::Instance->AlliedBaseDefenseCounts.Count; ++i) {
                        this->BaseDefenseCounts.AddItem(RulesClass::Instance->AlliedBaseDefenseCounts.GetItem(i));
                }

                for(int i = 0; i < RulesClass::Instance->AlliedBaseDefenses.Count; ++i) {
                        this->BaseDefenses.AddItem(RulesClass::Instance->AlliedBaseDefenses.GetItem(i));
                }

                this->Crew.Bind(&RulesClass::Instance->AlliedCrew);
                this->DefaultDisguise.Bind(&RulesClass::Instance->AlliedDisguise);
                this->SurvivorDivisor.Bind(&RulesClass::Instance->AlliedSurvivorDivisor);

                strcpy(this->EVATag, "Allied");

                this->ParaDropFallbackTypes = &RulesClass::Instance->AllyParaDropInf;
                this->ParaDropFallbackNum = &RulesClass::Instance->AllyParaDropNum;

                this->SidebarMixFileIndex = 1;
                this->SidebarYuriFileNames = false;
        }

};
virtual void SideExt::ExtData::InvalidatePointer ( void *  ptr) [inline, virtual]

Implements Extension< TT >.

                                                          {
                }
void SideExt::ExtData::LoadFromINIFile ( TT pThis,
CCINIClass *  pINI 
) [virtual]
{
        char* p = NULL;
        char* section = pThis->get_ID();

        if(pINI->ReadString(section, "AI.BaseDefenseCounts", "", Ares::readBuffer, Ares::readLength)) {
                this->BaseDefenseCounts.Clear();

                for(p = strtok(Ares::readBuffer, Ares::readDelims); p && *p; p = strtok(NULL, Ares::readDelims)) {
                        this->BaseDefenseCounts.AddItem(atoi(p));
                }
        }

        if(pINI->ReadString(section, "AI.BaseDefenses", "", Ares::readBuffer, Ares::readLength)) {
                this->BaseDefenses.Clear();

                for(p = strtok(Ares::readBuffer, Ares::readDelims); p && *p; p = strtok(NULL, Ares::readDelims)) {
                        this->BaseDefenses.AddItem(BuildingTypeClass::FindOrAllocate(p));
                }
        }

        INI_EX exINI(pINI);

        this->Crew.Parse(&exINI, section, "Crew", 1);

        this->DefaultDisguise.Parse(&exINI, section, "DefaultDisguise", 1);

        if(pINI->ReadString(section, "EVA.Tag", "", Ares::readBuffer, 0x20)) {
                AresCRT::strCopy(this->EVATag, Ares::readBuffer, 0x20);
        }

        this->Parachute_Anim.Parse(&exINI, section, "Parachute.Anim");

        this->ParaDropPlane.Read(&exINI, section, "ParaDrop.Aircraft");

        if(pINI->ReadString(section, "ParaDrop.Types", "", Ares::readBuffer, Ares::readLength)) {
                this->ParaDrop.Clear();
                this->ParaDropFallbackTypes = NULL;

                for(p = strtok(Ares::readBuffer, Ares::readDelims); p && *p; p = strtok(NULL, Ares::readDelims)) {
                        TechnoTypeClass* pTT = UnitTypeClass::Find(p);

                        if(!pTT) {
                                pTT = InfantryTypeClass::Find(p);
                        }

                        if(pTT) {
                                this->ParaDrop.AddItem(pTT);
                        } else {
                                Debug::INIParseFailed(section, "ParaDrop.Types", p);
                        }
                }
        }

        if(pINI->ReadString(section, "ParaDrop.Num", "", Ares::readBuffer, Ares::readLength)) {
                this->ParaDropNum.Clear();
                this->ParaDropFallbackNum = NULL;

                for(p = strtok(Ares::readBuffer, Ares::readDelims); p && *p; p = strtok(NULL, Ares::readDelims)) {
                        this->ParaDropNum.AddItem(atoi(p));
                }
        }

        this->SidebarMixFileIndex =  pINI->ReadInteger(section, "Sidebar.MixFileIndex", this->SidebarMixFileIndex);
        this->SidebarYuriFileNames = pINI->ReadBool(section, "Sidebar.YuriFileNames", this->SidebarYuriFileNames);
        this->SurvivorDivisor.Read(&exINI, section, "SurvivorDivisor");
}
virtual size_t SideExt::ExtData::Size ( ) const [inline, virtual]

Implements Extension< TT >.

{ return sizeof(*this); };

Member Data Documentation

TypeList<BuildingTypeClass*> SideExt::ExtData::BaseDefenses
Customizable<InfantryTypeClass*> SideExt::ExtData::Crew
TypeList<TechnoTypeClass*> SideExt::ExtData::ParaDrop
TypeList<InfantryTypeClass*>* SideExt::ExtData::ParaDropFallbackTypes

The documentation for this class was generated from the following files:
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Defines