Effect.h

Go to the documentation of this file.

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

#ifndef EFFECT_H
#define EFFECT_H

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

typedef enum
{
    e_classIdCEffect,

    e_classIdCEffectResponse,

    e_classIdCEffectApplyBehavior,

    e_classIdCEffectApplyForce,

    e_classIdCEffectCancelOrder,

    e_classIdCEffectCreateHealer,

    e_classIdCEffectCreatePersistent,

    e_classIdCEffectCreateUnit,

    e_classIdCEffectDamage,

    e_classIdCEffectDestroyHealer,

    e_classIdCEffectDestroyPersistent,

    e_classIdCEffectEnumArea,

    e_classIdCEffectEnumMagazine,

    e_classIdCEffectEnumTransport,

    e_classIdCEffectIssueOrder,

    e_classIdCEffectLaunchMissile,

    e_classIdCEffectModifyPlayer,

    e_classIdCEffectModifyUnit,

    e_classIdCEffectRedirectMissile,

    e_classIdCEffectReleaseMagazine,

    e_classIdCEffectRemoveBehavior,

    e_classIdCEffectReturnMagazine,

    e_classIdCEffectSet,

    e_classIdCEffectSwitch,

    e_classIdCEffectTeleport,

    e_classIdCEffectTransferBehavior,

    e_classIdCEffectUseCalldown,

    e_classIdCEffectUseMagazine,

} EClassIdCEffect;

const int32 e_classIdCEffectCount = 28;

typedef enum
{
    e_effectRevealFlagUnfog,

    e_effectRevealFlagDetect,

    e_effectRevealFlagRadar,

    e_effectRevealFlagLoS,

    e_effectRevealFlagPermanent,

} EEffectRevealFlag;

const int32 e_effectRevealFlagCount = 5;

typedef enum
{
    e_effectCombineAnd,

    e_effectCombineOr,

} EEffectCombine;

const int32 e_effectCombineCount = 2;

typedef enum
{
    e_effectApplyBehaviorFlagUseDuration,

} EEffectApplyBehaviorFlag;

const int32 e_effectApplyBehaviorFlagCount = 1;

typedef enum
{
    e_effectCancelOrderFlagActive,

    e_effectCancelOrderFlagQueued,

    e_effectCancelOrderFlagUninterruptible,

} EEffectCancelOrderFlag;

const int32 e_effectCancelOrderFlagCount = 3;

typedef enum
{
    e_createPersistentChanneled,

    e_createPersistentChanneling,

    e_createPersistentEffectSuccess,

    e_createPersistentEffectFailure,

    e_createPersistentOrphanParams,

    e_createPersistentRandomEffect,

    e_createPersistentRandomOffset,

    e_createPersistentRandomPeriod,

    e_createPersistentPersistUntilDestroyed,

} ECreatePersistent;

const int32 e_createPersistentCount = 9;

typedef enum
{
    e_createUnitBirth,

    e_createUnitDropOff,

    e_createUnitOffsetByRadius,

    e_createUnitPlacement,

    e_createUnitPlacementIgnoreBlockers,

    e_createUnitPlacementIgnoreCliffTest,

    e_createUnitPrecursor,

    e_createUnitProvideFood,

    e_createUnitSetFacing,

    e_createUnitSelectControlGroups,

    e_createUnitTechComplete,

    e_createUnitUseFood,

} ECreateUnit;

const int32 e_createUnitCount = 12;

typedef enum
{
    e_damageVisibilityHidden,

    e_damageVisibilitySnapshot,

    e_damageVisibilityVisible,

} EDamageVisibility;

const int32 e_damageVisibilityCount = 3;

typedef enum
{
    e_damageFlagLive,

    e_damageFlagKill,

    e_damageFlagNotification,

    e_damageFlagNoKillCredit,

    e_damageFlagNoLeech,

    e_damageFlagNoGain,

    e_damageFlagNoScaledDealtBonus,

    e_damageFlagNoFractionDealtBonus,

    e_damageFlagNoUnscaledDealtBonus,

    e_damageFlagNoDealtMaximum,

    e_damageFlagNoDealtMinimum,

    e_damageFlagNoBehaviorResponse,

    e_damageFlagNoVitalAbsorbLife,

    e_damageFlagNoVitalAbsorbShields,

    e_damageFlagNoVitalAbsorbEnergy,

    e_damageFlagNoVitalLeechLife,

    e_damageFlagNoVitalLeechShields,

    e_damageFlagNoVitalLeechEnergy,

    e_damageFlagNoVitalGainLife,

    e_damageFlagNoVitalGainShields,

    e_damageFlagNoVitalGainEnergy,

} EDamageFlag;

const int32 e_damageFlagCount = 21;

typedef enum
{
    e_damageSoundLaunch,

    e_damageSoundImpact,

} EDamageSound;

