Behavior.h

Go to the documentation of this file.

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

#ifndef BEHAVIOR_H
#define BEHAVIOR_H

#include "UnderlyingTypes.h"
#include "Game.h"
#include "Unit.h"

typedef enum
{
    e_classIdCBehavior,

    e_classIdCBehaviorAttribute,

    e_classIdCBehaviorBuff,

    e_classIdCBehaviorClickResponse,

    e_classIdCBehaviorConjoined,

    e_classIdCBehaviorCreepSource,

    e_classIdCBehaviorJump,

    e_classIdCBehaviorPowerSource,

    e_classIdCBehaviorPowerUser,

    e_classIdCBehaviorResource,

    e_classIdCBehaviorReveal,

    e_classIdCBehaviorSpawn,

    e_classIdCBehaviorVeterancy,

    e_classIdCBehaviorWander,

} EClassIdCBehavior;

const int32 e_classIdCBehaviorCount = 14;

typedef enum
{
    e_behaviorCategoryPermanent,

    e_behaviorCategoryRestorable,

    e_behaviorCategoryTemporary,

} EBehaviorCategory;

const int32 e_behaviorCategoryCount = 3;

typedef enum
{
    e_behaviorFlagPermanent,

    e_behaviorFlagIgnoreInEditor,

    e_behaviorFlagEnabledWhileDead,

} EBehaviorFlag;

const int32 e_behaviorFlagCount = 3;

typedef enum
{
    e_behaviorBuffChanneled,

    e_behaviorBuffChanneling,

    e_behaviorBuffCountdown,

    e_behaviorBuffExtend,

    e_behaviorBuffDisableWhileUnderConstruction,

    e_behaviorBuffRemoveDamageResponseExhausted,

    e_behaviorBuffRefreshStack,

    e_behaviorBuffUpdateDurationWhileDisabled,

} EBehaviorBuff;

const int32 e_behaviorBuffCount = 8;

typedef enum
{
    e_behaviorBuffReplaceShortestDuration,

    e_behaviorBuffReplaceFarthestDistance,

} EBehaviorBuffReplace;

const int32 e_behaviorBuffReplaceCount = 2;

typedef enum
{
    e_conjoinedFlagShareLife,

    e_conjoinedFlagShareShields,

    e_conjoinedFlagShareEnergy,

    e_conjoinedFlagShareVisible,

    e_conjoinedFlagShareAcquire,

    e_conjoinedFlagShareSelect,

} EConjoinedFlag;

const int32 e_conjoinedFlagCount = 6;

typedef enum
{
    e_behaviorDisplaySelf,

    e_behaviorDisplayAlly,

    e_behaviorDisplayNeutral,

    e_behaviorDisplayEnemy,

} EBehaviorDisplay;

const int32 e_behaviorDisplayCount = 4;

typedef enum
{
    e_behaviorInfoFlagHidden,

} EBehaviorInfoFlag;

const int32 e_behaviorInfoFlagCount = 1;

typedef enum
{
    e_behaviorResourceFlagHideHarvesters,

    e_behaviorResourceFlagRemoveWhenEmpty,

} EBehaviorResourceFlag;

const int32 e_behaviorResourceFlagCount = 2;

typedef enum
{
    e_behaviorAlignmentNeutral,

    e_behaviorAlignmentPositive,

    e_behaviorAlignmentNegative,

} EBehaviorAlignment;

const int32 e_behaviorAlignmentCount = 3;

typedef enum
{
    e_behaviorModifyDisableAbils,

    e_behaviorModifyEnableAttack,

    e_behaviorModifyEnableMove,

    e_behaviorModifyMovement,

    e_behaviorModifyReveal,

    e_behaviorModifyDetected,

    e_behaviorModifyShareSight,

    e_behaviorModifySuppressMoving,

    e_behaviorModifySuppressTurning,

    e_behaviorModifyWarpable,

    e_behaviorModifyHideChangeUI,

    e_behaviorModifyOrdersUninterruptible,

} EBehaviorModify;

const int32 e_behaviorModifyCount = 12;

