Abil.h

Go to the documentation of this file.

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

#ifndef ABIL_H
#define ABIL_H

#include "UnderlyingTypes.h"
#include "Game.h"
#include "ItemContainer.h"
#include "TargetSort.h"

typedef enum
{
    e_classIdCAbil,

    e_classIdCAbilProgress,

    e_classIdCAbilEffect,

    e_classIdCAbilQueueable,

    e_classIdCAbilRedirect,

    e_classIdCAbilArmMagazine,

    e_classIdCAbilAttack,

    e_classIdCAbilAugment,

    e_classIdCAbilBattery,

    e_classIdCAbilBeacon,

    e_classIdCAbilBehavior,

    e_classIdCAbilBuild,

    e_classIdCAbilBuildable,

    e_classIdCAbilEffectInstant,

    e_classIdCAbilEffectTarget,

    e_classIdCAbilHarvest,

    e_classIdCAbilInteract,

    e_classIdCAbilInventory,

    e_classIdCAbilLearn,

    e_classIdCAbilMerge,

    e_classIdCAbilMergeable,

    e_classIdCAbilMorph,

    e_classIdCAbilMorphPlacement,

    e_classIdCAbilMove,

    e_classIdCAbilPawn,

    e_classIdCAbilQueue,

    e_classIdCAbilRally,

    e_classIdCAbilRedirectInstant,

    e_classIdCAbilRedirectTarget,

    e_classIdCAbilResearch,

    e_classIdCAbilRevive,

    e_classIdCAbilSpecialize,

    e_classIdCAbilStop,

    e_classIdCAbilTrain,

    e_classIdCAbilTransport,

    e_classIdCAbilWarpable,

    e_classIdCAbilWarpTrain,

} EClassIdCAbil;

const int32 e_classIdCAbilCount = 37;

typedef enum
{
    e_abilAlignmentNeutral,

    e_abilAlignmentNegative,

    e_abilAlignmentPositive,

} EAbilAlignment;

const int32 e_abilAlignmentCount = 3;

typedef enum
{
    e_abilCmdAllowSelfCast,

    e_abilCmdHidden,

    e_abilCmdShowInGlossary,

    e_abilCmdToSelection,

} EAbilCmdFlags;

const int32 e_abilCmdCount = 4;

typedef enum
{
    e_abilCmdStateAvailable,

    e_abilCmdStateRestricted,

    e_abilCmdStateSuppressed,

} EAbilCmdState;

const int32 e_abilCmdStateCount = 3;

typedef enum
{
    e_abilSharedFlagDisableWhileDead,

} EAbilSharedFlag;

const int32 e_abilSharedFlagCount = 1;

typedef enum
{
    e_abilTechPlayerOwner,

    e_abilTechPlayerUpkeep,

} EAbilTechPlayer;

const int32 e_abilTechPlayerCount = 2;

typedef enum
{
    e_abilArmMagEffectCreate,

    e_abilArmMagEffectDeath,

    e_abilArmMagEffectLaunch,

    e_abilArmMagEffectRelease,

} EAbilArmMagazineEffect;

const int32 e_abilArmMagEffectCount = 4;

typedef enum
{
    e_abilArmMagFlagAutoCastOffOwnerLeave,

    e_abilArmMagFlagAutoCreate,

    e_abilArmMagFlagBestUnit,

    e_abilArmMagFlagIgnoreUnitCost,

    e_abilArmMagFlagRetarget,

    e_abilArmMagFlagShowStatus,

    e_abilArmMagFlagTransient,

    e_abilArmMagFlagUnitOrderQueue,

    e_abilArmMagFlagWaitForFood,

} EAbilArmMagazineFlag;

const int32 e_abilArmMagFlagCount = 9;

typedef enum
{
    e_abilArmMagInfoFlagAutoBuild,

    e_abilArmMagInfoFlagAutoBuildOn,

    e_abilArmMagInfoFlagExternal,

} EAbilArmMagazineInfoFlag;

const int32 e_abilArmMagInfoFlagCount = 3;

typedef enum
{
    e_abilArmMagLaunchFireAtTarget,

    e_abilArmMagLaunchReleaseAtSource,

    e_abilArmMagLaunchReleaseAtTarget,

} EAbilArmMagazineLaunch;

const int32 e_abilArmMagLaunchCount = 3;

typedef enum
{
    e_abilArmMagManageDestroy,

    e_abilArmMagManageIgnore,

    e_abilArmMagManageRecall,

} EAbilArmMagazineManage;

const int32 e_abilArmMagManageCount = 3;

typedef enum
{
    e_abilAttackStageApproach,

    e_abilAttackStageAttack,

    e_abilAttackStageLoiter,

} EAbilAttackStage;

const int32 e_abilAttackStageCount = 3;

typedef enum
{
    e_abilAugmentFlagAutoCast,

    e_abilAugmentFlagAutoCastOffOwnerLeave,

    e_abilAugmentFlagAutoCastOn,

    e_abilAugmentFlagBestUnit,

    e_abilAugmentFlagSmart,

} EAbilAugmentFlag;

const int32 e_abilAugmentFlagCount = 5;

typedef enum
{
    e_abilBehaviorFlagAutoCast,

    e_abilBehaviorFlagAutoCastOffOwnerLeave,

    e_abilBehaviorFlagAutoCastOn,

    e_abilBehaviorFlagBestUnit,

    e_abilBehaviorFlagToggle,

    e_abilBehaviorFlagToggledOn,

    e_abilBehaviorFlagTransient,

} EAbilBehaviorFlag;

const int32 e_abilBehaviorFlagCount = 7;

typedef enum
{
    e_abilBehaviorStageUntoggled,

    e_abilBehaviorStageToggled,

} EAbilBehaviorStage;

const int32 e_abilBehaviorStageCount = 2;

typedef enum
{
    e_abilBuildEffectStart,

    e_abilBuildEffectFinish,

    e_abilBuildEffectCancel,

} EAbilBuildEffect;

const int32 e_abilBuildEffectCount = 3;

typedef enum
{
    e_abilBuildFlagBestUnit,

    e_abilBuildFlagCancelable,

    e_abilBuildFlagHomogenousInterrupt,

    e_abilBuildFlagIgnoreFood,

    e_abilBuildFlagIgnoreUnitCost,

    e_abilBuildFlagInstantPlacement,

    e_abilBuildFlagInterruptible,

    e_abilBuildFlagNeutralDetachedAddOn,

    e_abilBuildFlagPeonHide,

    e_abilBuildFlagPeonDisableAbils,

    e_abilBuildFlagPeonDisableCollision,

    e_abilBuildFlagPeonFidgetAcross,

    e_abilBuildFlagPeonKillCancel,

    e_abilBuildFlagPeonKillFinish,

    e_abilBuildFlagPeonMaintained,

    e_abilBuildFlagRangeIncludesBuilding,

    e_abilBuildFlagShowProgress,

} EAbilBuildFlag;

