Actor.h

Go to the documentation of this file.

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

#ifndef ACTOR_H
#define ACTOR_H

#include "UnderlyingTypes.h"
#include "Game.h"
#include "ActorSupport.h"
#include "AttachMethod.h"
#include "Error.h"
#include "Model.h"

typedef enum
{
    e_classIdCActor,

    e_classIdCActorBase,

    e_classIdCActorBearings,

    e_classIdCActorCamera,

    e_classIdCActorModel,

    e_classIdCActorQuad,

    e_classIdCActorForce,

    e_classIdCActorForceLineSegment,

    e_classIdCActorBeam,

    e_classIdCActorRange,

    e_classIdCActorRegion,

    e_classIdCActorSite,

    e_classIdCActorSiteOp,

    e_classIdCActorSiteOpBase,

    e_classIdCActorSound,

    e_classIdCActorSplat,

    e_classIdCActorAction,

    e_classIdCActorArc,

    e_classIdCActorBeamSimple,

    e_classIdCActorBeamStandard,

    e_classIdCActorCameraModel,

    e_classIdCActorCreep,

    e_classIdCActorDoodad,

    e_classIdCActorDoodadPreserver,

    e_classIdCActorFoliageFXSpawner,

    e_classIdCActorEditorCamera,

    e_classIdCActorEditorPoint,

    e_classIdCActorEventMacro,

    e_classIdCActorForceBox,

    e_classIdCActorForceConeRoundedEnd,

    e_classIdCActorForceCylinder,

    e_classIdCActorForceSphere,

    e_classIdCActorGlobalConfig,

    e_classIdCActorLight,

    e_classIdCActorLightOmni,

    e_classIdCActorLightSpot,

    e_classIdCActorLightModel,

    e_classIdCActorLightOmniModel,

    e_classIdCActorLightSpotModel,

    e_classIdCActorLookAt,

    e_classIdCActorList,

    e_classIdCActorPortrait,

    e_classIdCActorPower,

    e_classIdCActorProgress,

    e_classIdCActorPropertyCurveSet,

    e_classIdCActorQueryResponse,

    e_classIdCActorRegionArc,

    e_classIdCActorRegionCircle,

    e_classIdCActorRegionCombine,

    e_classIdCActorRegionGame,

    e_classIdCActorRegionPolygon,

    e_classIdCActorRegionQuad,

    e_classIdCActorRegionWater,

    e_classIdCActorScene,

    e_classIdCActorSelection,

    e_classIdCActorSetQueried,

    e_classIdCActorShadow,

    e_classIdCActorShield,

    e_classIdCActorShieldImpact,

    e_classIdCActorSimple,

    e_classIdCActorSiteBillboard,

    e_classIdCActorSiteMover,

    e_classIdCActorSiteRocker,

    e_classIdCActorSiteOp2DRotation,

    e_classIdCActorSiteOpAction,

    e_classIdCActorSiteOpAttach,

    e_classIdCActorSiteOpAttachVolume,

    e_classIdCActorSiteOpBanker,

    e_classIdCActorSiteOpBankerUnit,

    e_classIdCActorSiteOpBasic,

    e_classIdCActorSiteOpDeathMotion,

    e_classIdCActorSiteOpEffect,

    e_classIdCActorSiteOpForward,

    e_classIdCActorSiteOpHeight,

    e_classIdCActorSiteOpHigherOfTerrainAndWater,

    e_classIdCActorSiteOpHostBearings,

    e_classIdCActorSiteOpHostedOffset,

    e_classIdCActorSiteOpIncoming,

    e_classIdCActorSiteOpLocalOffset,

    e_classIdCActorSiteOpPatch,

    e_classIdCActorSiteOpPhysicsImpact,

    e_classIdCActorSiteOpRandomPointInCircle,

    e_classIdCActorSiteOpRandomPointInCrossbar,

    e_classIdCActorSiteOpRandomPointInSphere,

    e_classIdCActorSiteOpRotationExplicit,

    e_classIdCActorSiteOpRotationRandom,

    e_classIdCActorSiteOpRotationVariancer,

    e_classIdCActorSiteOpRotator,

    e_classIdCActorSiteOpRotationSmooth,

    e_classIdCActorSiteOpSelectionOffset,

    e_classIdCActorSiteOpSerpentHead,

    e_classIdCActorSiteOpSerpentSegment,

    e_classIdCActorSiteOpShadow,

    e_classIdCActorSiteOpTipability,

    e_classIdCActorSiteOpUp,

    e_classIdCActorSiteOpZ,

    e_classIdCActorSnapshot,

    e_classIdCActorStateMonitor,

    e_classIdCActorSquib,

    e_classIdCActorTerrain,

    e_classIdCActorTerrainDeformer,

    e_classIdCActorText,

    e_classIdCActorTurret,

    e_classIdCActorUnit,

    e_classIdCActorMissile,

} EClassIdCActor;

const int32 e_classIdCActorCount = 105;

typedef enum
{
    e_actorBaselineStand,

    e_actorBaselineWalk,

} EActorBaselineType;

const int32 e_actorBaselineCount = 2;

typedef enum
{
    e_actorBaselinePhaseStandIntro,

    e_actorBaselinePhaseStand,

    e_actorBaselinePhaseWalkIntro,

    e_actorBaselinePhaseWalk,

    e_actorBaselinePhaseWalkOutro,

} EActorBaselinePhase;

const int32 e_actorBaselinePhaseCount = 5;

typedef enum
{
    e_actorFlagAddToExternalFinder,

    e_actorFlagSuppressCreationErrors,

    e_actorFlagSuppressSaveLoad,

} EActorFlag;

const int32 e_actorFlagCount = 3;

typedef enum
{
    e_actorDoodadFlagPauseAnimsWhileFogged,

    e_actorDoodadFlagFootprintOnly,

} EActorDoodadFlag;

const int32 e_actorDoodadFlagCount = 2;

typedef enum
{
    e_actorScopeBearingsTrackingAutomaticBySituation,

    e_actorScopeBearingsTrackingForceOn,

    e_actorScopeBearingsTrackingForceOff,

} EActorScopeBearingsTrackingType;

const int32 e_actorScopeBearingsTrackingCount = 3;

typedef enum
{
    e_actorModelFlagAllowHitTest,

    e_actorModelFlagAutomateGlobalLoops,

    e_actorModelFlagIgnoreWalkables,

    e_actorModelFlagNeedsVolumeMonitoring,

    e_actorModelFlagSuppressMissingAttachErrors,

    e_actorModelFlagSuppressPlayerDecals,

    e_actorModelFlagUpdateVisibility,

    e_actorModelFlagUseConstSyncSeed,

    e_actorModelFlagUseSyncSeed,

    e_actorModelFlagWireframeRender,

} EActorModelFlag;