typedef enum
{
    e_behaviorStateBury,

    e_behaviorStateCloak,

    e_behaviorStateGenerateThreat,

    e_behaviorStateHallucination,

    e_behaviorStateInvulnerable,

    e_behaviorStateBenign,

    e_behaviorStatePassive,

    e_behaviorStateRevealProgress,

    e_behaviorStateStasis,

    e_behaviorStateStun,

    e_behaviorStateSummoned,

    e_behaviorStateSuppressAttack,

    e_behaviorStateSuppressBuildOn,

    e_behaviorStateSuppressCloak,

    e_behaviorStateSuppressCollision,

    e_behaviorStateSuppressCombat,

    e_behaviorStateSuppressDetection,

    e_behaviorStateSuppressDropOff,

    e_behaviorStateSuppressFidgeting,

    e_behaviorStateSuppressFoodMade,

    e_behaviorStateSuppressFoodUsed,

    e_behaviorStateSuppressInvulnerability,

    e_behaviorStateSuppressPassenger,

    e_behaviorStateSuppressRadar,

    e_behaviorStateSuppressRequirements,

    e_behaviorStateSuppressTech,

    e_behaviorStateSuppressThreat,

    e_behaviorStateSuppressLife,

    e_behaviorStateSuppressShields,

    e_behaviorStateSuppressEnergy,

    e_behaviorStateSuppressLifeRegen,

    e_behaviorStateSuppressShieldsRegen,

    e_behaviorStateSuppressEnergyRegen,

    e_behaviorStateNoDraw,

    e_behaviorStateTransientMorph,

    e_behaviorStateUncommandable,

    e_behaviorStateUndetectable,

    e_behaviorStateUnradarable,

    e_behaviorStateUnselectable,

    e_behaviorStateUnstoppable,

    e_behaviorStateUntargetable,

    e_behaviorStateLineMovement,

    e_behaviorStateDetector,

    e_behaviorStateRadar,

} EBehaviorState;

const int32 e_behaviorStateCount = 44;

typedef enum
{
    e_behaviorPowerUserFlagDisplayPower,

    e_behaviorPowerUserFlagKillIfUnpowered,

    e_behaviorPowerUserFlagLevelFromSourceCount,

} EBehaviorPowerUserFlag;

const int32 e_behaviorPowerUserFlagCount = 3;

typedef enum
{
    e_behaviorSpawnFlagHideCount,

    e_behaviorSpawnFlagIgnoreMorph,

    e_behaviorSpawnFlagKillSpawnedOnDeath,

} EBehaviorSpawnFlag;

const int32 e_behaviorSpawnFlagCount = 3;

typedef enum
{
    e_behaviorVeterancyFlagCombineNumericModifications,

    e_behaviorVeterancyFlagCombineXP,

    e_behaviorVeterancyFlagMaxLevelLeech,

} EBehaviorVeterancyFlag;

const int32 e_behaviorVeterancyFlagCount = 3;

typedef enum
{
    e_behaviorVeterancyXPDamageDealt,

    e_behaviorVeterancyXPDamageTaken,

    e_behaviorVeterancyXPKills,

} EBehaviorVeterancyXP;

const int32 e_behaviorVeterancyXPCount = 3;

typedef enum
{
    e_damageLocationAttacker,

    e_damageLocationDefender,

} EDamageLocation;

const int32 e_damageLocationCount = 2;

typedef enum
{
    e_behaviorRateCharge,

    e_behaviorRateCooldown,

    e_behaviorRateMorph,

    e_behaviorRateProgress,

    e_behaviorRateQueueable,

    e_behaviorRateSpawn,

    e_behaviorRateCreep,

} EBehaviorRate;

const int32 e_behaviorRateCount = 7;

typedef enum
{
    e_behaviorHeightStart,

    e_behaviorHeightStop,

} EBehaviorHeight;

const int32 e_behaviorHeightCount = 2;

struct SAttributeChange
{
    CBehaviorLink Attribute;

    int32 Points;
};

