Validator.h

Go to the documentation of this file.

// Validator.h generated from model.xml using generate-code.xsl

#ifndef VALIDATOR_H
#define VALIDATOR_H

#include "UnderlyingTypes.h"
#include "Game.h"
#include "Abil.h"
#include "Behavior.h"

typedef enum
{
    e_classIdCValidator,

    e_classIdCValidatorCombine,

    e_classIdCValidatorCondition,

    e_classIdCValidatorFunction,

    e_classIdCValidatorGameCompareTimeOfDay,

    e_classIdCValidatorGameCompareTerrain,

    e_classIdCValidatorLocation,

    e_classIdCValidatorLocationCompareCliffLevel,

    e_classIdCValidatorLocationComparePower,

    e_classIdCValidatorLocationCompareRange,

    e_classIdCValidatorLocationArc,

    e_classIdCValidatorLocationCreep,

    e_classIdCValidatorLocationCrossChasm,

    e_classIdCValidatorLocationCrossCliff,

    e_classIdCValidatorLocationEnumArea,

    e_classIdCValidatorLocationPathable,

    e_classIdCValidatorLocationPlacement,

    e_classIdCValidatorLocationType,

    e_classIdCValidatorLocationVision,

    e_classIdCValidatorPlayer,

    e_classIdCValidatorPlayerAlliance,

    e_classIdCValidatorPlayerRequirement,

    e_classIdCValidatorPlayerCompare,

    e_classIdCValidatorPlayerCompareDifficulty,

    e_classIdCValidatorPlayerCompareFoodAvailable,

    e_classIdCValidatorPlayerCompareFoodMade,

    e_classIdCValidatorPlayerCompareFoodUsed,

    e_classIdCValidatorPlayerCompareRace,

    e_classIdCValidatorPlayerCompareResource,

    e_classIdCValidatorPlayerCompareResult,

    e_classIdCValidatorPlayerCompareType,

    e_classIdCValidatorUnit,

    e_classIdCValidatorUnitAI,

    e_classIdCValidatorUnitCombatAI,

    e_classIdCValidatorUnitAbil,

    e_classIdCValidatorUnitBehaviorState,

    e_classIdCValidatorUnitDetected,

    e_classIdCValidatorUnitFilters,

    e_classIdCValidatorUnitFlying,

    e_classIdCValidatorUnitInventory,

    e_classIdCValidatorUnitInventoryIsFull,

    e_classIdCValidatorUnitInventoryContainsItem,

    e_classIdCValidatorUnitLastDamagePlayer,

    e_classIdCValidatorUnitMissileNullified,

    e_classIdCValidatorUnitMover,

    e_classIdCValidatorUnitOrder,

    e_classIdCValidatorUnitOrderQueue,

    e_classIdCValidatorUnitOrderTargetPathable,

    e_classIdCValidatorUnitOrderTargetType,

    e_classIdCValidatorUnitPathable,

    e_classIdCValidatorUnitPathing,

    e_classIdCValidatorUnitScanning,

    e_classIdCValidatorUnitType,

    e_classIdCValidatorUnitWeaponAnimating,

    e_classIdCValidatorUnitWeaponFiring,

    e_classIdCValidatorUnitWeaponPlane,

    e_classIdCValidatorUnitCompare,

    e_classIdCValidatorUnitCompareAIAreaEvalRatio,

    e_classIdCValidatorUnitCompareAbilLevel,

    e_classIdCValidatorUnitCompareAttackPriority,

    e_classIdCValidatorUnitCompareBehaviorCount,

    e_classIdCValidatorUnitCompareCargo,

    e_classIdCValidatorUnitCompareChargeUsed,

    e_classIdCValidatorUnitCompareCooldown,

    e_classIdCValidatorUnitCompareDamageTakenTime,

    e_classIdCValidatorUnitCompareDeath,

    e_classIdCValidatorUnitCompareDetectRange,

    e_classIdCValidatorUnitCompareField,

    e_classIdCValidatorUnitCompareMarkerCount,

    e_classIdCValidatorUnitCompareMoverPhase,

    e_classIdCValidatorUnitCompareOrderCount,

    e_classIdCValidatorUnitCompareOrderTargetRange,

    e_classIdCValidatorUnitComparePowerSourceLevel,

    e_classIdCValidatorUnitComparePowerUserLevel,

    e_classIdCValidatorUnitCompareRallyPointCount,

    e_classIdCValidatorUnitCompareResourceContents,

    e_classIdCValidatorUnitCompareResourceHarvesters,

    e_classIdCValidatorUnitCompareSpeed,

    e_classIdCValidatorUnitCompareVeterancyLevel,

    e_classIdCValidatorUnitCompareVital,

    e_classIdCValidatorUnitCompareVitality,

} EClassIdCValidator;