const int32 e_actorModelFlagCount = 10;

typedef enum
{
    e_actorSelectionFlagIsSyncSelection,

    e_actorSelectionFlagIsFlash,

    e_actorSelectionFlagUseCheapQuadSplat,

    e_actorSelectionFlagUseCrescent,

} EActorSelectionFlag;

const int32 e_actorSelectionFlagCount = 4;

typedef enum
{
    e_actorUnitFlagShowBlobShadow,

    e_actorUnitFlagStandAnimBirthVariation,

    e_actorUnitFlagSuppressCreationErrors,

    e_actorUnitFlagSuppressStandIntro,

    e_actorUnitFlagSuppressWalkIntro,

    e_actorUnitFlagSuppressWalkOutro,

    e_actorUnitFlagSuppressDefaultStatusBar,

} EActorUnitFlag;

const int32 e_actorUnitFlagCount = 7;

typedef enum
{
    e_actorRequestCreateSharingNone,

    e_actorRequestCreateSharingAlways,

    e_actorRequestCreateSharingPerEffectTree,

} EActorRequestCreateSharing;

const int32 e_actorRequestCreateSharingCount = 3;

typedef enum
{
    e_actorSplatHeightNormal,

    e_actorSplatHeightMinimumActor,

    e_actorSplatHeightMinimumTerrain,

} EActorSplatHeight;

const int32 e_actorSplatHeightCount = 3;

typedef enum
{
    e_actorEffectLocationOriginUnit,

    e_actorEffectLocationOriginPoint,

    e_actorEffectLocationOriginUnitOrPoint,

    e_actorEffectLocationCasterUnit,

    e_actorEffectLocationCasterPoint,

    e_actorEffectLocationCasterUnitOrPoint,

    e_actorEffectLocationSourceUnit,

    e_actorEffectLocationSourcePoint,

    e_actorEffectLocationSourceUnitOrPoint,

    e_actorEffectLocationMissileUnitOrPoint,

    e_actorEffectLocationTargetUnit,

    e_actorEffectLocationTargetPoint,

    e_actorEffectLocationTargetUnitOrPoint,

    e_actorEffectLocationOuterUnit,

    e_actorEffectLocationOuterPoint,

    e_actorEffectLocationOuterUnitOrPoint,

} EActorEffectLocation;

const int32 e_actorEffectLocationCount = 16;

typedef enum
{
    e_actorHostedPropInheritNone,

    e_actorHostedPropInheritOneShot,

    e_actorHostedPropInheritContinuous,

} EActorHostedPropInheritType;

const int32 e_actorHostedPropInheritCount = 3;

typedef enum
{
    e_actorSiteOpBillboardUnobstructable,

    e_actorSiteOpBillboardUseTowardsCameraDistance,

} EActorSiteBillboardType;

const int32 e_actorSiteOpBillboardCount = 2;

typedef enum
{
    e_actorSiteOpActionCenter,

    e_actorSiteOpActionImpact,

    e_actorSiteOpActionLaunch,

} EActorSiteOpActionLocation;

const int32 e_actorSiteOpActionCount = 3;

typedef enum
{
    e_actorSiteOpAttachSourceAutomatic,

    e_actorSiteOpAttachSourceChain,

    e_actorSiteOpAttachSourceHost,

} EActorSiteOpAttachSource;

const int32 e_actorSiteOpAttachSourceCount = 3;

typedef enum
{
    e_actorSiteOpBasicWorldPosition,

    e_actorSiteOpBasicActorBearings,

    e_actorSiteOpBasicActorPosition,

    e_actorSiteOpBasicCreatorBearings,

    e_actorSiteOpBasicCreatorPosition,

    e_actorSiteOpBasicInitialBearings,

    e_actorSiteOpBasicScopeBearings,

    e_actorSiteOpBasicScopePosition,

} EActorSiteOpBasicType;

const int32 e_actorSiteOpBasicCount = 8;

typedef enum
{
    e_actorSiteOpPhysicsImpactNormal,

} EActorSiteOpPhysicsImpactType;

const int32 e_actorSiteOpPhysicsImpactCount = 1;

typedef enum
{
    e_actorSiteOpTerrainAndWaterFlagFollowWaves,

    e_actorSiteOpTerrainAndWaterFlagPassThroughIfNoWater,

} EActorSiteOpTerrainAndWaterFlag;

const int32 e_actorSiteOpTerrainAndWaterFlagCount = 2;

typedef enum
{
    e_actorSiteOpRotatorAccumulateAndSetRotation,

    e_actorSiteOpRotatorAddRotationChange,

} EActorSiteOpRotatorType;

const int32 e_actorSiteOpRotatorCount = 2;

typedef enum
{
    e_actorSiteOpTipabilityFlagNoLowerThanBaseHeight,

    e_actorSiteOpTipabilityFlagNoLowerThanScope,

} EActorSiteOpTipabilityFlag;

const int32 e_actorSiteOpTipabilityFlagCount = 2;

typedef enum
{
    e_actorRadialDistributionUniform,

    e_actorRadialDistributionExponential,

    e_actorRadialDistributionGaussian,

} EActorRadialDistribution;

const int32 e_actorRadialDistributionCount = 3;

typedef enum
{
    e_actorCrossbarDistributionUniform,

    e_actorCrossbarDistributionGaussian,

    e_actorCrossbarDistributionGaussianInverse,

} EActorCrossbarDistribution;

const int32 e_actorCrossbarDistributionCount = 3;

typedef enum
{
    e_actorShieldFlashTypeFacer,

    e_actorShieldFlashTypeFull,

    e_actorShieldFlashTypeHeader,

    e_actorShieldFlashTypeNone,

} EActorShieldFlashType;

const int32 e_actorShieldFlashTypeCount = 4;

typedef enum
{
    e_actorTransferFlagAnimator,

    e_actorTransferFlagAnimProps,

    e_actorTransferFlagFOWColor,

    e_actorTransferFlagFOWShader,

    e_actorTransferFlagModel,

    e_actorTransferFlagPosition,

    e_actorTransferFlagRotation,

    e_actorTransferFlagTextures,

    e_actorTransferFlagStatus,

} EActorTransferFlag;

const int32 e_actorTransferFlagCount = 9;

typedef enum
{
    e_actorTextAlignmentLeft,

    e_actorTextAlignmentTop,

    e_actorTextAlignmentCenter,

    e_actorTextAlignmentRight,

    e_actorTextAlignmentBottom,

} EActorTextAlignment;

const int32 e_actorTextAlignmentCount = 5;

typedef enum
{
    e_actorTextOptionConformToTerrain,

    e_actorTextOptionUseTerrainHeight,

    e_actorTextOptionUseWalkableHeight,

} EActorTextOption;

const int32 e_actorTextOptionCount = 3;