const int32 e_abilBuildFlagCount = 17;

typedef enum
{
    e_abilBuildStageApproach,

    e_abilBuildStageWait,

    e_abilBuildStageConstruct,

    e_abilBuildStageHalt,

    e_abilBuildStageResume,

    e_abilBuildStageFinish,

    e_abilBuildStageCollide,

} EAbilBuildStage;

const int32 e_abilBuildStageCount = 7;

typedef enum
{
    e_abilBuildTypeNormal,

    e_abilBuildTypeAddOn,

} EAbilBuildType;

const int32 e_abilBuildTypeCount = 2;

typedef enum
{
    e_abilEffectFlagAbortOnAllianceChange,

    e_abilEffectFlagAllowMovement,

    e_abilEffectFlagAutoCast,

    e_abilEffectFlagAutoCastOffOwnerLeave,

    e_abilEffectFlagAutoCastOn,

    e_abilEffectFlagBestUnit,

    e_abilEffectFlagChase,

    e_abilEffectFlagClearLastAttackTarget,

    e_abilEffectFlagDeferCooldown,

    e_abilEffectFlagLineMovement,

    e_abilEffectFlagNoDeceleration,

    e_abilEffectFlagRangeUsePathing,

    e_abilEffectFlagReExecutable,

    e_abilEffectFlagRequireTargetVision,

    e_abilEffectFlagSmart,

    e_abilEffectFlagTransient,

    e_abilEffectFlagTransientPreferred,

    e_abilEffectFlagWaitToSpend,

    e_abilEffectFlagPassengerAcquireExternal,

    e_abilEffectFlagPassengerAcquirePassengers,

    e_abilEffectFlagPassengerAcquireTransport,

    e_abilEffectFlagTransportAcquirePassengers,

    e_abilEffectFlagUpdateChargesOnLevelChange,

} EAbilEffectFlag;

const int32 e_abilEffectFlagCount = 23;

typedef enum
{
    e_abilEffectStageApproach,

    e_abilEffectStageWait,

    e_abilEffectStagePrep,

    e_abilEffectStageCast,

    e_abilEffectStageChannel,

    e_abilEffectStageFinish,

    e_abilEffectStageBail,

} EAbilEffectStage;

const int32 e_abilEffectStageCount = 7;

typedef enum
{
    e_abilHarvestFlagBypassResourceQueue,

} EAbilHarvestFlag;

const int32 e_abilHarvestFlagCount = 1;

typedef enum
{
    e_abilHarvestStageApproachResource,

    e_abilHarvestStageWaitAtResource,

    e_abilHarvestStageHarvest,

    e_abilHarvestStageWaitToReturn,

    e_abilHarvestStageWaitForDropOff,

    e_abilHarvestStageApproachDropOff,

    e_abilHarvestStageDropOff,

} EAbilHarvestStage;

const int32 e_abilHarvestStageCount = 7;

typedef enum
{
    e_abilInteractFlagAutoCast,

    e_abilInteractFlagBestUnit,

    e_abilInteractFlagExclusive,

    e_abilInteractFlagSameCliffLevel,

    e_abilInteractFlagShareControl,

    e_abilInteractFlagShareVision,

    e_abilInteractFlagSmart,

} EAbilInteractFlag;

const int32 e_abilInteractFlagCount = 7;

typedef enum
{
    e_abilInventoryAlignmentRight,

    e_abilInventoryAlignmentLeft,

} EAbilInventoryAlignment;

const int32 e_abilInventoryAlignmentCount = 2;

typedef enum
{
    e_abilInventoryFlagItemDeath,

} EAbilInventoryFlag;

const int32 e_abilInventoryFlagCount = 1;

typedef enum
{
    e_abilLearnFlagBestUnit,

    e_abilLearnFlagHideOnMaxLevel,

    e_abilLearnFlagHideOnPointsSpent,

    e_abilLearnFlagTransient,

    e_abilLearnFlagUnitOrderQueue,

} EAbilLearnFlag;

const int32 e_abilLearnFlagCount = 5;

typedef enum
{
    e_abilMergeFlagBestUnit,

    e_abilMergeFlagIgnoreUnitCost,

} EAbilMergeFlag;

const int32 e_abilMergeFlagCount = 2;

typedef enum
{
    e_abilMorphEffectStart,

    e_abilMorphEffectFinish,

    e_abilMorphEffectCancel,

} EAbilMorphEffect;

const int32 e_abilMorphEffectCount = 3;

typedef enum
{
    e_abilMorphFlagAutoCast,

    e_abilMorphFlagAutoCastIdleOnly,

    e_abilMorphFlagAutoCastOffOwnerLeave,

    e_abilMorphFlagAutoCastOn,

    e_abilMorphFlagAutomatic,

    e_abilMorphFlagBestUnit,

    e_abilMorphFlagBirth,

    e_abilMorphFlagDisableAbils,

    e_abilMorphFlagDisableCollision,

    e_abilMorphFlagFastBuild,

    e_abilMorphFlagInterruptible,

    e_abilMorphFlagIgnoreCollision,

    e_abilMorphFlagIgnoreFacing,

    e_abilMorphFlagIgnoreFood,

    e_abilMorphFlagIgnorePlacement,

    e_abilMorphFlagIgnoreUnitCost,

    e_abilMorphFlagMoveBlockers,

    e_abilMorphFlagProduce,

    e_abilMorphFlagRally,

    e_abilMorphFlagRallyReset,

    e_abilMorphFlagShowPlaceholder,

    e_abilMorphFlagShowProgress,

    e_abilMorphFlagSuppressMovement,

    e_abilMorphFlagTransient,

    e_abilMorphFlagWaitUntilStopped,

} EAbilMorphFlag;

const int32 e_abilMorphFlagCount = 25;

typedef enum
{
    e_abilMorphPhaseDelay,

    e_abilMorphPhaseDuration,

} EAbilMorphPhase;

const int32 e_abilMorphPhaseCount = 2;

typedef enum
{
    e_abilMorphSectionAbils,

    e_abilMorphSectionActor,

    e_abilMorphSectionCollide,

    e_abilMorphSectionFacing,

    e_abilMorphSectionMover,

    e_abilMorphSectionStats,

} EAbilMorphSection;