const int32 e_classIdCValidatorCount = 81;

typedef enum
{
    e_pathingTypeNone,

    e_pathingTypeGround,

    e_pathingTypeBuilding,

    e_pathingTypeCliff,

} EPathingType;

const int32 e_pathingTypeCount = 4;

typedef enum
{
    e_cargoSpaceFree,

    e_cargoSpaceLoad,

    e_cargoSpaceSize,

    e_cargoSpaceUsed,

} ECargoSpace;

const int32 e_cargoSpaceCount = 4;

typedef enum
{
    e_unitAIFlagCampaign,

    e_unitAIFlagForceUnburrow,

    e_unitAIFlagScriptControlled,

    e_unitAIFlagSuggestBurrow,

    e_unitAIFlagSuggestUnburrow,

    e_unitAIFlagSuicide,

    e_unitAIFlagWantsToMove,

    e_unitAIFlagForcedToMove,

} EUnitAIFlag;

const int32 e_unitAIFlagCount = 8;

typedef enum
{
    e_attackPriorityIsThreat,

    e_attackPriorityInRange,

    e_attackPriorityInRangeCurrentTarget,

} EAttackPriority;

const int32 e_attackPriorityCount = 3;

typedef enum
{
    e_detectTypeNormal,

    e_detectTypeRadar,

} EDetectType;

const int32 e_detectTypeCount = 2;

typedef enum
{
    e_unitTypeLink,

    e_unitTypeLeaderAlias,

    e_unitTypeSelectAlias,

    e_unitTypeAIBully,

} EUnitType;

const int32 e_unitTypeCount = 4;

typedef enum
{
    e_vitalTypeCurrent,

    e_vitalTypeDelta,

    e_vitalTypeFraction,

    e_vitalTypeMaximum,

} EVitalType;

const int32 e_vitalTypeCount = 4;

typedef enum
{
    e_validateCombineAnd,

    e_validateCombineOr,

} EValidateCombine;

const int32 e_validateCombineCount = 2;

struct SValidatorEnumArea
{
    CFangleArc Arc;

    EValueCompare Compare;

    uint32 Count;

    CFixed Radius;

    CFixed RadiusBonus;

    CValidatorLink Validator;
};

struct SValidatorCondition
{
    CValidatorLink Test;

    CValidatorLink Return;
};

struct SValidatorFunction : SValidatorCondition
{
    CValidatorLink Success;

    CValidatorLink Failure;

    CValidatorLink Ignored;

    flag8 Break;
};

class CValidator
{
public:
    uint8 IgnoreWhileChanneling;

    CCmdResult ResultFailed;
};

class CValidatorCombine : CValidator
{
public:
    EValidateCombine Type;

    std::vector<CValidatorLink> CombineArray;

    flag8 Negate;
};

class CValidatorCondition : CValidator
{
public:
    std::vector<SValidatorCondition> IfArray;

    CValidatorLink Else;
};

class CValidatorFunction : CValidator
{
public:
    std::vector<SValidatorFunction> Line;

    CCmdResult ResultFallback;
};

class CValidatorGameCompareTimeOfDay : CValidator
{
public:
    EValueCompare Compare;

    CTimeOfDay Value;
};

class CValidatorGameCompareTerrain : CValidator
{
public:
    EValueCompare Compare;

    CTerrainLink Value;
};

class CValidatorLocation : CValidator
{
public:
    SEffectWhichLocation WhichLocation;
};