typedef enum
{
    e_actorOff,

    e_actorOn,

} EActorOnOffType;

const int32 e_actorCount = 2;

typedef enum
{
    e_actorActionFlagAlignedImpactsAndDamages,

    e_actorActionFlagIgnoresShields,

    e_actorActionFlagImpactForceSite,

    e_actorActionFlagLaunchForceSite,

    e_actorActionFlagVictimRevealsAttacker,

} EActorActionFlag;

const int32 e_actorActionFlagCount = 5;

typedef enum
{
    e_actorRangeFlagGameWorld,

    e_actorRangeFlagMinimap,

} EActorRangeFlag;

const int32 e_actorRangeFlagCount = 2;

typedef enum
{
    e_actorRegionFlagUseEffectRange,

} EActorRegionFlag;

const int32 e_actorRegionFlagCount = 1;

typedef enum
{
    e_actorHeightSourceAsyncFast,

    e_actorHeightSourceAsyncPrecise,

    e_actorHeightSourceSyncAir,

    e_actorHeightSourceSyncGround,

} EActorHeightSourceType;

const int32 e_actorHeightSourceCount = 4;

typedef enum
{
    e_actorHeightTestAverage,

    e_actorHeightTestHighest,

    e_actorHeightTestLowest,

} EActorHeightTestType;

const int32 e_actorHeightTestCount = 3;

typedef enum
{
    e_actorIncomingDirect,

    e_actorIncomingMissile,

} EActorIncomingType;

const int32 e_actorIncomingCount = 2;

typedef enum
{
    e_actorSoundFlagUpdateVisibility,

} EActorSoundFlag;

const int32 e_actorSoundFlagCount = 1;

typedef enum
{
    e_actorTerrainDeformerFlagDestroysFoliage,

    e_actorTerrainDeformerFlagUseUnitFootprint,

    e_actorTerrainDeformerFlagRestoreOnHidden,

    e_actorTerrainDeformerFlagRestoreOnMovement,

    e_actorTerrainDeformerFlagRestoreOnDestroy,

} EActorTerrainDeformerFlag;

const int32 e_actorTerrainDeformerFlagCount = 5;

typedef enum
{
    e_unitStatusGroupOwner,

    e_unitStatusGroupAllied,

    e_unitStatusGroupEnemy,

    e_unitStatusGroupAll,

    e_unitStatusGroupReplay,

} EUnitStatusGroup;

const int32 e_unitStatusGroupCount = 5;

typedef enum
{
    e_actorProximityCenterActor,

    e_actorProximityCenterModelBounds,

} EActorProximity;

const int32 e_actorProximityCount = 2;

typedef enum
{
    e_actorForceFlagFallOff,

    e_actorForceFlagStacks,

} EActorForceFlag;

const int32 e_actorForceFlagCount = 2;

typedef enum
{
    e_actorForceFieldDirectional,

    e_actorForceFieldRadial,

} EActorForceField;

const int32 e_actorForceFieldCount = 2;

typedef enum
{
    e_actorForceDirectionUp,

    e_actorForceDirectionForward,

} EActorForceDirection;

const int32 e_actorForceDirectionCount = 2;

typedef enum
{
    e_actorForceOriginAtBottom,

    e_actorForceOriginAtCenter,

} EActorForceOrigin;

const int32 e_actorForceOriginCount = 2;

typedef enum
{
    e_actorCombatRevealDurationOneShot,

    e_actorCombatRevealDurationByVictim,

} EActorCombatRevealDurationType;

const int32 e_actorCombatRevealDurationCount = 2;

typedef enum
{
    e_serpentBasic,

    e_serpentSwimming,

} ESerpentType;

const int32 e_serpentCount = 2;

typedef enum
{
    e_actorSerpentFlagUseAttachDistances,

} ESerpentFlag;

const int32 e_actorSerpentFlagCount = 1;

typedef enum
{
    e_actorTerrainSquibVisualFlagOneShot,

} EActorTerrainSquibVisualFlag;

const int32 e_actorTerrainSquibVisualFlagCount = 1;

typedef enum
{
    e_minimapShapeQuad,

    e_minimapShapeCircle,

} EMinimapShape;

const int32 e_minimapShapeCount = 2;

struct SActorRequest
{
    CRefKey Subject;

    EActorRequestScope Scope;

    EActorRequestActor Actor;

    CEffectLink Effect;

    flag8 FailOnNoHost;
};

struct SActorEvent
{
    CActorTerms Terms;

    CRefKey Target;

    CActorMsgPayloadPtr Send;
};

struct SActorSiteOpsData
{
    CActorSiteOps Ops;

    flag8 HoldPosition;

    flag8 HoldRotation;
};

struct SActorHostedAttach
{
    CActorLabelKey Name;

    SAttachQuery AttachQuery;

    SActorRequest Host;

    SActorSiteOpsData HostSiteOps;
};

struct SActorBaseline
{
    CAnimProps AnimProps;

    real32 BlendIn;

    real32 BlendOut;
};

struct SActorAVPair
{
    CModelLink Model;

    CScaleVector Scale;

    CAnimProps AnimProps;

    CSoundLink Sound;
};

struct SActorAVCluster : SActorAVPair
{
    CModelLink ModelReaction;

    CAnimProps AnimPropsReaction;

    CScaleVector ScaleReaction;
};

struct SActorActionTerrainSquib : SActorAVPair
{
    CPhysicsMaterialLinks TerrainPhysicsMaterial;

    real32 DistanceMaxFromTerrainToCreate;
};

struct SModelEventData
{
    CActorLabelKey Name;

    CActorCreateKey Actor;
};

struct SEventDataFootprint : SModelEventData
{
    CModelLink Model;
};

struct SEventDataSound : SModelEventData
{
    CSoundLink Sound;
};

struct SActorDeathBodySquib
{
    CActorLabelKey Name;

    CActorCreateKey ActorModel;

    CModelLink Model;

    SActorSiteOpsData ModelSiteOps;

    SAttachQuery ModelAttachQuery;

    CActorCreateKey ActorSound;

    CSoundLink Sound;

    SActorSiteOpsData SoundSiteOps;

    SAttachQuery SoundAttachQuery;
};

struct SActorDeathData
{
    CActorCreateKey ActorModel;

    CActorCreateKey ActorModelLow;

    CAnimProps AnimProps;

    CModelLink ModelLink;

    CSoundLink SoundLink;

    CSoundLink VoiceLink;

    std::vector<SActorDeathBodySquib> BodySquibs;
};

struct SActorDeathDataCustom : SActorDeathData
{
    CActorLabelKey Name;

    CActorTableKeys1x3 PhysicsMatchKeysOrdered;

    CActorLabelKey InheritsFrom;

    flag8 IsAbstract;
};