const int32 e_abilMorphSectionCount = 6;

typedef enum
{
    e_abilMorphStageApproach,

    e_abilMorphStageWait,

    e_abilMorphStageAbilsStart,

    e_abilMorphStageAbilsEnd,

    e_abilMorphStageActorStart,

    e_abilMorphStageActorEnd,

    e_abilMorphStageCollideStart,

    e_abilMorphStageCollideEnd,

    e_abilMorphStageFacingStart,

    e_abilMorphStageFacingEnd,

    e_abilMorphStageMoverStart,

    e_abilMorphStageMoverEnd,

    e_abilMorphStageStatsStart,

    e_abilMorphStageStatsEnd,

    e_abilMorphStageUnitStart,

    e_abilMorphStageUnitEnd,

} EAbilMorphStage;

const int32 e_abilMorphStageCount = 16;

typedef enum
{
    e_abilMoveFlagShowIfImmobile,

} EAbilMoveFlag;

const int32 e_abilMoveFlagCount = 1;

typedef enum
{
    e_abilPawnFlagBestUnit,

    e_abilPawnFlagSmart,

} EAbilPawnFlag;

const int32 e_abilPawnFlagCount = 2;

typedef enum
{
    e_abilQueueFlagBestUnit,

    e_abilQueueFlagHidden,

    e_abilQueueFlagNotifyAddOn,

    e_abilQueueFlagPassive,

} EAbilQueueFlag;

const int32 e_abilQueueFlagCount = 4;

typedef enum
{
    e_abilRallyFlagShowWhileMerging,

    e_abilRallyFlagShowWhileWarping,

} EAbilRallyFlag;

const int32 e_abilRallyFlagCount = 2;

typedef enum
{
    e_abilRallyStagePlace,

} EAbilRallyStage;

const int32 e_abilRallyStageCount = 1;

typedef enum
{
    e_abilRedirectFlagIncludeSelf,

} EAbilRedirectFlag;

const int32 e_abilRedirectFlagCount = 1;

typedef enum
{
    e_abilResearchFlagBestUnit,

    e_abilResearchFlagTransient,

    e_abilResearchFlagUnitOrderQueue,

} EAbilResearchFlag;

const int32 e_abilResearchFlagCount = 3;

typedef enum
{
    e_abilReviveFlagBestUnit,

    e_abilReviveFlagTransient,

    e_abilReviveFlagUnitOrderQueue,

    e_abilReviveFlagWaitForFood,

} EAbilReviveFlag;

const int32 e_abilReviveFlagCount = 4;

typedef enum
{
    e_abilReviveVitalIgnore,

    e_abilReviveVitalStart,

    e_abilReviveVitalMaximum,

} EAbilReviveVital;

const int32 e_abilReviveVitalCount = 3;

typedef enum
{
    e_abilSpecializeFlagAutoCastOffOwnerLeave,

    e_abilSpecializeFlagBestUnit,

    e_abilSpecializeFlagTransient,

    e_abilSpecializeFlagUnitOrderQueue,

} EAbilSpecializeFlag;

const int32 e_abilSpecializeFlagCount = 4;

typedef enum
{
    e_abilSpecializeInfoFlagAutoCast,

    e_abilSpecializeInfoFlagAutoCastOn,

} EAbilSpecializeInfoFlag;

const int32 e_abilSpecializeInfoFlagCount = 2;

typedef enum
{
    e_abilStopFlagHoldFire,

} EAbilStopFlag;

const int32 e_abilStopFlagCount = 1;

typedef enum
{
    e_abilTrainFlagAutoCastOffOwnerLeave,

    e_abilTrainFlagBestUnit,

    e_abilTrainFlagDisableCollision,

    e_abilTrainFlagIgnoreUnitCost,

    e_abilTrainFlagKillOnCancel,

    e_abilTrainFlagKillOnFinish,

    e_abilTrainFlagSelect,

    e_abilTrainFlagTransient,

    e_abilTrainFlagUnitOrderQueue,

    e_abilTrainFlagWaitForFood,

} EAbilTrainFlag;

const int32 e_abilTrainFlagCount = 10;

typedef enum
{
    e_abilTrainInfoFlagAutoCast,

    e_abilTrainInfoFlagAutoCastOn,

} EAbilTrainInfoFlag;

const int32 e_abilTrainInfoFlagCount = 2;

typedef enum
{
    e_abilTrainLocationSource,

    e_abilTrainLocationRally,

} EAbilTrainLocation;

const int32 e_abilTrainLocationCount = 2;

typedef enum
{
    e_abilTrainRotationTarget,

    e_abilTrainRotationSource,

} EAbilTrainRotation;

const int32 e_abilTrainRotationCount = 2;

typedef enum
{
    e_abilTransportFlagAllowPassengerSmartCmd,

    e_abilTransportFlagAllowSmartCmd,

    e_abilTransportFlagCargoDeath,

    e_abilTransportFlagIgnoreBlockers,

    e_abilTransportFlagPlayerHold,

    e_abilTransportFlagShowCargoSize,

    e_abilTransportFlagShowStatus,

} EAbilTransportFlag;

const int32 e_abilTransportFlagCount = 7;

typedef enum
{
    e_abilWarpTrainFlagIgnoreRampTest,

    e_abilWarpTrainFlagIgnoreUnitCost,

} EAbilWarpTrainFlag;

const int32 e_abilWarpTrainFlagCount = 2;

typedef enum
{
    e_abilArmMagazineCmdAmmo1,

    e_abilArmMagazineCmdAmmo2,

    e_abilArmMagazineCmdAmmo3,

    e_abilArmMagazineCmdAmmo4,

    e_abilArmMagazineCmdAmmo5,

    e_abilArmMagazineCmdAmmo6,

    e_abilArmMagazineCmdAmmo7,

    e_abilArmMagazineCmdAmmo8,

    e_abilArmMagazineCmdAmmo9,

    e_abilArmMagazineCmdAmmo10,

    e_abilArmMagazineCmdAmmo11,

    e_abilArmMagazineCmdAmmo12,

    e_abilArmMagazineCmdAmmo13,

    e_abilArmMagazineCmdAmmo14,

    e_abilArmMagazineCmdAmmo15,

    e_abilArmMagazineCmdAmmo16,

    e_abilArmMagazineCmdAmmo17,

    e_abilArmMagazineCmdAmmo18,

    e_abilArmMagazineCmdAmmo19,

    e_abilArmMagazineCmdAmmo20,

} EAbilArmMagazineCmd;