const int32 e_damageSoundCount = 2;

typedef enum
{
    e_damageTotalMaximum,

    e_damageTotalMinimum,

    e_damageTotalCombine,

} EDamageTotal;

const int32 e_damageTotalCount = 3;

typedef enum
{
    e_effectHealerFlagChanneled,

    e_effectHealerFlagChanneling,

} EEffectHealerFlag;

const int32 e_effectHealerFlagCount = 2;

typedef enum
{
    e_effectMissile2D,

    e_effectMissileChanneled,

    e_effectMissilePlacement,

    e_effectMissilePlacementIgnoreBlockers,

    e_effectMissilePlacementIgnoreCliffTest,

    e_effectMissilePointFallback,

    e_effectMissileRetarget,

    e_effectMissileReturn,

    e_effectMissileTransfer,

    e_effectMissileTravelValidation,

    e_effectMissileValidateAbil,

    e_effectMissileValidateWeapon,

} EEffectMissile;

const int32 e_effectMissileCount = 12;

typedef enum
{
    e_moverPatternTypeStripe,

    e_moverPatternTypeBounce,

} EMoverPatternType;

const int32 e_moverPatternTypeCount = 2;

typedef enum
{
    e_effectModifyCopy,

    e_effectModifyOwner,

    e_effectModifyHide,

    e_effectModifyShow,

    e_effectModifyMimic,

    e_effectModifyNullifyMissile,

    e_effectModifySalvage,

    e_effectModifyCopyAutoCast,

} EEffectModify;

const int32 e_effectModifyCount = 8;

typedef enum
{
    e_effectTeleportTestCliff,

    e_effectTeleportTestFog,

    e_effectTeleportTestZone,

} EEffectTeleport;

const int32 e_effectTeleportCount = 3;

typedef enum
{
    e_responseFlagAcquire,

    e_responseFlagFlee,

} EResponseFlag;

const int32 e_responseFlagCount = 2;

typedef enum
{
    e_notifyAreaFlagHelpFriend,

    e_notifyAreaFlagHurtFriend,

    e_notifyAreaFlagHurtEnemy,

    e_notifyAreaFlagOnlyWorkers,

    e_notifyAreaFlagMinorDanger,

} ENotifyAreaFlag;

const int32 e_notifyAreaFlagCount = 5;

typedef enum
{
    e_effectRedirectMissileOriginalValidation,

} EEffectRedirectMissile;

const int32 e_effectRedirectMissileCount = 1;

struct SEffectArea
{
    CFangleArc Arc;

    uint32 MaxCount;

    CFixed Radius;

    CFixed RadiusBonus;
};

struct SEffectDamageArea : SEffectArea
{
    CFixed Bonus;

    CFixed Fraction;

    CValidatorLink Validator;
};

struct SEffectEnumArea : SEffectArea
{
    CEffectLink Effect;
};

struct SEffectModifyPlayerCost : SCost
{
    CAbilLink Abil;

    SEffectWhichUnit Unit;
};

struct SEffectModifyUnitCost
{
    CAbilCommand Abil;

    SEffectWhichPlayer Player;

    CFixed ChargeCountUse;

    CGameTime ChargeTimeUse;

    CGameTime CooldownTimeUse;

    SCostFactor Fraction;
};

struct SEffectModifyVital
{
    CFixed Change;

    CFixed ChangeFraction;
};

struct SEffectSwitchCase
{
    CValidatorLink Validator;

    CEffectLink Effect;

    flag8 FallThrough;
};

struct SEffectMover
{
    CMoverLink Link;

    CFixed IfRangeLTE;
};

class CEffect
{
public:
    std::vector<CValidatorLink> ValidatorArray;

    TEditorCategories EditorCategories;

    SMarker Marker;

    CNotifyAreaFlags AINotifyFlags;

    std::vector<TTechAlias> TechAliasArray;

    CFixed Chance;

    CAlertLink Alert;
};

class CEffectResponse : CEffect
{
public:
    CResponseFlags ResponseFlags;
};

class CEffectApplyBehavior : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CBehaviorLink Behavior;

    flag8 KillHallucination;

    uint32 Count;

    CFlags Flags;

    CGameTime Duration;
};

class CEffectApplyForce : CEffectResponse
{
public:
    SEffectWhichLocation WhichLocation;

    SEffectWhichUnit WhichUnit;

    CFixed Amount;

    CFixed MassFraction;

    SEffectWhichTimeScale TimeScaleSource;
};

class CEffectCancelOrder : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CAbilCommand AbilCmd;

    uint32 Count;

    CFlags Flags;
};

class CEffectCreateHealer : CEffectResponse
{
public:
    SEffectWhichUnit LaunchUnit;

    SEffectWhichUnit ImpactUnit;

    CFlags Flags;

    CValidatorLink PeriodicValidator;