struct SActorDeathDataCustomGroup
{
    CActorLabelKey Name;

    CActorDeathMembers Members;

    CActorTableKeys1x3 Supersedes;

    CFixed SyncPassChance;
};

struct SActorPhysicsData
{
    CActorLabelKey Name;

    CActorTableKeys1x3 MatchKeys;

    int32 AttackModelVariation;

    CAnimProps AttackAnimProps;

    CActorCreateKey Physics;
};

struct SActorPhysicsImpactData
{
    CActorLabelKey Name;

    CActorLabelKey Group;

    CActorCreateKey ActorModel;

    CModelLink ModelLink;

    CActorCreateKey ActorSound;

    CSoundLink SoundLink;

    EActorPhysicsImpactRangeType AutoVolumeRange;

    real32 AutoVolumeRangeMin;

    real32 AutoVolumeRangeMax;

    SActorSiteOpsData SiteOps;

    CVariatorActorReal32 OccuranceThrottlingDistance;

    real32 OccuranceThrottlingDistanceTimeout;

    CVariatorActorReal32 OccuranceThrottlingPeriod;
};

struct SActorStateInfo
{
    CActorLabelKey Name;

    CActorTerms Terms;
};

struct SActorProgressStage
{
    CAnimProps AnimProps;

    real32 BlendTime;

    CSoundLink Sound;
};

struct SActorCloakState
{
    CAnimProps Enter;

    CAnimProps Loop;
};

struct SActorCloakTransition
{
    std::vector<SActorCloakState> StateArray;
};

struct SActorSendBasics
{
    CRefKey Target;

    CActorMsgPayloadPtr Send;
};

struct SActorQuerySubject
{
    CActorClassFilters Filters;

    CActorTerms Terms;
};

struct SActorQueryResponse : SActorSendBasics
{
    EActorResponseScope Scope;
};

struct SActorQuerySubjectResponse
{
    CActorClassFilters Filters;

    EActorIntersectType IntersectType;

    CActorTerms Terms;

    std::vector<SActorSendBasics> OnResponse;
};

struct SActorRangeAbil
{
    CAbilLink Link;

    TAbilCmdIndex Index;
};

struct SActorCreepHeightClass
{
    CActorLabelKey Name;

    real32 StartOffset;

    real32 SolidHeight;

    real32 FadeHeight;
};

struct SActorCreepRate
{
    CActorLabelKey Name;

    real32 Rate;
};

struct SStatusColor
{
    CColor BackgroundColor;

    CColor EmptyColor;

    std::vector<CColor> ColorArray;
};

struct SDamagePastRemainingHealth
{
    CFixed Value;

    EActorOverkillTestType TestType;
};

struct SDamageOverInterval
{
    CFixed Value;

    CFixed Interval;

    EActorOverkillTestType TestType;
};

struct SUnitAbilSound
{
    CAbilCommand AbilCmd;

    CSoundLink Sound;

    CSoundLink GroupSound;
};

struct SIconVariation
{
    uint32 Number;

    CImagePath Image;
};

struct SLayerIcon
{
    std::vector<CImagePath> Image;
};

struct SLayerIconVariation : SLayerIcon
{
    int32 Number;
};

struct SLayerIconShield
{
    std::vector<CImagePath> Image;
};

struct SLayerIconShieldVariation : SLayerIconShield
{
    uint32 Number;
};

struct SErrorOverride
{
    ECmdResult Error;

    CStringLink Text;

    CSoundLink Sound;

    CSoundLink GroupSound;
};

struct SSerpentAggregate
{
    ESerpentType Type;

    real32 BaseElementLengthMax;

    CActorAngle SegmentRotationRate;

    real32 SwimmingUndulationElementLength;

    real32 SwimmingUndulationStartOffset;

    real32 SwimmingUndulationAmplitudePerUnit;

    real32 SwimmingUndulationWavelength;

    real32 SwimmingUndulationIdlePhaseVelocity;

    CActorAngle TurnSmoothingActivationAngleMin;

    CActorAngle TurnSmoothingActivationAngleMax;

    real32 TurnSmoothingRadiusMax;

    CActorAngle UncoilingWhileIdleRotationRateMin;

    CActorAngle UncoilingWhileIdleRotationRateMax;

    CFlags Flags;
};

struct SSerpentSegment
{
    real32 Radius;
};

struct STerrainSquibVisual
{
    CPhysicsMaterialLink TerrainPhysicsMaterial;

    CActorCreateKey ActorModel;

    CActorCreateKey ActorModelLow;

    CModelLink ModelLink;

    CFlags Flags;
};

struct STerrainSquib
{
    CActorLabelKey GroupName;

    SAttachQuery AttachQuery;

    CVariatorActorReal32 MovementDistance;

    CVariatorActorReal32 IdlePeriod;

    real32 RangeUp;

    real32 RangeUpFade;

    real32 RangeDown;

    real32 RangeDownFade;

    std::vector<STerrainSquibVisual> Visuals;
};

struct SStatusHarvesterData
{
    CStringLink Text;

    CTargetFilters SearchFilters;

    CFixed SearchRadius;
};

struct STextTagParameters
{
    CStringLink Text;

    flag8 TextShadow;

    C2iVector Offset;

    EAttachmentID Attachment;

    uint32 FontSize;

    CColor TextColor;

    CColor EdgeColor;

    CColor BackgroundColor;

    CImagePath BackgroundImage;

    flag8 BackgroundImageTiled;
};

class CActor
{
public:
    CActorKey CopySource;

    CActorTerms Terms;

    std::vector<CActorKey> Aliases;

    std::vector<CActorKey> Macros;

    EActorRequestCreateSharing Sharing;

    CFlags Flags;

    CFlags Filter;

    EActorHostedPropInheritType InheritType;

    CFlags Inherits;

    CActorTransferFlags AcceptedTransfers;

    CActorHostedPropTransferFlags AcceptedHostedPropTransfers;

    EFogVisibility FogVisibility;

    TEditorCategories EditorCategories;

    SActorRequest Supporter;
};

class CActorBase : CActor
{
public:
    std::vector<SActorEvent> Remove;

    std::vector<SActorEvent> On;
};

class CActorBearings : CActorBase
{
public:
    flag8 AddToProximitySystem;

    SActorRequest HostForProps;

    SActorRequest Host;

    SActorSiteOpsData HostSiteOps;

    EActorScopeBearingsTrackingType ScopeBearingsTracking;
};

class CActorCamera : CActorBearings
{
public:
    CCameraLink Camera;

    SActorRequest HostEye;

    SActorSiteOpsData HostEyeSiteOps;
};

class CActorModel : CActorBearings
{
public:
    CModelLink Model;

    CScaleVector Scale;

    real32 AutoScaleFactor;

    real32 AutoScaleFromSelectionFactor;

    real32 AnimBlendTime;