const int32 e_abilArmMagazineCmdCount = 20;

typedef enum
{
    e_abilAttackCmdExecute,

} EAbilAttackCmd;

const int32 e_abilAttackCmdCount = 1;

typedef enum
{
    e_abilAugmentCmdExecute,

} EAbilAugmentCmd;

const int32 e_abilAugmentCmdCount = 1;

typedef enum
{
    e_abilBatteryCmdExecute,

} EAbilBatteryCmd;

const int32 e_abilBatteryCmdCount = 1;

typedef enum
{
    e_abilBeaconCmdCancel,

    e_abilBeaconCmdMove,

} EAbilBeaconCmd;

const int32 e_abilBeaconCmdCount = 2;

typedef enum
{
    e_abilBehaviorCmdOn,

    e_abilBehaviorCmdOff,

} EAbilBehaviorCmd;

const int32 e_abilBehaviorCmdCount = 2;

typedef enum
{
    e_abilBuildCmdBuild1,

    e_abilBuildCmdBuild2,

    e_abilBuildCmdBuild3,

    e_abilBuildCmdBuild4,

    e_abilBuildCmdBuild5,

    e_abilBuildCmdBuild6,

    e_abilBuildCmdBuild7,

    e_abilBuildCmdBuild8,

    e_abilBuildCmdBuild9,

    e_abilBuildCmdBuild10,

    e_abilBuildCmdBuild11,

    e_abilBuildCmdBuild12,

    e_abilBuildCmdBuild13,

    e_abilBuildCmdBuild14,

    e_abilBuildCmdBuild15,

    e_abilBuildCmdBuild16,

    e_abilBuildCmdBuild17,

    e_abilBuildCmdBuild18,

    e_abilBuildCmdBuild19,

    e_abilBuildCmdBuild20,

    e_abilBuildCmdBuild21,

    e_abilBuildCmdBuild22,

    e_abilBuildCmdBuild23,

    e_abilBuildCmdBuild24,

    e_abilBuildCmdBuild25,

    e_abilBuildCmdBuild26,

    e_abilBuildCmdBuild27,

    e_abilBuildCmdBuild28,

    e_abilBuildCmdBuild29,

    e_abilBuildCmdBuild30,

    e_abilBuildCmdHalt,

} EAbilBuildCmd;

const int32 e_abilBuildCmdCount = 31;

typedef enum
{
    e_abilBuildableCmdCancel,

    e_abilBuildableCmdHalt,

} EAbilBuildableCmd;

const int32 e_abilBuildableCmdCount = 2;

typedef enum
{
    e_abilEffectInstantCmdExecute,

    e_abilEffectInstantCmdCancel,

} EAbilEffectInstantCmd;

const int32 e_abilEffectInstantCmdCount = 2;

typedef enum
{
    e_abilEffectTargetCmdExecute,

    e_abilEffectTargetCmdCancel,

} EAbilEffectTargetCmd;

const int32 e_abilEffectTargetCmdCount = 2;

typedef enum
{
    e_abilHarvestCmdGather,

    e_abilHarvestCmdReturn,

    e_abilHarvestCmdCancel,

} EAbilHarvestCmd;

const int32 e_abilHarvestCmdCount = 3;

typedef enum
{
    e_abilInteractCmdDesignate,

} EAbilInteractCmd;

const int32 e_abilInteractCmdCount = 1;

typedef enum
{
    e_abilInventoryCmdDrop,

    e_abilInventoryCmdMove,

    e_abilInventoryCmdTake,

    e_abilInventoryCmdItemInstant,

    e_abilInventoryCmdItemTarget,

    e_abilInventoryCmdItemCancel,

    e_abilInventoryCmdPawnInstant,

} EAbilInventoryCmd;

const int32 e_abilInventoryCmdCount = 7;

typedef enum
{
    e_abilLearnCmdLearn1,

    e_abilLearnCmdLearn2,

    e_abilLearnCmdLearn3,

    e_abilLearnCmdLearn4,

    e_abilLearnCmdLearn5,

    e_abilLearnCmdLearn6,

    e_abilLearnCmdLearn7,

    e_abilLearnCmdLearn8,

    e_abilLearnCmdLearn9,

    e_abilLearnCmdLearn10,

    e_abilLearnCmdLearn11,

    e_abilLearnCmdLearn12,

    e_abilLearnCmdLearn13,

    e_abilLearnCmdLearn14,

    e_abilLearnCmdLearn15,

    e_abilLearnCmdLearn16,

    e_abilLearnCmdLearn17,

    e_abilLearnCmdLearn18,

    e_abilLearnCmdLearn19,

    e_abilLearnCmdLearn20,

} EAbilLearnCmd;

const int32 e_abilLearnCmdCount = 20;

typedef enum
{
    e_abilMergeCmdSelectedUnits,

    e_abilMergeCmdWithTarget,

} EAbilMergeCmd;

const int32 e_abilMergeCmdCount = 2;

typedef enum
{
    e_abilMorphCmdExecute,

    e_abilMorphCmdCancel,

} EAbilMorphCmd;

const int32 e_abilMorphCmdCount = 2;

typedef enum
{
    e_abilMergeableCmdCancel,

} EAbilMergeableCmd;

const int32 e_abilMergeableCmdCount = 1;

typedef enum
{
    e_abilMoveCmdMove,

    e_abilMoveCmdPatrol,

    e_abilMoveCmdHoldPos,

    e_abilMoveCmdAcquireMove,

    e_abilMoveCmdTurn,

} EAbilMoveCmd;

const int32 e_abilMoveCmdCount = 5;

typedef enum
{
    e_abilPawnCmdPawn1,

    e_abilPawnCmdPawn2,

    e_abilPawnCmdPawn3,

    e_abilPawnCmdPawn4,

    e_abilPawnCmdPawn5,

    e_abilPawnCmdPawn6,

    e_abilPawnCmdPawn7,

    e_abilPawnCmdPawn8,

    e_abilPawnCmdPawn9,

    e_abilPawnCmdPawn10,

    e_abilPawnCmdPawn11,

    e_abilPawnCmdPawn12,

    e_abilPawnCmdPawn13,

    e_abilPawnCmdPawn14,

    e_abilPawnCmdPawn15,

    e_abilPawnCmdPawn16,

    e_abilPawnCmdPawn17,

    e_abilPawnCmdPawn18,

    e_abilPawnCmdPawn19,

    e_abilPawnCmdPawn20,

} EAbilPawnCmd;