struct SDamageKind
{
    std::vector<CFixed> KindArray;
};

struct SBehaviorResponse
{
    CFixed Chance;

    SCost Cost;
};

struct SDamageResponse : SBehaviorResponse
{
    CFixed ClampMaximum;

    CFixed ClampMinimum;

    CEffectLink Exhausted;

    flag8 Fatal;

    CEffectLink Handled;

    std::vector<CFixed> Ignore;

    CFlagArray<e_damageKindCount> Kind;

    EDamageLocation Location;

    CFixed Maximum;

    CFixed Minimum;

    CFixed ModifyAmount;

    CFixed ModifyFraction;

    CFixed ModifyLimit;

    flag8 ModifyMinimumDamage;

    CTargetFilters TargetFilters;

    std::vector<CEffectLink> RequireEffectArray;

    std::vector<CEffectLink> ExcludeEffectArray;
};

struct SDeathResponse : SBehaviorResponse
{
    CEffectLink Effect;

    CFlagArray<e_playerRelationshipCount> Relationship;

    CFlagArray<e_deathTypeCount> Type;
};

struct SModification
{
    CFlagArray<e_behaviorModifyCount> ModifyFlags;

    CFlagArray<e_behaviorStateCount> StateFlags;

    CFixed Height;

    std::vector<CGameTime> HeightTime;

    CFixed SightBonus;

    CFixed SightMaximum;

    CFixed SightMinimum;

    int32 QueueCount;

    int32 QueueSize;

    CFixed TimeScale;

    CGameSpeed MoveSpeedMaximum;

    CGameSpeed MoveSpeedMinimum;

    CGameSpeed MoveSpeedBonus;

    CFixed MoveSpeedMultiplier;

    CFixed UnifiedMoveSpeedFactor;

    CGameAcceleration AccelerationBonus;

    CFixed AccelerationMultiplier;

    CGameAcceleration DecelerationBonus;

    CFixed DecelerationMultiplier;

    CFixed SnareMultiplier;

    CFixed AttackSpeedMultiplier;

    CFixed UnifiedAttackSpeedFactor;

    CFixed WeaponRange;

    CFixed WeaponMinRange;

    std::vector<CFixed> DamageDealtScaled;

    std::vector<CFixed> DamageDealtFraction;

    std::vector<CFixed> DamageDealtUnscaled;

    std::vector<CFixed> DamageDealtMaximum;

    std::vector<CFixed> DamageDealtMinimum;

    std::vector<CFixed> DamageDealtAttributeScaled;

    std::vector<CFixed> DamageDealtAttributeMultiplier;

    std::vector<CFixed> DamageDealtAttributeUnscaled;

    CFixed LifeArmorBonus;

    CFixed LifeArmorMultiplier;

    CFixed ShieldArmorBonus;

    CFixed ShieldArmorMultiplier;

    std::vector<uint32> ResourceHarvestAmountBonus;

    std::vector<CFixed> ResourceHarvestAmountMultiplier;

    std::vector<CGameTime> ResourceHarvestTimeBonus;

    std::vector<CFixed> ResourceHarvestTimeMultiplier;

    std::vector<CFixed> VitalMaxArray;

    std::vector<CFixed> VitalMaxFractionArray;

    std::vector<CGameRate> VitalRegenArray;

    std::vector<SDamageKind> VitalDamageGainArray;

    std::vector<SDamageKind> VitalDamageLeechArray;

    CFlagArray<e_classIdCAbilCount> AbilClassEnableArray;

    CFlagArray<e_classIdCAbilCount> AbilClassDisableArray;

    std::vector<CAbilLink> AbilLinkEnableArray;

    std::vector<CAbilLink> AbilLinkDisableArray;

    CBehaviorCategoryFlags BehaviorCategoriesEnable;

    CBehaviorCategoryFlags BehaviorCategoriesDisable;

    CFlagArray<e_classIdCBehaviorCount> BehaviorClassEnableArray;

    CFlagArray<e_classIdCBehaviorCount> BehaviorClassDisableArray;