    std::vector<SActorHostedAttach> HostedAttaches;

    C3Vector LocalOffsetFor2ndVisibilityTest;

    CFlags ModelFlags;

    std::vector<SEventDataFootprint> EventDataFootprint;

    CActorCreateKey EventDataFootprintActor;

    std::vector<SEventDataSound> EventDataSound;

    CActorCreateKey EventDataSoundActor;

    EActorProximity ProximityPosition;

    CActorLabelKey CreepHeightClass;

    CActorLabelKey CreepRateGrow;

    CActorLabelKey CreepRateShrink;

    SActorPhysicsImpactData PhysicsImpactDefault;

    std::vector<SActorPhysicsImpactData> PhysicsImpacts;
};

class CActorQuad : CActorBearings
{
public:
    CActorCreateKey LaunchActor;

    real32 LaunchHeight;

    CActorCreateKey CenterActor;

    real32 CenterHeight;

    CActorCreateKey ImpactActor;

    real32 ImpactHeight;

    CQuad Quad;

    real32 Height;

    real32 Width;
};

class CActorForce : CActorModel
{
public:
    SActorRequest Receiver;

    EActorForceField Field;

    CVariatorActorReal32 Duration;

    CVariatorActorReal32 Magnitude;

    CFlags ForceFlags;
};

class CActorForceLineSegment : CActorForce
{
public:
    SActorRequest HostEnd;

    SActorSiteOpsData HostEndSiteOps;
};

class CActorBeam : CActorModel
{
public:
    SActorRequest HostLaunch;

    SActorSiteOpsData HostLaunchSiteOps;

    SActorRequest HostImpact;

    SActorSiteOpsData HostImpactSiteOps;
};

class CActorRange : CActorBearings
{
public:
    SActorRangeAbil Abil;

    CBehaviorLink Behavior;

    CUnitLink Sight;

    CWeaponLink Weapon;

    real32 Range;

    real32 Arc;

    CImagePath Icon;

    real32 IconArcLength;

    CFlags RangeFlags;

    CFlagArray<e_cliffLevelCompareCount> CliffLevelFlags;
};

class CActorRegion : CActorBearings
{
public:
    CAbilCommand QueryAbilCmd;

    CEffectLink QueryEffect;

    CTargetFilters QueryFilters;

    real32 QueryRange;

    CRefKey NotifyRadiusKey;

    CRefKey NotifyArcKey;

    CRefKey NotifyClosestScaleKey;

    CFlags RegionFlags;
};

class CActorSite : CActorBearings
{
public:
};

class CActorSiteOp : CActorBase
{
public:
    flag8 HoldPosition;

    flag8 HoldRotation;
};

class CActorSiteOpBase : CActorSiteOp
{
public:
};

class CActorSound : CActorBearings
{
public:
    CSoundLink Sound;

    CFlags SoundFlags;
};

class CActorSplat : CActorBearings
{
public:
    CColor Color;

    real32 FadeIn;

    real32 FadeOut;

    real32 HoldTime;

    ESplatLayer Layer;

    CModelLink Model;

    CScaleVector Scale;

    real32 AutoScaleFactor;

    real32 AutoScaleFromSelectionFactor;

    EActorSplatHeight Height;
};

class CActorAction : CActorBase
{
public:
    CActorKey LaunchGuideAlias;

    SActorSiteOpsData LaunchSiteOps;

    CActorCreateKey LaunchSite;

    CActorCreateKey LaunchSiteFallback;

    SAttachQuery LaunchAttachQuery;

    SActorRequest LaunchRequest;

    SActorAVPair LaunchAssets;

    CActorCreateKey LaunchModel;

    CActorCreateKey LaunchSound;

    CActorCreateKey LaunchTerrainSquibModel;

    CActorCreateKey LaunchTerrainSquibSound;

    std::vector<SActorActionTerrainSquib> LaunchTerrainSquibMap;

    SActorSiteOpsData ContainerSiteOps;

    CActorCreateKey ContainerSite;

    SAttachQuery ContainerAttachQuery;

    SActorAVPair ContainerAssets;

    CActorCreateKey ContainerModel;

    CActorCreateKey ContainerSound;

    CActorCreateKey ContainerTerrainSquibModel;

    CActorCreateKey ContainerTerrainSquibSound;

    std::vector<SActorActionTerrainSquib> ContainerTerrainSquibMap;

    CActorKey Beam;

    EActorEffectScope BeamScope;

    CActorKey Missile;

    CActorKey ImpactGuideAlias;

    SActorSiteOpsData ImpactSiteOps;

    SActorSiteOpsData ImpactSiteOpsReaction;

    CActorCreateKey ImpactSite;

    CActorCreateKey ImpactSiteFallback;

    SAttachQuery ImpactAttachQuery;

    SAttachQuery ImpactReattachQuery;

    SActorSiteOpsData ImpactPointSiteOps;

    CActorCreateKey ImpactPointSite;

    std::vector<SActorAVCluster> ImpactMap;

    CActorCreateKey ImpactModel;

    CActorCreateKey ImpactModelReaction;

    CActorCreateKey ImpactSound;

    std::vector<SActorPhysicsData> ImpactPhysics;

    CActorCreateKey ImpactTerrainSquibModel;

    CActorCreateKey ImpactTerrainSquibSound;

    std::vector<SActorActionTerrainSquib> ImpactTerrainSquibMap;

    SActorSiteOpsData DamageSiteOps;

    SActorSiteOpsData DamageSiteOpsReaction;

    CActorCreateKey DamageSite;

    SAttachQuery DamageAttachQuery;

    SAttachQuery DamageReattachQuery;

    std::vector<SActorAVCluster> DamageMap;

    CActorCreateKey DamageModel;

    CActorCreateKey DamageModelReaction;

    CActorCreateKey DamageSound;

    std::vector<SActorPhysicsData> DamagePhysics;

    CActorCreateKey DamageTerrainSquibModel;

    CActorCreateKey DamageTerrainSquibSound;

    std::vector<SActorActionTerrainSquib> DamageTerrainSquibMap;

    CActorAngle AcquisitionYawHalfArc;

    CActorAngle AcquisitionPitchHalfArc;

    CActorAngle AccuracyHalfArc;

    real32 WeaponFireTrackingTimeWindow;

    EActorShieldFlashType ShieldFlashType;

    real32 ShieldRippleScaleFactor;

    CFlags ActionFlags;

    CRefKey AttackAnimSource;

    CAnimNameKey AttackAnimName;

    CEffectLink ForceCommencementFrom;

    EActorCombatRevealDurationType CombatRevealDurationType;

    real32 Lifetime;
};

class CActorArc : CActorModel
{
public:
    real32 Angle;

    real32 Radius;

    CAnimProps AngleAnimProps;
};

