Ares
Classes | Public Types | Static Public Member Functions | Static Public Attributes

HouseExt Class Reference

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

List of all members.

Classes

class  ExtData

Public Types

enum  RequirementStatus { Forbidden = 1, Incomplete = 2, Complete = 3, Overridden = 4 }
enum  BuildLimitStatus { ReachedPermanently = -1, ReachedTemporarily = 0, NotReached = 1 }
typedef HouseClass TT

Static Public Member Functions

static signed int BuildLimitRemaining (HouseClass *pHouse, TechnoTypeClass *pItem)
static BuildLimitStatus CheckBuildLimit (HouseClass *pHouse, TechnoTypeClass *pItem, bool IncludeQueued)
static RequirementStatus RequirementsMet (HouseClass *pHouse, TechnoTypeClass *pItem)
static bool PrerequisitesMet (HouseClass *pHouse, TechnoTypeClass *pItem)
static bool PrerequisitesListed (Prereqs::BTypeList *List, TechnoTypeClass *pItem)
static bool HasNeededFactory (HouseClass *pHouse, TechnoTypeClass *pItem)
static signed int PrereqValidate (HouseClass *pHouse, TechnoTypeClass *pItem, bool BuildLimitOnly, bool IncludeQueued)

Static Public Attributes

static Container< HouseExtExtMap

Member Typedef Documentation

typedef HouseClass HouseExt::TT

Member Enumeration Documentation

Enumerator:
ReachedPermanently 
ReachedTemporarily 
NotReached 
                              {
                ReachedPermanently = -1, // remove cameo
                ReachedTemporarily = 0, // black out cameo
                NotReached = 1, // don't do anything
        };
Enumerator:
Forbidden 
Incomplete 
Complete 
Overridden 
                               {
                Forbidden = 1, // forbidden by special conditions (e.g. reqhouses) that's not likely to change in this session
                Incomplete = 2, // missing something (approp factory)
                Complete = 3, // OK
                Overridden = 4, // magic condition met, bypass prereq check
        };

Member Function Documentation