    CEffectLink PeriodicEffect;

    EUnitVital DrainVital;

    CFixed DrainVitalCostFactor;

    std::vector<CFixed> DrainResourceCostFactor;

    EUnitVital RechargeVital;

    CGameRate RechargeVitalRate;

    CFixed TimeFactor;
};

class CEffectCreatePersistent : CEffectResponse
{
public:
    SEffectWhichLocation WhichLocation;

    SEffectWhichTimeScale TimeScaleSource;

    SEffectWhichLocation OffsetVectorStartLocation;

    SEffectWhichLocation OffsetVectorEndLocation;

    SEffectWhichLocation OffsetFacingFallback;

    CFlags Flags;

    CGameTime InitialDelay;

    CEffectLink InitialEffect;

    CEffectOffset InitialOffset;

    CGameTime ExpireDelay;

    CEffectLink ExpireEffect;

    CEffectOffset ExpireOffset;

    CEffectLink FinalEffect;

    CEffectOffset FinalOffset;

    uint32 PeriodCount;

    CValidatorLink PeriodicValidator;

    std::vector<CEffectLink> PeriodicEffectArray;

    std::vector<CEffectOffset> PeriodicOffsetArray;

    std::vector<CGameTime> PeriodicPeriodArray;

    CFixed RevealRadius;

    CFlagArray<e_effectRevealFlagCount> RevealFlags;

    CTargetFilters DetectFilters;

    CTargetFilters RadarFilters;

    EHeightMap HeightMap;

    CEffectLink AINotifyEffect;
};

class CEffectCreateUnit : CEffectResponse
{
public:
    SEffectWhichLocation WhichLocation;

    SEffectWhichLocation Origin;

    CFlags CreateFlags;

    SEffectWhichUnit RallyUnit;

    SEffectWhichPlayer SpawnOwner;

    CEffectLink SpawnEffect;

    CUnitLink SpawnUnit;

    uint32 SpawnCount;

    CFixed SpawnRange;

    std::vector<CGamePoint> SpawnOffset;

    SEffectWhichUnit SelectUnit;

    SEffectWhichUnit TypeFallbackUnit;
};

class CEffectDamage : CEffectResponse
{
public:
    SEffectWhichLocation LaunchLocation;

    SEffectWhichLocation ImpactLocation;

    CValidatorLink ImpactUnitValidator;

    std::vector<CFixed> AttributeBonus;

    std::vector<CFixed> AttributeFactor;

    CFlagArray<e_unitAttributeCount> AttributeForced;

    CFixed ShieldBonus;

    CFixed ShieldFactor;

    CFixed ArmorReduction;

    EDamageVisibility Visibility;

    CDamageFlags Flags;

    EDamageKind Kind;

    EDamageKind KindSplash;

    EDamageTotal Total;

    CFixed Amount;

    CFixed Random;

    std::vector<CFixed> VitalBonus;

    std::vector<CFixed> VitalFractionCurrent;

    std::vector<CFixed> VitalFractionMax;

    std::vector<CFixed> LeechFraction;

    EDeathType Death;

    flag8 KillHallucination;

    std::vector<SEffectDamageArea> AreaArray;

    std::vector<SEffectWhichUnit> ExcludeArray;

    std::vector<SEffectWhichUnit> IncludeArray;

    CTargetFilters SearchFilters;

    STargetSorts TargetSorts;

    CCmdResult MinCountError;

    uint32 MinCount;

    uint32 MaxCount;

    uint32 RecycleCount;

    CFlags SearchFlags;

    CFlagArray<e_equipmentDisplayFlagCount> DisplayFlags;
};

class CEffectDestroyHealer : CEffectResponse
{
public:
    SEffectWhichLocation WhichLocation;

    CEffectLink Effect;

    uint32 Count;

    CFixed Radius;
};

class CEffectDestroyPersistent : CEffectResponse
{
public:
    SEffectWhichLocation WhichLocation;

    CEffectLink Effect;

    uint32 Count;

    CFixed Radius;
};

class CEffectEnumArea : CEffectResponse
{
public:
    SEffectWhichLocation LaunchLocation;

    SEffectWhichLocation ImpactLocation;

    std::vector<SEffectWhichUnit> ExcludeArray;

    std::vector<SEffectWhichUnit> IncludeArray;

    CTargetFilters SearchFilters;

    STargetSorts TargetSorts;

    std::vector<SEffectEnumArea> AreaArray;

    CCmdResult MinCountError;

    uint32 MinCount;

    uint32 MaxCount;

    uint32 RecycleCount;

    CFlags SearchFlags;
};

class CEffectEnumMagazine : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CTargetFilters SearchFilters;

    uint32 MaxCount;

    CEffectLink EffectInternal;

    CEffectLink EffectExternal;
};