class CActorBeamSimple : CActorBeam
{
public:
};

class CActorBeamStandard : CActorBeam
{
public:
    CBeamLink Beam;
};

class CActorCameraModel : CActorModel
{
public:
    CRefKey Camera;
};

class CActorCreep : CActorBase
{
public:
    CActorCreateKey FoliageSpawnTarget;

    std::vector<SActorQuerySubjectResponse> SubjectResponses;
};

class CActorDoodad : CActorModel
{
public:
    CFlagArray<e_actorDoodadFlagCount> DoodadFlags;

    CFlagArray<e_editorFlagCount> EditorFlags;

    CModelLink EditorModel;

    CAnimProps EditorAnim;

    CImagePath EditorIcon;

    std::vector<CTerrainLink> TexSets;

    CFacing Facing;

    CFangle EditorFacingAlignment;

    CFootprintLink Footprint;

    real32 Radius;

    CRange RandomScaleRange;

    CFixed OccludeHeight;

    TCliffLevel BoostedCliffLevel;

    std::vector<CFixed> BoostedHeight;

    CImagePath MinimapIcon;

    CActorKey MinimapRenderPriority;

    C2Vector MinimapSize;

    EMinimapShape MinimapShape;

    CColor MinimapColor;

    CImagePath MinimapImage;

    real32 VisibleOpacity;

    real32 VisibleOpacityBlendDuration;

    CFixed NoFlyZoneSoftRadius;

    CFixed NoFlyZoneHardRadius;
};

class CActorDoodadPreserver : CActorModel
{
public:
};

class CActorFoliageFXSpawner : CActorBearings
{
public:
    real32 Radius;

    CActorCreateKey SpawnTarget;
};

class CActorEditorCamera : CActorModel
{
public:
};

class CActorEditorPoint : CActorModel
{
public:
};

class CActorEventMacro : CActorBase
{
public:
};

class CActorForceBox : CActorForce
{
public:
    CVariatorActorReal32 Height;

    CVariatorActorReal32 Length;

    CVariatorActorReal32 Width;

    EActorForceOrigin Origin;
};

class CActorForceConeRoundedEnd : CActorForceLineSegment
{
public:
    CVariatorActorAngle Angle;

    CVariatorActorReal32 Length;
};

class CActorForceCylinder : CActorForceLineSegment
{
public:
    CVariatorActorReal32 Radius;

    CVariatorActorReal32 Length;
};

class CActorForceSphere : CActorForce
{
public:
    CVariatorActorReal32 Radius;

    flag8 IsHemisphere;

    EActorForceDirection Direction;
};

class CActorGlobalConfig : CActorBase
{
public:
    CActorCreateKey ActorUnitFallback;

    CActorCreateKey AttachHarnessActor;

    CActorLink AttachHarnessSOpAttach;

    CActorLink AttachHarnessSOpLocalOffset;

    CActorLink AttachHarnessSOpRotationExplicit;

    std::vector<SActorDeathBodySquib> BodySquibs;

    CModelLink CloakModel;

    CModelLink CloakModelLow;

    std::vector<SActorCloakTransition> CloakTransitionArray;

    CActorCreateKey CommandUIActor;

    CModelLink CreepEngulfmentModel;

    std::vector<SActorCreepHeightClass> CreepHeightClasses;

    std::vector<SActorCreepRate> CreepRates;

    std::vector<CActorKey> DeathCustomPriorityList;

    std::vector<SActorDeathDataCustom> DeathCustoms;

    CActorKey MainActor;

    CFixed MaxSpeedForSound;

    std::vector<CActorKey> MinimapRenderPriorityList;

    real32 MissileBoundsOptSpeedThreshold;

    uint32 PopulationLimitModel;

    CColorHDR RevealTint;

    CActorKey SceneActor;
};

class CActorLight : CActorModel
{
public:
};

class CActorLightOmni : CActorLight
{
public:
};

class CActorLightSpot : CActorLight
{
public:
};

class CActorLightModel : CActorModel
{
public:
    CRefKey Light;
};

class CActorLightOmniModel : CActorLightModel
{
public:
};

class CActorLightSpotModel : CActorLightModel
{
public:
};

class CActorLookAt : CActorBase
{
public:
};

class CActorList : CActorBase
{
public:
    flag8 IsAutoDestroy;
};

class CActorPortrait : CActorModel
{
public:
    CRefKey FaceFXTarget;

    CRefKey AnimTargets;
};

class CActorPower : CActorBase
{
public:
    CBehaviorLink PowerSource;

    std::vector<CActorCreateKey> VisualArray;
};

class CActorProgress : CActorBase
{
public:
    std::vector<SActorProgressStage> StageArray;
};

class CActorPropertyCurveSet : CActorBase
{
public:
};

class CActorQueryResponse : CActorBase
{
public:
    SActorQuerySubject Subject;

    std::vector<SActorQueryResponse> OnResponse;
};

class CActorRegionArc : CActorRegion
{
public:
    real32 Angle;

    real32 Radius;
};

class CActorRegionCircle : CActorRegion
{
public:
    real32 Radius;
};

class CActorRegionCombine : CActorRegion
{
public:
    std::vector<CActorCreateKey> ChildArray;
};

class CActorRegionGame : CActorRegion
{
public:
};

class CActorRegionPolygon : CActorRegion
{
public:
    std::vector<C2Vector> PointArray;
};

class CActorRegionQuad : CActorRegion
{
public:
    CQuad Quad;

    real32 Height;

    real32 Width;
};

class CActorRegionWater : CActorRegion
{
public:
};

class CActorScene : CActorBase
{
public:
};

class CActorSelection : CActorSplat
{
public:
    C3Vector Alpha;

    real32 FallOff;

    real32 InnerBoundaryFallOffRatio;

    real32 InnerBoundaryRatio;

    real32 InnerOffsetRatio;

    real32 InnerWidth;

    real32 OuterWidth;

    real32 HalfHeight;

    real32 Attenuation;

    real32 HostRadiusPercent;

    real32 RotationSpeed;

    uint32 SegmentCount;

    real32 SegmentPercentSolid;

    CFlags SelectionFlags;
};

class CActorSetQueried : CActorBase
{
public:
    SActorRequest Host;

    SAttachQuery AttachQuery;

    CActorCreateKey SpawnTarget;
};

class CActorShadow : CActorSplat
{
public:
    C3Vector Alpha;

    real32 FallOff;

    real32 HalfHeight;

    real32 Attenuation;

    real32 HostRadiusPercent;
};

class CActorShield : CActorModel
{
public:
    CActorCreateKey Ripple;

    real32 ScaleDamageMin;

    real32 ScaleDamageMax;

    real32 RadiusMin;

    real32 RadiusMax;
};

class CActorShieldImpact : CActorBase
{
public:
    CActorCreateKey VisualDirectionalFacer;