const int32 e_abilPawnCmdCount = 20;

typedef enum
{
    e_abilQueueCmdCancelLast,

    e_abilQueueCmdCancelSlot,

} EAbilQueueCmd;

const int32 e_abilQueueCmdCount = 2;

typedef enum
{
    e_abilRallyCmdRally1,

    e_abilRallyCmdRally2,

    e_abilRallyCmdRally3,

    e_abilRallyCmdRally4,

} EAbilRallyCmd;

const int32 e_abilRallyCmdCount = 4;

typedef enum
{
    e_abilRedirectInstantCmdExecute,

} EAbilRedirectInstantCmd;

const int32 e_abilRedirectInstantCmdCount = 1;

typedef enum
{
    e_abilRedirectTargetCmdExecute,

} EAbilRedirectTargetCmd;

const int32 e_abilRedirectTargetCmdCount = 1;

typedef enum
{
    e_abilResearchCmdResearch1,

    e_abilResearchCmdResearch2,

    e_abilResearchCmdResearch3,

    e_abilResearchCmdResearch4,

    e_abilResearchCmdResearch5,

    e_abilResearchCmdResearch6,

    e_abilResearchCmdResearch7,

    e_abilResearchCmdResearch8,

    e_abilResearchCmdResearch9,

    e_abilResearchCmdResearch10,

    e_abilResearchCmdResearch11,

    e_abilResearchCmdResearch12,

    e_abilResearchCmdResearch13,

    e_abilResearchCmdResearch14,

    e_abilResearchCmdResearch15,

    e_abilResearchCmdResearch16,

    e_abilResearchCmdResearch17,

    e_abilResearchCmdResearch18,

    e_abilResearchCmdResearch19,

    e_abilResearchCmdResearch20,

    e_abilResearchCmdResearch21,

    e_abilResearchCmdResearch22,

    e_abilResearchCmdResearch23,

    e_abilResearchCmdResearch24,

    e_abilResearchCmdResearch25,

    e_abilResearchCmdResearch26,

    e_abilResearchCmdResearch27,

    e_abilResearchCmdResearch28,

    e_abilResearchCmdResearch29,

    e_abilResearchCmdResearch30,

} EAbilResearchCmd;

const int32 e_abilResearchCmdCount = 30;

typedef enum
{
    e_abilReviveCmdRevive1,

    e_abilReviveCmdRevive2,

    e_abilReviveCmdRevive3,

    e_abilReviveCmdRevive4,

    e_abilReviveCmdRevive5,

    e_abilReviveCmdRevive6,

    e_abilReviveCmdRevive7,

    e_abilReviveCmdRevive8,

    e_abilReviveCmdRevive9,

    e_abilReviveCmdRevive10,

    e_abilReviveCmdRevive11,

    e_abilReviveCmdRevive12,

    e_abilReviveCmdRevive13,

    e_abilReviveCmdRevive14,

    e_abilReviveCmdRevive15,

    e_abilReviveCmdRevive16,

    e_abilReviveCmdRevive17,

    e_abilReviveCmdRevive18,

    e_abilReviveCmdRevive19,

    e_abilReviveCmdRevive20,

    e_abilReviveCmdReviveAtTarget1,

    e_abilReviveCmdReviveAtTarget2,

    e_abilReviveCmdReviveAtTarget3,

    e_abilReviveCmdReviveAtTarget4,

    e_abilReviveCmdReviveAtTarget5,

    e_abilReviveCmdReviveAtTarget6,

    e_abilReviveCmdReviveAtTarget7,

    e_abilReviveCmdReviveAtTarget8,

    e_abilReviveCmdReviveAtTarget9,

    e_abilReviveCmdReviveAtTarget10,

} EAbilReviveCmd;

const int32 e_abilReviveCmdCount = 30;

typedef enum
{
    e_abilSpecializeCmdSpecialize1,

    e_abilSpecializeCmdSpecialize2,

    e_abilSpecializeCmdSpecialize3,

    e_abilSpecializeCmdSpecialize4,

    e_abilSpecializeCmdSpecialize5,

    e_abilSpecializeCmdSpecialize6,

    e_abilSpecializeCmdSpecialize7,

    e_abilSpecializeCmdSpecialize8,

    e_abilSpecializeCmdSpecialize9,

    e_abilSpecializeCmdSpecialize10,

    e_abilSpecializeCmdSpecialize11,

    e_abilSpecializeCmdSpecialize12,

    e_abilSpecializeCmdSpecialize13,

    e_abilSpecializeCmdSpecialize14,

    e_abilSpecializeCmdSpecialize15,

    e_abilSpecializeCmdSpecialize16,

    e_abilSpecializeCmdSpecialize17,

    e_abilSpecializeCmdSpecialize18,

    e_abilSpecializeCmdSpecialize19,

    e_abilSpecializeCmdSpecialize20,

} EAbilSpecializeCmd;

const int32 e_abilSpecializeCmdCount = 20;

typedef enum
{
    e_abilStopCmdStop,

    e_abilStopCmdHoldFire,

    e_abilStopCmdCheer,

    e_abilStopCmdDance,

} EAbilStopCmd;

const int32 e_abilStopCmdCount = 4;

typedef enum
{
    e_abilTrainCmdTrain1,

    e_abilTrainCmdTrain2,

    e_abilTrainCmdTrain3,

    e_abilTrainCmdTrain4,

    e_abilTrainCmdTrain5,

    e_abilTrainCmdTrain6,

    e_abilTrainCmdTrain7,

    e_abilTrainCmdTrain8,

    e_abilTrainCmdTrain9,

    e_abilTrainCmdTrain10,

    e_abilTrainCmdTrain11,

    e_abilTrainCmdTrain12,

    e_abilTrainCmdTrain13,

    e_abilTrainCmdTrain14,

    e_abilTrainCmdTrain15,

    e_abilTrainCmdTrain16,

    e_abilTrainCmdTrain17,

    e_abilTrainCmdTrain18,

    e_abilTrainCmdTrain19,

    e_abilTrainCmdTrain20,

    e_abilTrainCmdTrain21,

    e_abilTrainCmdTrain22,

    e_abilTrainCmdTrain23,

    e_abilTrainCmdTrain24,

    e_abilTrainCmdTrain25,

    e_abilTrainCmdTrain26,

    e_abilTrainCmdTrain27,

    e_abilTrainCmdTrain28,

    e_abilTrainCmdTrain29,

    e_abilTrainCmdTrain30,

} EAbilTrainCmd;