class CEffectEnumTransport : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CTargetFilters SearchFilters;

    uint32 MaxCount;

    CEffectLink Effect;

    flag8 CheckOuter;
};

class CEffectIssueOrder : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CAbilLink Abil;

    TAbilCmdIndex AbilCmdIndex;

    CCmdFlags CmdFlags;

    SEffectWhichPlayer Player;

    SEffectWhichLocation Target;
};

class CEffectLaunchMissile : CEffectResponse
{
public:
    SEffectWhichLocation LaunchLocation;

    SEffectWhichLocation ImpactLocation;

    CEffectOffset LaunchOffset;

    CEffectOffset ImpactOffset;

    CEffectLink LaunchEffect;

    CEffectLink ImpactEffect;

    CEffectLink FinishEffect;

    CFlags Flags;

    CBehaviorLink TransferBehavior;

    uint32 TransferCount;

    CUnitLink AmmoUnit;

    CGameTime AmmoLife;

    CUnitLink PlaceholderUnit;

    CFixed PlacementRange;

    CFixed ImpactRange;

    CTargetFilters RetargetFilters;

    CFixed RetargetRange;

    CGameTime ReturnDelay;

    std::vector<SEffectMover> ReturnMovers;

    std::vector<SEffectMover> Movers;

    EMoverPatternType MoverRollingPattern;

    uint32 MoverRollingJump;

    EMoverPatternType MoverExecutePattern;

    uint32 MoverExecuteJump;

    uint32 MoverExecuteRange;

    EDeathType DeathType;

    EDamageVisibility Visibility;
};

class CEffectModifyPlayer : CEffect
{
public:
    SEffectWhichPlayer WhichPlayer;

    std::vector<int32> Resources;

    std::vector<int32> ResourcesCollected;

    SEffectModifyPlayerCost Cost;
};

class CEffectModifyUnit : CEffectResponse
{
public:
    SEffectWhichUnit TransferUnit;

    SEffectWhichUnit LaunchUnit;

    SEffectWhichUnit ImpactUnit;

    SEffectWhichUnit KillCreditUnit;

    flag8 KillHallucination;

    SEffectModifyUnitCost Cost;

    std::vector<SEffectModifyVital> VitalArray;

    CFixed Height;

    CGameTime HeightTime;

    CFlags ModifyFlags;

    CFixed XP;

    uint32 ResourceRestoreBonus;

    CFixed ResourceRestoreFraction;

    int32 Resources;

    uint32 ResourcesHarvestedBonus;

    CFixed ResourcesHarvestedFraction;

    SCostFactor SalvageFactor;

    int32 SpawnCount;

    uint32 CopyOrderCount;

    uint32 CopyRallyCount;

    SEffectWhichPlayer ModifyOwnerPlayer;
};

class CEffectRedirectMissile : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    SEffectWhichLocation ImpactLocation;

    CTargetFilters ImpactFilters;

    CFlags Flags;
};

class CEffectReleaseMagazine : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;
};

class CEffectRemoveBehavior : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CBehaviorCategoryFlags BehaviorCategories;

    EClassIdCBehavior BehaviorClass;

    CBehaviorLink BehaviorLink;

    flag8 KillHallucination;

    uint32 Count;
};

class CEffectReturnMagazine : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CEffectLink MagazineEffect;
};

class CEffectSet : CEffect
{
public:
    std::vector<CEffectLink> EffectArray;

    flag8 Random;

    uint32 MinCount;

    uint32 MaxCount;

    EEffectLocationType TargetLocationType;
};

class CEffectSwitch : CEffect
{
public:
    std::vector<SEffectSwitchCase> CaseArray;

    CEffectLink CaseDefault;

    EEffectLocationType TargetLocationType;
};

class CEffectTeleport : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    flag8 ClearQueuedOrders;

    CFixed MinDistance;

    CFangleArc PlacementArc;

    SEffectWhichLocation PlacementAround;

    CFixed PlacementRange;

    CFixed Range;

    SEffectWhichLocation SourceLocation;

    SEffectWhichLocation TargetLocation;

    CFlags TeleportFlags;
};

class CEffectTransferBehavior : CEffectResponse
{
public:
    SEffectWhichUnit LaunchUnit;

    SEffectWhichUnit ImpactUnit;

    CBehaviorLink Behavior;

    uint32 Count;

    flag8 Copy;

    flag8 Preserve;
};

class CEffectUseCalldown : CEffectResponse
{
public:
    SEffectWhichLocation WhichLocation;

    uint32 CalldownCount;

    CEffectLink CalldownEffect;
};

class CEffectUseMagazine : CEffectResponse
{
public:
    SEffectWhichUnit WhichUnit;

    CUnitLink AmmoUnit;

    CEffectLink AmmoEffect;

    CAbilLink MagazineAbil;
};

#endif // EFFECT_H