    CActorCreateKey VisualDirectionalHeader;

    CActorCreateKey VisualDirectionless;

    real32 RadiusMedium;

    real32 RadiusLarge;

    uint32 MaxCountSmall;

    uint32 MaxCountMedium;

    uint32 MaxCountLarge;
};

class CActorSimple : CActorBase
{
public:
};

class CActorSiteBillboard : CActorSite
{
public:
    EActorSiteBillboardType BillboardType;

    real32 TowardsCameraDistance;

    flag8 HoldRotation;

    flag8 UpdateDriveBearings;
};

class CActorSiteMover : CActorSite
{
public:
    real32 Acceleration;

    real32 Deceleration;

    real32 Speed;

    real32 SpeedMax;
};

class CActorSiteRocker : CActorSite
{
public:
    CVariatorActorReal32 Elevation;

    CVariatorActorReal32 ElevationPeriod;

    CVariatorActorFangle Pitch;

    CVariatorActorReal32 PitchPeriod;

    CVariatorActorFangle Roll;

    CVariatorActorReal32 RollPeriod;
};

class CActorSiteOp2DRotation : CActorSiteOpBase
{
public:
};

class CActorSiteOpAction : CActorSiteOpBase
{
public:
    EActorSiteOpActionLocation Location;
};

class CActorSiteOpAttach : CActorSiteOpBase
{
public:
    SAttachQuery AttachQuery;

    SAttachQuery ReattachQuery;

    flag8 ForceSoftAttach;

    EActorSiteOpAttachSource Source;
};

class CActorSiteOpAttachVolume : CActorSiteOpBase
{
public:
    SActorRequest HostIncoming;

    SActorSiteOpsData HostIncomingSiteOps;

    flag8 UpwardVisibilityEnhancement;

    CActorAngle UpwardVisibilityEnhancementVarianceUp;

    CActorAngle UpwardVisibilityEnhancementVarianceDown;
};

class CActorSiteOpBanker : CActorSiteOpBase
{
public:
    CActorAngle RollAngleMax;

    CActorAngle RollInRate;

    CActorAngle RollOutRate;

    real32 RollOutRemainderFractionForLevelOff;
};

class CActorSiteOpBankerUnit : CActorSiteOpBase
{
public:
    CVariatorActorAngle RollMax;

    CActorAngle RollInActivationAngle;

    CVariatorActorAngle RollInArc;

    CVariatorActorReal32 RollOutDuration;
};

class CActorSiteOpBasic : CActorSiteOpBase
{
public:
    EActorSiteOpBasicType BasicType;

    C3Vector WorldPosition;
};

class CActorSiteOpDeathMotion : CActorSiteOpBase
{
public:
    SActorRequest HostInitial;

    SActorSiteOpsData HostInitialSiteOps;

    real32 Deceleration;
};

class CActorSiteOpEffect : CActorSiteOpBase
{
public:
    EActorEffectLocation Location;

    flag8 ZOnly;
};

class CActorSiteOpForward : CActorSiteOpBase
{
public:
    C3Vector Forward;

    SActorRequest HostForward;

    SActorSiteOpsData HostForwardSiteOps;

    flag8 Invert;
};

class CActorSiteOpHeight : CActorSiteOpBase
{
public:
    EActorHeightSourceType HeightSourceType;

    SActorRequest HostHeight;
};

class CActorSiteOpHigherOfTerrainAndWater : CActorSiteOpBase
{
public:
    EActorHeightSourceType HeightSourceType;

    CFlags TerrainAndWaterFlags;
};

class CActorSiteOpHostBearings : CActorSiteOpBase
{
public:
    SActorRequest HostBearings;

    SActorSiteOpsData HostBearingsSiteOps;
};

class CActorSiteOpHostedOffset : CActorSiteOpBase
{
public:
    SActorRequest HostOffset;

    SActorSiteOpsData HostOffsetSiteOps;
};

class CActorSiteOpIncoming : CActorSiteOpBase
{
public:
    SActorRequest HostImpact;

    SActorRequest HostIncoming;

    EActorIncomingType Type;

    real32 PullBack;

    flag8 FreezePositionAtImpact;
};

class CActorSiteOpLocalOffset : CActorSiteOpBase
{
public:
    C3Vector LocalOffset;

    CVariatorActorReal32 OverridingLength;
};

class CActorSiteOpPatch : CActorSiteOpBase
{
public:
    CActorAngle PatchAngle;

    real32 PatchRadius;

    EActorRadialDistribution Distribution;

    real32 Mean;

    real32 Variance;
};

class CActorSiteOpPhysicsImpact : CActorSiteOpBase
{
public:
    EActorSiteOpPhysicsImpactType Type;
};

class CActorSiteOpRandomPointInCircle : CActorSiteOpBase
{
public:
    real32 Radius;

    EActorRadialDistribution Distribution;

    real32 Mean;

    real32 Variance;

    flag8 RestrictToCircumference;

    flag8 ObserveRotation;
};

class CActorSiteOpRandomPointInCrossbar : CActorSiteOpBase
{
public:
    real32 HalfWidth;

    EActorCrossbarDistribution Distribution;

    real32 Variance;
};

class CActorSiteOpRandomPointInSphere : CActorSiteOpBase
{
public:
    real32 Radius;

    EActorRadialDistribution Distribution;

    real32 Mean;

    real32 Variance;

    flag8 RestrictToSurface;
};

class CActorSiteOpRotationExplicit : CActorSiteOpBase
{
public:
    C3Vector Forward;

    C3Vector Up;

    flag8 IsLocal;
};

class CActorSiteOpRotationRandom : CActorSiteOpBase
{
public:
    CActorAngle YawHalfAngle;

    CActorAngle PitchHalfAngle;
};

class CActorSiteOpRotationVariancer : CActorSiteOpBase
{
public:
    CActorAngle ForwardAngle;

    CActorAngle UpAngle;

    flag8 IsUpDominantWhenOrthogonalized;
};

class CActorSiteOpRotator : CActorSiteOpBase
{
public:
    C3Vector LocalAxis;

    CActorAngle Rate;

    EActorSiteOpRotatorType Type;

    CActorAngle InitialAngle;
};

class CActorSiteOpRotationSmooth : CActorSiteOpBase
{
public:
    CFangleRate Acceleration;

    CFangleRate Deceleration;

    CFangleRate MaxSpeed;
};

class CActorSiteOpSelectionOffset : CActorSiteOpBase
{
public:
};

class CActorSiteOpSerpentHead : CActorSiteOpBase
{
public:
    SSerpentAggregate Aggregate;

    SSerpentSegment Segment;
};

class CActorSiteOpSerpentSegment : CActorSiteOpBase
{
public:
    CRefKey Head;