const int32 e_abilTrainCmdCount = 30;

typedef enum
{
    e_abilTransportCmdLoad,

    e_abilTransportCmdUnloadAll,

    e_abilTransportCmdUnloadAt,

    e_abilTransportCmdUnloadUnit,

    e_abilTransportCmdLoadAll,

} EAbilTransportCmd;

const int32 e_abilTransportCmdCount = 5;

typedef enum
{
    e_abilWarpableCmdCancel,

} EAbilWarpableCmd;

const int32 e_abilWarpableCmdCount = 1;

typedef enum
{
    e_abilWarpTrainCmdTrain1,

    e_abilWarpTrainCmdTrain2,

    e_abilWarpTrainCmdTrain3,

    e_abilWarpTrainCmdTrain4,

    e_abilWarpTrainCmdTrain5,

    e_abilWarpTrainCmdTrain6,

    e_abilWarpTrainCmdTrain7,

    e_abilWarpTrainCmdTrain8,

    e_abilWarpTrainCmdTrain9,

    e_abilWarpTrainCmdTrain10,

    e_abilWarpTrainCmdTrain11,

    e_abilWarpTrainCmdTrain12,

    e_abilWarpTrainCmdTrain13,

    e_abilWarpTrainCmdTrain14,

    e_abilWarpTrainCmdTrain15,

    e_abilWarpTrainCmdTrain16,

    e_abilWarpTrainCmdTrain17,

    e_abilWarpTrainCmdTrain18,

    e_abilWarpTrainCmdTrain19,

    e_abilWarpTrainCmdTrain20,

} EAbilWarpTrainCmd;

const int32 e_abilWarpTrainCmdCount = 20;

struct SAbilCmdButton
{
    CButtonLink DefaultButtonFace;

    CAbilCmdFlags Flags;

    EAbilCmdState State;

    const CTechRequirementsGraph* Requirements;
};

struct SAbilOrderDisplay
{
    CColor Color;

    CModelPath Model;

    CFixed Scale;

    CImagePath LineTexture;
};

struct SAbilQueueableInfo : SCost
{
    SAbilCmdButton Button;

    CGameTime Time;

    CAlertLink Alert;
};

struct SAbilArmMagazineInfo : SAbilQueueableInfo
{
    uint32 Count;

    uint32 CountStart;

    CFixed Distance;

    CFlags Flags;

    EAbilArmMagazineManage Manage;

    CUnitLink Unit;
};

struct SAbilBuildInfo : SCost
{
    SAbilCmdButton Button;

    CUnitLink Unit;

    CGameTime Delay;

    CGameTime Time;

    CAlertLink Alert;

    std::vector<CValidatorLink> ValidatorArray;

    int32 AddOnParentCmdPriority;
};

struct SAbilInventoryInfo : SItemContainer
{
    EAbilInventoryAlignment Alignment;

    CItemContainerLink Container;

    CUnitLink Item;
};

struct SAbilLearnInfo : SAbilQueueableInfo
{
    CAbilLink Abil;
};

struct SAbilMergeInfo : SCost
{
    CUnitLink Unit;

    CGameTime Time;
};

struct SAbilMorphSection
{
    std::vector<CGameTime> DurationArray;

    std::vector<CEffectLink> EffectArray;
};

struct SAbilMorphInfo
{
    flag8 Score;

    CUnitLink Unit;

    CFixed CollideRange;

    std::vector<SAbilMorphSection> SectionArray;

    EAbilMorphPhase RallyResetPhase;

    EAbilMorphSection RallyResetSection;

    CGameTime RandomDelayMin;

    CGameTime RandomDelayMax;
};

struct SAbilPawnInfo : SCost
{
    SAbilCmdButton Button;

    CItemClassLink ClassRequired;

    std::vector<CItemClassLink> ClassesExcluded;

    std::vector<CFixed> RefundFraction;

    CTargetFilters TargetFilters;

    std::vector<CValidatorLink> ValidatorArray;
};

struct SAbilRallyInfo
{
    flag8 SetOnGround;

    CTargetFilters SetFilters;

    std::vector<CValidatorLink> SetValidators;

    CTargetFilters UseFilters;

    std::vector<CValidatorLink> UseValidators;
};

struct SAbilResearchInfo : SAbilQueueableInfo
{
    CUpgradeLink Upgrade;
};

struct SAbilReviveInfo : SCost
{
    CGameTime Time;

    CAlertLink Alert;
};

struct SAbilSpecializeInfo : SAbilQueueableInfo
{
    CEffectLink Effect;

    CFlags Flags;
};

struct SAbilTrainInfo : SAbilQueueableInfo
{
    std::vector<CUnitLink> Unit;

    CEffectLink Effect;

    EAbilTrainLocation Location;

    EAbilTrainRotation Rotation;

    CFlags Flags;
};

struct SAbilWarpTrainInfo : SAbilQueueableInfo
{
    CUnitLink Unit;
};

class CAbil
{
public:
    CStringLink Name;

    EAbilTechPlayer TechPlayer;

    EAbilAlignment Alignment;

    std::vector<SAbilOrderDisplay> OrderArray;

    CAbilSetId AbilSetId;

    TEditorCategories EditorCategories;

    uint32 InfoTooltipPriority;

    CStringLink TargetMessage;

    std::vector<TTechAlias> TechAliasArray;

    CFlagArray<e_abilSharedFlagCount> SharedFlags;
};

class CAbilProgress : CAbil
{
public:
    CStringLink Activity;

    flag8 Cancelable;

    std::vector<CFixed> VitalStartFactor;
};

class CAbilEffect : CAbil
{
public:
    CStringLink Activity;

    std::vector<CEffectLink> Effect;

    CFlags Flags;

    std::vector<SCost> Cost;

    std::vector<SCost> CancelCost;

    CFlagArray<e_abilEffectStageCount> RefundArray;

    SCostFactor RefundFraction;

    CUnitLink Placeholder;

    std::vector<CTargetFilters> TargetFilters;

    STargetSorts TargetSorts;

    std::vector<CFixed> Range;

    CFixed RangeSlop;

    CFangleArc Arc;

    CFangleArc ArcSlop;

    CFangleArc TrackingArc;

    uint32 SmartPriority;

    std::vector<CValidatorLink> SmartValidatorArray;

    EAcquireLevel AutoCastAcquireLevel;

    CTargetFilters AutoCastFilters;

    CFixed AutoCastRange;

    std::vector<CValidatorLink> AutoCastValidatorArray;

    std::vector<CGameTime> PrepTime;

