Ares
Public Member Functions | Public Attributes

HouseExt::ExtData Class Reference

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

Inheritance diagram for HouseExt::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 InvalidatePointer (void *ptr)
void SetFirestormState (bool Active)
bool CheckBasePlanSanity ()

Public Attributes

bool IonSensitive
bool FirewallActive
int FirewallRecalc
int SWLastIndex
BuildingClass * Factory_BuildingType
BuildingClass * Factory_InfantryType
BuildingClass * Factory_VehicleType
BuildingClass * Factory_NavyType
BuildingClass * Factory_AircraftType
std::bitset< 32 > StolenTech

Constructor & Destructor Documentation

HouseExt::ExtData::ExtData ( const DWORD  Canary,
TT *const  OwnerObject 
) [inline]
virtual HouseExt::ExtData::~ExtData ( ) [inline, virtual]
                                   {

                }

Member Function Documentation

bool HouseExt::ExtData::CheckBasePlanSanity ( )

moved the fix for #917 here - check a house's ability to handle base plan before it actually tries to generate a base plan, not at game start (we have no idea what houses at game start are supposed to be able to do base planning, so mission maps fuck up)

                                          {
        auto House = this->AttachedToObject;
        // this shouldn't happen, but you never know
        if(House->ControlledByHuman() || House->IsNeutral()) {
                return true;
        }

        const char *errorMsg = "AI House of country [%s] cannot build any object in %s. The AI ain't smart enough for that.\n";
        bool AllIsWell(true);

        // if you don't have a base unit buildable, how did you get to base planning?
        // only through crates or map actions, so have to validate base unit in other situations
        auto pArray = &RulesClass::Instance->BaseUnit;
        bool canBuild = false;
        for(int i = 0; i < pArray->Count; ++i) {
                auto Item = pArray->GetItem(i);
                if(House->CanExpectToBuild(Item)) {
                        canBuild = true;
                        break;
                }
        }
        if(!canBuild) {
                AllIsWell = false;
                Debug::DevLog(Debug::Error, errorMsg, House->Type->ID, "BaseUnit");
        }

        auto CheckList = [House, errorMsg, &AllIsWell]
                        (DynamicVectorClass<BuildingTypeClass *> *const List, char * const ListName) -> void {
                if(!House->FirstBuildableFromArray(List)) {
                        AllIsWell = false;
                        Debug::DevLog(Debug::Error, errorMsg, House->Type->ID, ListName);
                }
        };

        // commented out lists that do not cause a crash, according to testers
//      CheckList(&RulesClass::Instance->Shipyard, "Shipyard");
        CheckList(&RulesClass::Instance->BuildPower, "BuildPower");
        CheckList(&RulesClass::Instance->BuildRefinery, "BuildRefinery");
        CheckList(&RulesClass::Instance->BuildWeapons, "BuildWeapons");

//                      CheckList(&RulesClass::Instance->BuildConst, "BuildConst");
//                      CheckList(&RulesClass::Instance->BuildBarracks, "BuildBarracks");
//                      CheckList(&RulesClass::Instance->BuildTech, "BuildTech");
//                      CheckList(&RulesClass::Instance->BuildRadar, "BuildRadar");
//                      CheckList(&RulesClass::Instance->ConcreteWalls, "ConcreteWalls");
//                      CheckList(&RulesClass::Instance->BuildDummy, "BuildDummy");
//                      CheckList(&RulesClass::Instance->BuildNavalYard, "BuildNavalYard");

        auto pCountryData = HouseTypeExt::ExtMap.Find(House->Type);
        CheckList(&pCountryData->Powerplants, "Powerplants");

//                      auto pSide = SideClass::Array->GetItem(curHouse->Type->SideIndex);
//                      auto pSideData = SideExt::ExtMap.Find(pSide);
//                      CheckList(&pSideData->BaseDefenses, "Base Defenses");

        return AllIsWell;
}
virtual void HouseExt::ExtData::InvalidatePointer ( void *  ptr) [inline, virtual]

Implements Extension< TT >.

                                                          {
                        AnnounceInvalidPointer(Factory_AircraftType, ptr);
                        AnnounceInvalidPointer(Factory_BuildingType, ptr);
                        AnnounceInvalidPointer(Factory_VehicleType, ptr);
                        AnnounceInvalidPointer(Factory_NavyType, ptr);
                        AnnounceInvalidPointer(Factory_InfantryType, ptr);
                }
void HouseExt::ExtData::SetFirestormState ( bool  Active)
                                                   {
        HouseClass *pHouse = this->AttachedToObject;
        HouseExt::ExtData* pData = HouseExt::ExtMap.Find(pHouse);

        if(pData->FirewallActive == Active) {
                return;
        }

        pData->FirewallActive = Active;

        DynamicVectorClass<CellStruct> AffectedCoords;

        for(int i = 0; i < pHouse->Buildings.Count; ++i) {
                BuildingClass *B = pHouse->Buildings[i];
                BuildingTypeExt::ExtData *pBuildTypeData = BuildingTypeExt::ExtMap.Find(B->Type);
                if(pBuildTypeData->Firewall_Is) {
                        BuildingExt::ExtData * pData = BuildingExt::ExtMap.Find(B);
                        pData->UpdateFirewall();
                        CellStruct temp;
                        B->GetMapCoords(&temp);
                        AffectedCoords.AddItem(temp);
                }
        }

        MapClass::Instance->Update_Pathfinding_1();
        MapClass::Instance->Update_Pathfinding_2(&AffectedCoords);
};
virtual size_t HouseExt::ExtData::Size ( ) const [inline, virtual]

Implements Extension< TT >.

{ return sizeof(*this); };

Member Data Documentation


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