signed int HouseExt::BuildLimitRemaining ( HouseClass *  pHouse,
TechnoTypeClass *  pItem 
) [static]
{
        int BuildLimit = pItem->BuildLimit;
        if(BuildLimit >= 0) {
                BuildLimit -= pHouse->CountOwnedNow(pItem);
        } else {
                BuildLimit = abs(BuildLimit);
                BuildLimit -= pHouse->CountOwnedEver(pItem);
        }
        return std::min(BuildLimit, 0x7FFFFFFF);
}
HouseExt::BuildLimitStatus HouseExt::CheckBuildLimit ( HouseClass *  pHouse,
TechnoTypeClass *  pItem,
bool  IncludeQueued 
) [static]
{
        int BuildLimit = pItem->BuildLimit;
        int Remaining = HouseExt::BuildLimitRemaining(pHouse, pItem);
        if(BuildLimit > 0) {
                if(Remaining <= 0 && IncludeQueued) {
                        return FactoryClass::FindThisOwnerAndProduct(pHouse, pItem)
                                ? NotReached
                                : ReachedPermanently
                        ;
                }
        }
        return (Remaining > 0)
                ? NotReached
                : ReachedTemporarily
        ;
}
bool HouseExt::HasNeededFactory ( HouseClass *  pHouse,
TechnoTypeClass *  pItem 
) [static]
                                                                          {
        DWORD ItemOwners = pItem->GetOwners();
        eAbstractType WhatAmI = pItem->WhatAmI();

        for(int i = 0; i < pHouse->Buildings.Count; ++i) {
                auto pBld = pHouse->Buildings[i];
                if(!pBld->InLimbo && pBld->HasPower) {
                        if(pBld->Type->Factory == WhatAmI) {
                                if(pBld->GetCurrentMission() != mission_Selling && pBld->QueuedMission != mission_Selling) {
                                        if((pBld->Type->GetOwners() & ItemOwners) != 0) {
                                                return true;
                                        }
                                }
                        }
                }
        }

        return false;
}
bool HouseExt::PrerequisitesListed ( Prereqs::BTypeList List,
TechnoTypeClass *  pItem 
) [static]
{
        if(!pItem) {
                return 0;
        }
        TechnoTypeExt::ExtData* pData = TechnoTypeExt::ExtMap.Find(pItem);

        for(int i = 0; i < pData->PrerequisiteLists.Count; ++i) {
                if(Prereqs::ListContainsAll(List, pData->PrerequisiteLists[i])) {
                        return 1;
                }
        }

        return 0;
}
bool HouseExt::PrerequisitesMet ( HouseClass *  pHouse,
TechnoTypeClass *  pItem 
) [static]
{
        if(!pItem) {
                return 0;
        }
        TechnoTypeExt::ExtData* pData = TechnoTypeExt::ExtMap.Find(pItem);

        for(int i = 0; i < pData->PrerequisiteLists.Count; ++i) {
                if(Prereqs::HouseOwnsAll(pHouse, pData->PrerequisiteLists[i])) {
                        return 1;
                }
        }

        return 0;
}
signed int HouseExt::PrereqValidate ( HouseClass *  pHouse,
TechnoTypeClass *  pItem,
bool  BuildLimitOnly,
bool  IncludeQueued 
) [static]
{
        if(!BuildLimitOnly) {
                RequirementStatus ReqsMet = HouseExt::RequirementsMet(pHouse, pItem);
                if(ReqsMet == Forbidden || ReqsMet == Incomplete) {
                        return 0;
                }

                if(!pHouse->IsHumanoid()) {
                        if(Ares::GlobalControls::AllowBypassBuildLimit[pHouse->AIDifficulty]) {
                                return 1;
                        } else {
                                return (signed int)HouseExt::CheckBuildLimit(pHouse, pItem, IncludeQueued);
                        }
                }

                if(ReqsMet == Complete) {
                        if(!HouseExt::PrerequisitesMet(pHouse, pItem)) {
                                return 0;
                        }
                }
        }

        if(!HouseExt::HasNeededFactory(pHouse, pItem)) {
                Debug::DevLog(Debug::Error, "[NCO Bug detected] "
                        "House %ls meets all requirements to build %s, but doesn't have a suitable factory!\n",
                        pHouse->UIName, pItem->ID);
                return 0;
        }

        return (signed int)HouseExt::CheckBuildLimit(pHouse, pItem, IncludeQueued);
}
HouseExt::RequirementStatus HouseExt::RequirementsMet ( HouseClass *  pHouse,
TechnoTypeClass *  pItem 
) [static]
{
        if(pItem->Unbuildable) {
                return Forbidden;
        }

        TechnoTypeExt::ExtData* pData = TechnoTypeExt::ExtMap.Find(pItem);
        if(!pItem) {
                return Forbidden;
        }
//      TechnoTypeClassExt::TechnoTypeClassData *pData = TechnoTypeClassExt::Ext_p[pItem];
        HouseExt::ExtData* pHouseExt = HouseExt::ExtMap.Find(pHouse);

        // this has to happen before the first possible "can build" response or NCO happens
        if(pItem->WhatAmI() != abs_BuildingType && !pHouse->HasFactoryForObject(pItem)) { return Incomplete; }

        if(!(pData->PrerequisiteTheaters & (1 << ScenarioClass::Instance->Theater))) { return Forbidden; }
        if(Prereqs::HouseOwnsAny(pHouse, &pData->PrerequisiteNegatives)) { return Forbidden; }

        int idx = HouseClass::Array->FindItemIndex(&pHouse);

        if(pData->ReversedByHouses.ValidIndex(idx) && pData->ReversedByHouses[idx]) {
                return Overridden;
        }

        if(pData->RequiredStolenTech.any()) {
                if((pHouseExt->StolenTech & pData->RequiredStolenTech) != pData->RequiredStolenTech) { return Incomplete; }
        }

        // yes, the game checks it here
        // hack value - skip real prereq check
        if(Prereqs::HouseOwnsAny(pHouse, &pItem->PrerequisiteOverride)) { return Overridden; }

        if(pHouse->HasFromSecretLab(pItem)) { return Overridden; }

        if(pHouse->IsHumanoid() && pItem->TechLevel == -1) { return Incomplete; }

        if(!pHouse->HasAllStolenTech(pItem)) { return Incomplete; }

        if(!pHouse->InRequiredHouses(pItem) || pHouse->InForbiddenHouses(pItem)) { return Forbidden; }

        if(!Unsorted::SWAllowed) {
                if(BuildingTypeClass *pBld = specific_cast<BuildingTypeClass*>(pItem)) {
                        if(pBld->SuperWeapon != -1) {
                                if(RulesClass::Instance->BuildTech.FindItemIndex(&pBld) == -1) {
                                        if(pHouse->Supers.GetItem(pBld->SuperWeapon)->Type->DisableableFromShell) {
                                                return Forbidden;
                                        }
                                }
                        }
                }
        }

        return (pHouse->TechLevel >= pItem->TechLevel) ? Complete : Incomplete;
}

Member Data Documentation


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