class CValidatorLocationCompareCliffLevel : CValidatorLocation
{
public:
    SEffectWhichLocation OtherLocation;

    EValueCompare Compare;

    TCliffLevel Value;
};

class CValidatorLocationComparePower : CValidatorLocation
{
public:
    SEffectWhichPlayer WhichPlayer;

    TPowerLink PowerLink;

    std::vector<CBehaviorLink> PowerSource;

    EValueCompare Compare;

    TPowerLevel Value;
};

class CValidatorLocationCompareRange : CValidatorLocation
{
public:
    EValueCompare Compare;

    CFixed Range;

    flag8 Pathing;

    SEffectWhichLocation Value;
};

class CValidatorLocationArc : CValidatorLocation
{
public:
    SEffectWhichLocation OtherLocation;

    flag8 Find;

    CFangleArc Arc;

    SEffectWhichLocation Value;
};

class CValidatorLocationCreep : CValidatorLocation
{
public:
    SEffectWhichPlayer WhichPlayer;

    flag8 Find;

    CFixed RadiusBonus;
};

class CValidatorLocationCrossChasm : CValidatorLocation
{
public:
    SEffectWhichLocation OtherLocation;

    flag8 Find;
};

class CValidatorLocationCrossCliff : CValidatorLocation
{
public:
    SEffectWhichLocation OtherLocation;

    flag8 Find;

    flag8 CrossRamp;
};

class CValidatorLocationEnumArea : CValidatorLocation
{
public:
    std::vector<SValidatorEnumArea> AreaArray;

    EValueCompare Compare;

    uint32 Count;

    CFlags SearchFlags;

    SEffectWhichLocation LaunchLocation;

    CTargetFilters SearchFilters;

    std::vector<SEffectWhichUnit> ExcludeArray;

    std::vector<SEffectWhichUnit> IncludeArray;

    CIdentifier CachedSearch;

    EUnitVital CombinedVital;

    EValueCompare CombinedVitalCompare;

    SEffectWhichUnit CombinedVitalUnit;

    uint32 CombinedVitalValue;
};

class CValidatorLocationPathable : CValidatorLocation
{
public:
    flag8 Find;

    CFlagArray<e_pathingTypeCount> Types;
};

class CValidatorLocationPlacement : CValidatorLocation
{
public:
    SEffectWhichUnit FromUnit;

    SEffectWhichUnit OtherUnit;

    CFixed Range;

    CUnitLink Unit;
};

class CValidatorLocationType : CValidatorLocation
{
public:
    CValidatorLink None;

    CValidatorLink Point;

    CValidatorLink Unit;
};

class CValidatorLocationVision : CValidatorLocation
{
public:
    SEffectWhichPlayer WhichPlayer;

    flag8 Find;
};

class CValidatorPlayer : CValidator
{
public:
    SEffectWhichPlayer WhichPlayer;

    SEffectWhichPlayer OtherPlayer;

    CCmdResult ResultNoPlayer;
};

class CValidatorPlayerAlliance : CValidatorPlayer
{
public:
    flag8 Find;

    SEffectWhichPlayer WithPlayer;

    EAllianceId Value;
};

class CValidatorPlayerRequirement : CValidatorPlayer
{
public:
    flag8 Find;

    const CTechRequirementsGraph* Value;
};

class CValidatorPlayerCompare : CValidatorPlayer
{
public:
    EValueCompare Compare;
};

class CValidatorPlayerCompareDifficulty : CValidatorPlayerCompare
{
public:
    TDifficultyLevel Value;
};

class CValidatorPlayerCompareFoodAvailable : CValidatorPlayerCompare
{
public:
    CFixed Value;
};

class CValidatorPlayerCompareFoodMade : CValidatorPlayerCompare
{
public:
    CFixed Value;
};

class CValidatorPlayerCompareFoodUsed : CValidatorPlayerCompare
{
public:
    CFixed Value;
};

class CValidatorPlayerCompareRace : CValidatorPlayerCompare
{
public:
    CRaceLink Value;
};

class CValidatorPlayerCompareResource : CValidatorPlayerCompare
{
public:
    EResourceType Resource;