    SSerpentSegment Segment;
};

class CActorSiteOpShadow : CActorSiteOpBase
{
public:
    EActorHeightSourceType HeightSourceType;

    real32 HeightOffset;

    real32 HeightOffsetOnCliff;

    std::vector<C2Vector> CliffTests;

    std::vector<C2Vector> HeightTests;

    EActorHeightTestType HeightTestType;
};

class CActorSiteOpTipability : CActorSiteOpBase
{
public:
    CFlags TipabilityFlags;
};

class CActorSiteOpUp : CActorSiteOpBase
{
public:
    C3Vector Up;

    SActorRequest HostUp;

    SActorSiteOpsData HostUpSiteOps;

    flag8 Invert;
};

class CActorSiteOpZ : CActorSiteOpBase
{
public:
    SActorRequest HostZ;
};

class CActorSnapshot : CActorModel
{
public:
};

class CActorStateMonitor : CActorBase
{
public:
    std::vector<SActorStateInfo> StateArray;

    CGameTime StateThinkInterval;
};

class CActorSquib : CActorBearings
{
public:
    std::vector<SActorAVPair> Map;

    CActorCreateKey HarnessModel;

    CActorCreateKey HarnessSound;
};

class CActorTerrain : CActorBase
{
public:
    SActorPhysicsImpactData PhysicsImpactDefault;

    std::vector<SActorPhysicsImpactData> PhysicsImpacts;
};

class CActorTerrainDeformer : CActorBearings
{
public:
    CFootprintLink Footprint;

    real32 InfluenceRange;

    real32 BlendTime;

    real32 HeightDelta;

    CFlags TerrainDeformerFlags;

    CActorCreateKey FoliageFXDeathSpawnTarget;
};

class CActorText : CActorBearings
{
public:
    real32 TextScale;

    C2Vector MaxSize;

    uint32 FixedSize;

    EActorTextAlignment AlignH;

    EActorTextAlignment AlignV;

    real32 HeightOffset;

    CColor Color;

    CFlags Options;

    CStringLink Text;
};

class CActorTurret : CActorBase
{
public:
    SAttachQuery PitchQuery;

    SAttachQuery YawQuery;

    SActorRequest TurretBody;
};

class CActorUnit : CActorModel
{
public:
    std::vector<SActorBaseline> Baselines;

    CModelLink BuildModel;

    std::vector<SActorDeathData> DeathArray;

    std::vector<SActorDeathDataCustom> DeathCustoms;

    std::vector<SActorDeathDataCustomGroup> DeathCustomData;

    CActorCreateKey DeathActorModel;

    CActorCreateKey DeathActorModelLow;

    CActorCreateKey DeathActorSound;

    CActorCreateKey DeathActorVoice;

    CModelLink EditorModel;

    CAnimProps EditorAnim;

    SDamagePastRemainingHealth OverkillByDamagePastRemainingHealth;

    SDamageOverInterval OverkillByDamageOverInterval;

    CActorTableKeys1x3 PhysicsMatchKeysOrdered;

    CModelLink PlacementModel;

    CSoundLink PlacementSound;

    CActorCreateKey PlacementActorModel;

    CActorCreateKey PlaceholderActorModel;

    CActorCreateKey PortraitActor;

    CModelLink PortraitModel;

    CCameraLink PortraitCamera;

    CRange RandomScaleRange;

    CGameTime StandAnimTurnTime;

    real32 StandAnimTurnTimeScaleMin;

    std::vector<STerrainSquib> TerrainSquibs;

    real32 VarianceWindowStandIntro;

    real32 VarianceWindowStand;

    real32 VarianceWindowWalkIntro;

    real32 VarianceWindowWalk;

    real32 VarianceWindowWalkOutro;

    CGameRate WalkAnimMoveSpeed;

    flag8 WalkAnimTimeScalingAsFlyer;

    std::vector<SUnitAbilSound> AbilSoundArray;

    CStringLink AddonIndicator;

    uint32 BarDistance;

    int32 BarHeight;

    int32 BarOffset;

    int32 BarWidth;

    CStringLink CantSelectUncontrollableTooltip;

    std::vector<CAbilCommand> CooldownDisplay;

    CString CustomUnitStatusFrame;

    std::vector<SErrorOverride> ErrorArray;

    CString GlossaryAnim;

    SLayerIcon GroupIcon;

    std::vector<SLayerIconVariation> GroupIconVariations;

    std::vector<CSoundLink> GroupSoundArray;

    uint32 GroupSoundThreshold;

    CImagePath HeroIcon;

    std::vector<SIconVariation> HeroIconVariations;

    CStringLink HighlightTooltip;

    CStringLink HighlightSubTooltip;

    CStringLink InfoText;

    CImagePath LifeArmorIcon;

    CImagePath MinimapIcon;

    flag8 MinimapIconIsTeamColored;

    real32 MinimapIconScale;

    CImagePath MinimapIconBackground;

    flag8 MinimapIconBackgroundIsTeamColored;

    real32 MinimapIconBackgroundScale;

    CActorKey MinimapRenderPriority;

    CStringLink MinimapTooltip;

    CHerdNodeLink MovementHerdNode;

    flag8 MinimapFlashWhenAttacked;

    flag8 MinimapUseSelfColor;

    flag8 MinimapUseSelectionColor;

    int32 NameOffset;

    CAbilCommand SelectAbilCmd;

    CImagePath ShieldArmorIcon;

    CActorCreateKey SnapshotActor;

    std::vector<CSoundLink> SoundArray;

    CFlagArray<e_unitStatusCount> StatusBarFlags;

    CFlagArray<e_unitStatusGroupCount> StatusBarGroups;

    CFlagArray<e_unitStatusCount> StatusBarOn;

    std::vector<SStatusColor> StatusColors;

    SStatusHarvesterData StatusHarvesterData;

    STextTagParameters StatusTextInfo;

    CColorRGB UnitBorderNormalColor;

    CColorRGB UnitBorderSubgroupColor;

    CFlags UnitFlags;

    CImagePath UnitIcon;

    std::vector<SIconVariation> UnitIconVariations;

    std::vector<SUnitKillRank> UnitKillRank;

    CActorCreateKey UnitModelFrameActor;

    std::vector<SVitalColor> VitalColors;

    std::vector<CStringLink> VitalNames;

    SLayerIcon Wireframe;

    std::vector<SLayerIconVariation> WireframeVariations;

    SLayerIconShield WireframeShield;

    CColor WireframeShieldColor;

    std::vector<SLayerIconShieldVariation> WireframeShieldVariations;
};

class CActorMissile : CActorUnit
{
public:
    SActorRequest HostReturn;

    SActorSiteOpsData HostReturnSiteOps;

    flag8 IsTentacle;

    CActorKey PreHost;
};

#endif // ACTOR_H