    std::vector<CGameTime> CastIntroTime;

    std::vector<CGameTime> CastOutroTime;

    std::vector<CGameTime> FinishTime;

    SMarker Marker;

    CFlagArray<e_abilEffectStageCount> UseMarkerArray;

    CFlagArray<e_abilEffectStageCount> ShowProgressArray;

    CFlagArray<e_abilEffectStageCount> CancelableArray;

    CFlagArray<e_abilEffectStageCount> PauseableArray;

    CFlagArray<e_abilEffectStageCount> PreemptableArray;

    CFlagArray<e_abilEffectStageCount> UninterruptibleArray;

    CFlagArray<e_abilEffectStageCount> ValidatedArray;

    CFlagArray<e_abilEffectStageCount> InheritAttackPriorityArray;

    CAlertLink ErrorAlert;

    std::vector<CAlertLink> AlertArray;

    std::vector<CEffectLink> CursorEffect;

    CEffectLink CalldownEffect;

    CEffectLink AINotifyEffect;

    std::vector<CUnitLink> ProducedUnitArray;

    std::vector<CButtonLink> ProgressButtonArray;

    CCmdResult DefaultError;

    std::vector<CImagePath> LevelButtonImage;

    std::vector<CStringLink> LevelButtonName;

    std::vector<CStringLink> LevelButtonTooltip;

    std::vector<CImagePath> LevelButtonTooltipImage;

    std::vector<CfRange> EffectRange;

    std::vector<CImagePath> LearnButtonImage;

    std::vector<CStringLink> LearnButtonName;

    std::vector<CStringLink> LearnButtonTooltip;

    std::vector<CImagePath> LearnButtonTooltipImage;

    CTargetFilters IgnoreFilters;
};

class CAbilQueueable : CAbil
{
public:
    SCostFactor RefundFraction;

    CAlertLink ErrorAlert;

    CStringLink Activity;
};

class CAbilRedirect : CAbil
{
public:
    CAbilLink Abil;

    TAbilCmdIndex Index;

    CFlags Flags;
};

class CAbilArmMagazine : CAbilQueueable
{
public:
    EAbilArmMagazineLaunch Launch;

    CFlags Flags;

    CFixed Leash;

    std::vector<SAbilArmMagazineInfo> InfoArray;

    CAlertLink Alert;

    std::vector<CEffectLink> EffectArray;

    CFixed ReturnLifeFraction;

    CEffectLink CalldownEffect;

    std::vector<CFangle> ExternalAngle;

    uint32 MaxCount;
};

class CAbilAttack : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CTargetFilters AcquireFilters;

    CTargetFilters SmartFilters;

    uint32 SmartPriority;

    CTargetFilters SupportedFilters;

    CFixed MinAttackSpeedMultiplier;

    CFixed MaxAttackSpeedMultiplier;
};

class CAbilAugment : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;

    CAbilCommand AbilCmd;

    EEffectLocationType TargetType;

    SCost Cost;

    CEffectLink Effect;

    CTargetFilters AutoCastFilters;

    std::vector<CValidatorLink> AutoCastValidatorArray;

    uint32 SmartPriority;

    std::vector<CValidatorLink> SmartValidatorArray;
};

class CAbilBattery : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CTargetFilters TargetFilters;

    CFixed Range;

    CTargetFilters EnumFilters;

    CFixed EnumRange;

    CEffectLink Effect;

    uint32 SmartPriority;
};

class CAbilBeacon : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    uint32 SmartPriority;
};

class CAbilBehavior : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;

    std::vector<SCost> Cost;

    std::vector<CBehaviorLink> BehaviorArray;

    std::vector<CValidatorLink> ValidatorArray;

    std::vector<CValidatorLink> AutoCastValidatorArray;

    std::vector<CImagePath> LevelButtonOnImage;

    std::vector<CStringLink> LevelButtonOnName;

    std::vector<CStringLink> LevelButtonOnTooltip;

    std::vector<CImagePath> LevelButtonOnTooltipImage;

    std::vector<CImagePath> LevelButtonOffImage;

    std::vector<CStringLink> LevelButtonOffName;

    std::vector<CStringLink> LevelButtonOffTooltip;

    std::vector<CImagePath> LevelButtonOffTooltipImage;

    std::vector<CImagePath> LearnButtonImage;

    std::vector<CStringLink> LearnButtonName;

    std::vector<CStringLink> LearnButtonTooltip;

    std::vector<CImagePath> LearnButtonTooltipImage;
};

class CAbilBuild : CAbil
{
public:
    SAbilCmdButton HaltCmdButton;

    CAbilLink BuildMorphAbil;

    CAbilLink UnlinkMorphAbil;

    CFlagArray<e_abilBuildFlagCount> FlagArray;

    CAlertLink Alert;

    CAlertLink ErrorAlert;

    std::vector<SAbilBuildInfo> InfoArray;

    EAbilBuildType Type;

    CFixed Range;

    SCostFactor RefundFraction;

    CGameTime FidgetDelayMin;

    CGameTime FidgetDelayMax;

    CMoverLink ConstructionMover;

    std::vector<CEffectLink> EffectArray;

    uint32 SmartPriority;
};

class CAbilBuildable : CAbilProgress
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    uint32 MaxBuilders;

    CFixed PowerBuildBonusRate;

    CFixed PowerBuildCostFactor;
};

class CAbilEffectInstant : CAbilEffect
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;
};

class CAbilEffectTarget : CAbilEffect
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CUnitLink PlaceUnit;

    flag8 AcquireAttackers;

    CFixed FollowRange;

    CAbilCommand FinishCommand;
};

class CAbilHarvest : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlagArray<e_abilHarvestFlagCount> FlagArray;

    CFixed Range;

    CFixed AcquireRadius;

    SMarker ReservedMarker;

    CFlagArray<e_resourceTypeCount> ResourceAcquire;

    CFlagArray<e_resourceTypeCount> ResourceAllowed;

    CFlagArray<e_resourceTypeCount> ResourceDestroy;

    std::vector<uint32> ResourceAmountBonus;

    std::vector<CFixed> ResourceAmountMultiplier;

    std::vector<uint32> ResourceAmountRequest;

    std::vector<CGameTime> ResourceTimeBonus;

    std::vector<CFixed> ResourceTimeMultiplier;

    CFlagArray<e_abilHarvestStageCount> CancelableArray;

    CFlagArray<e_abilHarvestStageCount> UninterruptibleArray;

    uint32 SmartPriority;
};