    std::vector<CBehaviorLink> BehaviorLinkEnableArray;

    std::vector<CBehaviorLink> BehaviorLinkDisableArray;

    std::vector<SUnitWeaponData> WeaponArray;

    CFixed WeaponScanBonus;

    std::vector<CWeaponLink> WeaponEnableArray;

    std::vector<CWeaponLink> WeaponDisableArray;

    std::vector<CTurretLink> TurretEnableArray;

    std::vector<CTurretLink> TurretDisableArray;

    std::vector<CSoundLink> SoundArray;

    CFixed Detect;

    CFangleArc DetectArc;

    CFixed DetectBonus;

    CTargetFilters DetectFilters;

    CFixed Radar;

    CFangleArc RadarArc;

    CTargetFilters RadarFilters;

    CFixed Food;

    std::vector<SAttributeChange> AttributeChangeArray;

    std::vector<CFixed> RateMultiplierArray;

    SDeathResponse DeathResponse;

    std::vector<int8> PlaneDelta;

    int32 ScoreKillBonus;

    int32 ScoreLostBonus;

    int16 SubgroupPriority;
};

struct SPowerStage
{
    uint32 MaxStackCount;

    TPowerLevel MinPowerLevel;

    SModification Modification;

    CEffectLink LevelGainEffect;

    CEffectLink LevelLossEffect;
};

struct SSpawnInfo
{
    CUnitLink Unit;

    uint32 Count;

    uint32 MaxCount;

    uint32 StartCount;

    const CTechRequirementsGraph* Requirements;

    CGameTime Delay;

    CEffectLink Effect;
};

struct SVeterancyLevel
{
    CImagePath InfoIcon;

    uint32 MinVeterancyXP;

    SModification Modification;

    CEffectLink LevelGainEffect;

    CEffectLink LevelLossEffect;
};

class CBehavior
{
public:
    CStringLink Name;

    CStringLink Tooltip;

    uint32 InfoTooltipPriority;

    EBehaviorAlignment Alignment;

    SCost Cost;

    CFlags BehaviorFlags;

    CFlags InfoFlags;

    CImagePath InfoIcon;

    CBehaviorCategoryFlags BehaviorCategories;

    TEditorCategories EditorCategories;

    const CTechRequirementsGraph* Requirements;

    std::vector<TTechAlias> TechAliasArray;
};

class CBehaviorAttribute : CBehavior
{
public:
    int32 MinPoints;

    int32 MaxPoints;

    SModification Modification;

    CEffectLink PointGainEffect;

    CEffectLink PointLossEffect;
};

class CBehaviorBuff : CBehavior
{
public:
    CFlags DisplayDuration;

    CFlags DisplayShield;

    std::vector<CValidatorLink> DisableValidatorArray;

    std::vector<CValidatorLink> RemoveValidatorArray;

    CFlags BuffFlags;

    uint32 MaxStackCount;

    uint32 MaxStackCountPerCaster;

    SEffectWhichTimeScale TimeScaleSource;

    CGameTime Duration;

    CGameTime DurationShield;

    std::vector<CGameTime> DurationVitalArray;

    std::vector<CGameTime> DurationVitalMaxArray;

    CGameTime DurationRandomMin;

    CGameTime DurationRandomMax;

    CGameTime DurationBonusMin;

    CGameTime DurationBonusMax;

    CGameTime Period;

    uint32 PeriodCount;

    CEffectLink InitialEffect;

    CEffectLink RefreshEffect;

    CEffectLink PeriodicEffect;

    CEffectLink FinalEffect;

    CEffectLink ExpireEffect;

    SEffectWhichPlayer Player;

    SEffectWhichPlayer AcquirePlayer;

    SModification Modification;

    CEffectLink AINotifyEffect;

    SDamageResponse DamageResponse;

    SEffectWhichUnit KillCredit;

    EBehaviorBuffReplace Replace;

    SEffectWhichLocation ReplaceLocation;

    CHerdNodeLink HerdNode;
};

class CBehaviorClickResponse : CBehavior
{
public:
    CFixed Chance;