    uint32 Value;
};

class CValidatorPlayerCompareResult : CValidatorPlayerCompare
{
public:
    EGameResult Value;
};

class CValidatorPlayerCompareType : CValidatorPlayerCompare
{
public:
    EPlayerType Value;
};

class CValidatorUnit : CValidator
{
public:
    SEffectWhichUnit WhichUnit;

    SEffectWhichUnit OtherUnit;

    CCmdResult ResultNoUnit;
};

class CValidatorUnitAI : CValidatorUnit
{
public:
    flag8 Find;

    EUnitAIFlag Flag;
};

class CValidatorUnitCombatAI : CValidatorUnit
{
public:
    flag8 Find;
};

class CValidatorUnitAbil : CValidatorUnit
{
public:
    flag8 Find;

    EClassIdCAbil AbilClass;

    CAbilLink AbilLink;
};

class CValidatorUnitBehaviorState : CValidatorUnit
{
public:
    flag8 Enabled;

    EBehaviorState BehaviorState;
};

class CValidatorUnitDetected : CValidatorUnit
{
public:
    SEffectWhichPlayer WhichPlayer;

    flag8 Detected;

    CFlags Flags;
};

class CValidatorUnitFilters : CValidatorUnit
{
public:
    CTargetFilters Filters;
};

class CValidatorUnitFlying : CValidatorUnit
{
public:
    flag8 Find;
};

class CValidatorUnitInventory : CValidatorUnit
{
public:
    CCmdResult ResultNoInventory;
};

class CValidatorUnitInventoryIsFull : CValidatorUnitInventory
{
public:
    flag8 Find;
};

class CValidatorUnitInventoryContainsItem : CValidatorUnitInventory
{
public:
    flag8 Find;

    CUnitLink Item;
};

class CValidatorUnitLastDamagePlayer : CValidatorUnit
{
public:
    EPlayerRelationship Relationship;
};

class CValidatorUnitMissileNullified : CValidatorUnit
{
public:
    flag8 Find;
};

class CValidatorUnitMover : CValidatorUnit
{
public:
    CMoverLink Value;

    flag8 Find;
};

class CValidatorUnitOrder : CValidatorUnit
{
public:
    CAbilLink AbilLink;

    TAbilCmdIndex AbilCmdIndex;

    SEffectWhichLocation Target;
};

class CValidatorUnitOrderQueue : CValidatorUnit
{
public:
    CAbilLink AbilLink;

    TAbilCmdIndex AbilCmdIndex;

    flag8 Find;

    flag8 Queued;

    SEffectWhichLocation Target;
};

class CValidatorUnitOrderTargetPathable : CValidatorUnit
{
public:
    CAbilLink AbilLink;

    TAbilCmdIndex AbilCmdIndex;

    flag8 Find;

    CFixed MaxDistance;
};

class CValidatorUnitOrderTargetType : CValidatorUnit
{
public:
    CAbilLink AbilLink;

    TAbilCmdIndex AbilCmdIndex;

    flag8 Find;

    EEffectLocationType Type;
};

class CValidatorUnitPathable : CValidatorUnit
{
public:
    SEffectWhichLocation WhichLocation;

    flag8 Find;

    CFixed Range;

    CFixed MaxDistance;
};

class CValidatorUnitPathing : CValidatorUnit
{
public:
    flag8 Find;
};

class CValidatorUnitScanning : CValidatorUnit
{
public:
    flag8 Find;
};

class CValidatorUnitType : CValidatorUnit
{
public:
    CUnitLink Value;

    flag8 Find;

    EUnitType Type;
};

class CValidatorUnitWeaponAnimating : CValidatorUnit
{
public:
    CWeaponLink Weapon;

    flag8 Find;
};

class CValidatorUnitWeaponFiring : CValidatorUnit
{
public:
    CWeaponLink Weapon;

    flag8 Find;
};

class CValidatorUnitWeaponPlane : CValidatorUnit
{
public:
    flag8 Find;

    EPlane Plane;
};

class CValidatorUnitCompare : CValidatorUnit
{
public:
    EValueCompare Compare;
};