class CAbilInteract : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;

    CFixed Range;

    CTargetFilters TargetFilters;

    std::vector<CValidatorLink> ValidatorArray;

    uint32 SmartPriority;

    std::vector<CValidatorLink> SmartValidatorArray;

    CTargetFilters AutoCastFilters;

    CFixed AutoCastRange;

    std::vector<CValidatorLink> AutoCastValidatorArray;
};

class CAbilInventory : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;

    CTargetFilters TargetFilters;

    std::vector<CValidatorLink> ValidatorArray;

    CFixed Range;

    CFixed MaxDropRange;

    std::vector<SAbilInventoryInfo> InfoArray;

    uint32 SmartPriority;
};

class CAbilLearn : CAbilQueueable
{
public:
    std::vector<SAbilLearnInfo> InfoArray;

    CFlags Flags;

    uint32 Points;

    uint32 PointsPerLevel;
};

class CAbilMerge : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;

    CAlertLink Alert;

    CEffectLink Effect;

    SAbilMergeInfo Info;

    CFixed Range;
};

class CAbilMergeable : CAbilProgress
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;
};

class CAbilMorph : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CDataSoupKey ActorKey;

    CFlags Flags;

    SCostFactor RefundFraction;

    SCost Cost;

    CUnitLink CancelUnit;

    std::vector<SAbilMorphInfo> InfoArray;

    CAlertLink StartGlobalAlert;

    CAlertLink FinishGlobalAlert;

    CAlertLink Alert;

    CAlertLink ErrorAlert;

    EAcquireLevel AutoCastAcquireLevel;

    CTargetFilters AutoCastFilters;

    std::vector<CValidatorLink> AutoCastValidatorArray;

    CFixed AutoCastRange;

    uint32 AutoCastCountMin;

    uint32 AutoCastCountMax;

    CStringLink Activity;

    std::vector<CValidatorLink> ValidatorArray;

    CFlagArray<e_classIdCAbilCount> AbilClassEnableArray;

    CFlagArray<e_classIdCAbilCount> AbilClassDisableArray;

    std::vector<CAbilLink> AbilLinkEnableArray;

    std::vector<CAbilLink> AbilLinkDisableArray;

    CButtonLink ProgressButton;
};

class CAbilMorphPlacement : CAbilMorph
{
public:
};

class CAbilMove : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFixed FleeRange;

    CGameTime FleeTime;

    CFixed FollowRangeSlop;

    CFixed FollowAcquireRange;

    CFixed MinPatrolDistance;

    CTargetFilters FollowFilters;

    CTargetFilters MoveFilters;

    CFlags Flags;

    uint32 MoveSmartPriority;

    uint32 BoardBunkerSmartPriority;

    uint32 BoardTransportSmartPriority;

    uint32 PowerupSmartPriority;

    uint32 RechargeSmartPriority;
};

class CAbilPawn : CAbil
{
public:
    std::vector<SAbilPawnInfo> InfoArray;

    CFlags Flags;

    CFixed Range;
};

class CAbilQueue : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    uint32 QueueCount;

    uint32 QueueSize;

    CFlags Flags;
};

class CAbilRally : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    std::vector<SAbilRallyInfo> InfoArray;

    CFlags Flags;

    uint32 SmartPriority;
};

class CAbilRedirectInstant : CAbilRedirect
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;
};

class CAbilRedirectTarget : CAbilRedirect
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;
};

class CAbilResearch : CAbilQueueable
{
public:
    std::vector<SAbilResearchInfo> InfoArray;

    CFlags Flags;
};

class CAbilRevive : CAbilQueueable
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;

    SAbilReviveInfo BaseInfo;

    SAbilReviveInfo LevelInfo;

    SCostFactor BaseUnitCostFactor;

    SCostFactor LevelUnitCostFactor;

    CDataSoupKey ActorKey;

    CEffectLink Effect;

    std::vector<CGamePoint> Offset;

    CFixed Range;

    std::vector<EAbilReviveVital> VitalArray;

    CAlertLink Alert;

    CStringLink NameOverride;

    CTargetFilters ReplaceFilters;

    EDeathType ReplaceDeathType;

    EAbilReviveCmd SelfReviveCmd;

    std::vector<CValidatorLink> ValidatorArray;

    EEffectLocationType TargetType;
};

class CAbilSpecialize : CAbilQueueable
{
public:
    std::vector<SAbilSpecializeInfo> InfoArray;

    uint32 MaxCount;

    CAlertLink Alert;

    CFlags Flags;
};

class CAbilStop : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;
};

class CAbilTrain : CAbilQueueable
{
public:
    CDataSoupKey ActorKey;

    CFlags Flags;

    CUnitLink MorphUnit;

    std::vector<CGamePoint> Offset;

    CFixed Range;

    std::vector<SAbilTrainInfo> InfoArray;

    CAlertLink Alert;

    std::vector<CGamePoint> ProxyOffset;

    CUnitLink ProxyUnit;
};

class CAbilTransport : CAbil
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CFlags Flags;

    CFixed Range;

    CFixed MaxUnloadRange;

    uint32 MaxCargoCount;

    TCargoSize MaxCargoSize;

    TCargoCapacity TotalCargoSpace;

    CBehaviorLink LoadCargoBehavior;

    CEffectLink LoadCargoEffect;

    CEffectLink LoadTransportEffect;

    CBehaviorLink LoadTransportBehavior;

    CBehaviorLink UnloadCargoBehavior;

    CEffectLink UnloadCargoEffect;

    CEffectLink UnloadTransportEffect;

    CBehaviorLink UnloadTransportBehavior;

    CGameTime InitialLoadDelay;

    CGameTime InitialUnloadDelay;

    CGameTime LoadPeriod;

    CGameTime UnloadPeriod;

    CTargetFilters TargetFilters;

    CFixed SearchRadius;

    std::vector<CValidatorLink> LoadValidatorArray;

    std::vector<CValidatorLink> UnloadValidatorArray;

    STargetSorts TargetSorts;

    CEffectLink CalldownEffect;

    CEffectLink DeathUnloadEffect;

    CAlertLink ErrorAlert;

    uint32 LoadSmartPriority;
};

class CAbilWarpable : CAbilProgress
{
public:
    std::vector<SAbilCmdButton> CmdButtonArray;

    CBehaviorLink PowerUserBehavior;
};

class CAbilWarpTrain : CAbil
{
public:
    std::vector<SAbilWarpTrainInfo> InfoArray;

    CAlertLink Alert;

    SCostFactor RefundFraction;

    CFlags Flags;
};

#endif // ABIL_H