    uint32 Count;

    CGameTime CountDelay;

    CEffectLink CountEffect;

    CFlagArray<e_playerRelationshipCount> Relationship;

    CGameTime ResetDelay;

    CEffectLink ResetEffect;
};

class CBehaviorConjoined : CBehavior
{
public:
    CFlags ConjoinedFlags;

    CFixed Radius;
};

class CBehaviorCreepSource : CBehavior
{
public:
    CGameTime Delay;

    CGameTime Period;

    CFootprintLink Build;

    CFootprintLink Start;

    CFootprintLink Birth;

    CFootprintLink Grown;

    std::vector<CValidatorLink> DisableValidatorArray;

    std::vector<CValidatorLink> RemoveValidatorArray;
};

class CBehaviorJump : CBehavior
{
public:
    CFixed TriggerHeightDeltaMin;

    CFixed TriggerHeightDeltaMax;

    CFixed InitiateRangeUp;

    CFixed InitiateRangeDown;

    CFixed JumpRangeMax;

    CEffectLink JumpEffectUp;

    CEffectLink JumpEffectDown;

    CMoverLink Mover;

    CMoverLink MoverUp;

    CMoverLink MoverDown;

    CGameTime DurationPreLaunch;

    CGameTime DurationPostLand;

    CGameTime DurationMoveOut;

    CUnitLink Placeholder;

    CFixed LandAdjustmentUp;

    CFixed LandAdjustmentDown;

    CFixed LandArrivalRange;

    CFixed LandCheckRadius;

    CEffectLink LandEffectUp;

    CEffectLink LandEffectDown;
};

class CBehaviorPowerSource : CBehavior
{
public:
    TPowerLevel PowerLevel;

    CFixed Radius;

    TPowerLink PowerLink;

    CFlagArray<e_cliffLevelCompareCount> CliffLevelFlags;
};

class CBehaviorPowerUser : CBehavior
{
public:
    TPowerLink PowerLink;

    TPowerLevel PlacementMinPowerLevel;

    CFlags Flags;

    flag8 PoweredWhileUnderConstruction;

    std::vector<SPowerStage> PowerStageArray;
};

class CBehaviorResource : CBehavior
{
public:
    uint32 Capacity;

    uint32 Contents;

    CGameTime HarvestTime;

    uint32 HarvestAmount;

    uint32 EmptyHarvestAmount;

    CUnitLink EmptyUnit;

    CFlags Flags;

    EAllianceId RequiredAlliance;

    CGameTime ReturnDelay;

    CAlertLink ExhaustedAlert;

    CAlertLink DepletionAlert;

    uint32 DepletionThreshold;

    uint32 DepletionVariationCount;

    CBehaviorLink CarryResourceBehavior;

    uint32 IdealHarvesterCount;

    CTargetFilters EnabledSearchFilters;

    CFixed EnabledSearchRadius;
};

class CBehaviorReveal : CBehavior
{
public:
    CGameTime Duration;

    CTargetFilters SearchFilters;
};

class CBehaviorSpawn : CBehavior
{
public:
    CFlags DisplayDuration;

    std::vector<SSpawnInfo> InfoArray;

    CGamePoint Center;

    std::vector<CGamePoint> Offset;

    CFixed Slop;

    CEffectLink Effect;

    CFixed Range;

    CFlags Flags;

    uint32 Limit;

    EDeathType LimitDeath;

    CBehaviorLink ConjoinedLink;
};

class CBehaviorVeterancy : CBehavior
{
public:
    CFlags Flags;

    std::vector<CTargetFilters> ShareFilters;

    std::vector<CTargetFilters> TargetFilters;

    std::vector<CFixed> XPFraction;

    std::vector<CFixed> SharedXPRadius;

    std::vector<CFixed> SharedXPFraction;

    std::vector<SVeterancyLevel> VeterancyLevelArray;
};

class CBehaviorWander : CBehavior
{
public:
    flag8 Leash;

    CFixed Range;

    CGameTime Delay;
};

#endif // BEHAVIOR_H