class CValidatorUnitCompareAIAreaEvalRatio : CValidatorUnitCompare
{
public:
    CFixed Radius;

    CFixed Value;
};

class CValidatorUnitCompareAbilLevel : CValidatorUnitCompare
{
public:
    CAbilLink AbilLink;

    uint32 Value;
};

class CValidatorUnitCompareAttackPriority : CValidatorUnitCompare
{
public:
    SEffectWhichUnit Attacker;

    CUnitLink AttackerAlternateType;

    CFlags Flags;

    TAttackTargetPriority Value;
};

class CValidatorUnitCompareBehaviorCount : CValidatorUnit
{
public:
    EValueCompare Compare;

    uint32 Value;

    CBehaviorLink Behavior;
};

class CValidatorUnitCompareCargo : CValidatorUnitCompare
{
public:
    ECargoSpace Type;

    uint8 Value;
};

class CValidatorUnitCompareChargeUsed : CValidatorUnitCompare
{
public:
    TChargeLink ChargeLink;

    EChargeLocation Location;

    CAbilLink Ability;

    CBehaviorLink Behavior;

    CFixed Value;
};

class CValidatorUnitCompareCooldown : CValidatorUnitCompare
{
public:
    TCooldownLink CooldownLink;

    ECooldownLocation Location;

    CAbilLink Ability;

    CBehaviorLink Behavior;

    CFixed Value;
};

class CValidatorUnitCompareDamageTakenTime : CValidatorUnitCompare
{
public:
    CGameTime Value;
};

class CValidatorUnitCompareDeath : CValidatorUnitCompare
{
public:
    EDeathType Value;
};

class CValidatorUnitCompareDetectRange : CValidatorUnitCompare
{
public:
    CFixed Value;

    flag8 Radar;
};

class CValidatorUnitCompareField : CValidatorUnitCompare
{
public:
    TCatalogFieldPath Field;

    TCatalogFieldValue Value;
};

class CValidatorUnitCompareMarkerCount : CValidatorUnitCompare
{
public:
    uint32 Value;
};

class CValidatorUnitCompareMoverPhase : CValidatorUnitCompare
{
public:
    uint32 Value;
};

class CValidatorUnitCompareOrderCount : CValidatorUnitCompare
{
public:
    CAbilLink AbilLink;

    TAbilCmdIndex AbilCmdIndex;

    uint32 Value;
};

class CValidatorUnitCompareOrderTargetRange : CValidatorUnitCompare
{
public:
    CAbilLink AbilLink;

    TAbilCmdIndex AbilCmdIndex;

    CFixed Value;

    flag8 Pathing;
};

class CValidatorUnitComparePowerSourceLevel : CValidatorUnitCompare
{
public:
    uint32 Value;

    CBehaviorLink Behavior;
};

class CValidatorUnitComparePowerUserLevel : CValidatorUnitCompare
{
public:
    uint32 Value;

    CBehaviorLink Behavior;
};

class CValidatorUnitCompareRallyPointCount : CValidatorUnitCompare
{
public:
    uint32 Value;

    CAbilLink AbilLink;

    uint32 Point;
};

class CValidatorUnitCompareResourceContents : CValidatorUnitCompare
{
public:
    uint32 Value;

    CBehaviorLink Behavior;
};

class CValidatorUnitCompareResourceHarvesters : CValidatorUnitCompare
{
public:
    uint32 Value;

    flag8 Active;

    flag8 Queued;

    CBehaviorLink Behavior;
};

class CValidatorUnitCompareSpeed : CValidatorUnitCompare
{
public:
    CGameSpeed Value;
};

class CValidatorUnitCompareVeterancyLevel : CValidatorUnitCompare
{
public:
    uint32 Value;

    CBehaviorLink Behavior;
};

class CValidatorUnitCompareVital : CValidatorUnitCompare
{
public:
    EVitalType Type;

    CFixed Value;

    EUnitVital Vital;
};

class CValidatorUnitCompareVitality : CValidatorUnitCompare
{
public:
    EVitalType Type;

    CFixed Value;
};

#endif // VALIDATOR_H