Mover.h

Go to the documentation of this file.

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

#ifndef MOVER_H
#define MOVER_H

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

typedef enum
{
    e_classIdCMover,

    e_classIdCMoverAvoid,

    e_classIdCMoverFlock,

    e_classIdCMoverMissile,

    e_classIdCMoverNull,

} EClassIdCMover;

const int32 e_classIdCMoverCount = 5;

typedef enum
{
    e_placementRequire,

    e_placementPrevent,

} EPlacement;

const int32 e_placementCount = 2;

typedef enum
{
    e_pathAvoidNormal,

    e_pathAvoidWalker,

} EPathAvoid;

const int32 e_pathAvoidCount = 2;

typedef enum
{
    e_pathModeGround,

    e_pathModeJumper,

    e_pathModeScaler,

    e_pathModeDigger,

    e_pathModeFlying,

    e_pathModeBuilder,

} EPathMode;

const int32 e_pathModeCount = 6;

typedef enum
{
    e_motionDriverNone,

    e_motionDriverAdaptableParabola,

    e_motionDriverBallistic,

    e_motionDriverGuidance,

    e_motionDriverThrow,

} EMotionDriverType;

const int32 e_motionDriverCount = 5;

typedef enum
{
    e_motionRotLaunchActorNone,

    e_motionRotLaunchActorLaunchToTarget,

    e_motionRotLaunchActorLaunchToTarget2D,

    e_motionRotLaunchActorSupplied,

} EMotionRotationLaunchActorType;

const int32 e_motionRotLaunchActorCount = 4;

typedef enum
{
    e_motionRotActorNone,

    e_motionRotActorDocking,

    e_motionRotActorLookAtTarget,

    e_motionRotActorLookAtTarget2D,

    e_motionRotActorUpright,

    e_motionRotActorZeroRoll,

} EMotionRotationActorType;

const int32 e_motionRotActorCount = 6;

typedef enum
{
    e_motionThrowRotNone,

    e_motionThrowRotLauncherForward,

    e_motionThrowRotLookAtTarget,

    e_motionThrowRotLookAtTarget2D,

    e_motionThrowRotThrowForward,

    e_motionThrowRotVectored,

} EMotionThrowRotationType;

const int32 e_motionThrowRotCount = 6;

typedef enum
{
    e_motionTurnDefault,

    e_motionTurnRevertToUp,

    e_motionTurnOptimal,

} EMotionTurnType;

const int32 e_motionTurnCount = 3;

typedef enum
{
    e_motionBlendNone,

    e_motionBlendLinear,

    e_motionBlendLogarithmic,

    e_motionBlendExponential,

} EMotionBlendType;

const int32 e_motionBlendCount = 4;

typedef enum
{
    e_motionAdaptableParabolaSegLaunch,

    e_motionAdaptableParabolaSegAscent,

    e_motionAdaptableParabolaSegApex,

    e_motionAdaptableParabolaSegDescent,

    e_motionAdaptableParabolaSegLand,

} EMotionAdaptableParabolaSeg;

const int32 e_motionAdaptableParabolaSegCount = 5;

typedef enum
{
    e_motionAdaptableParabolaHotspotLaunch,

    e_motionAdaptableParabolaHotspotPreApex,

    e_motionAdaptableParabolaHotspotPostApex,

    e_motionAdaptableParabolaHotspotLand,

} EMotionAdaptableParabolaHotspot;

const int32 e_motionAdaptableParabolaHotspotCount = 4;

typedef enum
{
    e_motionArrivalTestAdaptive,

    e_motionArrivalTest2D,

    e_motionArrivalTest3D,

    e_motionArrivalTestNever,

} EMotionArrivalTestType;

const int32 e_motionArrivalTestCount = 4;

typedef enum
{
    e_motionActorTrackingHookless,

    e_motionActorTrackingLinear,

    e_motionActorTrackingActual,

} EMotionActorTrackingType;

const int32 e_motionActorTrackingCount = 3;

typedef enum
{
    e_motionOverlayNone,

    e_motionOverlayOrbit,

    e_motionOverlayRevolver,

    e_motionOverlayWave,

} EMotionOverlayType;

const int32 e_motionOverlayCount = 4;

typedef enum
{
    e_motionOverlayPolarityNone,

    e_motionOverlayPolarityPositive,

    e_motionOverlayPolarityNegative,

    e_motionOverlayPolarityRandom,

    e_motionOverlayPolarityAlternating,

} EMotionOverlayPolarity;

const int32 e_motionOverlayPolarityCount = 5;

typedef enum
{
    e_moverFlagIgnoreMovementSuppression,

} EMoverFlag;

const int32 e_moverFlagCount = 1;

struct SPathingData
{
    CFlags Bits;
};

struct SMotionOverlay
{
    EMotionOverlayType Type;

    EMotionOverlayPolarity Polarity;

    CDataSoupKey PolarityDriver;

    C3fVector Axis;

    CVariatorGameFixed Wavelength;

    CFixed WavelengthChangeProbability;

    CFangleRateMissile RevolverSpeed;

    CFangleRateMissile RevolverSpeedRange;

    CFangleRateMissile RevolverMaxSpeed;

    CFangleRateMissile RevolverMaxSpeedRange;

    CFangleAccelMissile RevolverAccel;

    CFangleAccelMissile RevolverAccelRange;
};

struct SMotionOverlayPhase
{
    CVariatorGameFixed Scale;
};

struct SMotionPhase
{
    EMotionDriverType Driver;

    CMissileAcceleration Acceleration;

    CMissileAcceleration AccelerationRange;

    CMissileSpeed Speed;

    CMissileSpeed SpeedRange;

    CMissileSpeed MinSpeed;

    CMissileSpeed MaxSpeed;

    CFixed Gravity;

    CFixed Clearance;

    CFixed ClearanceLookahead;

    CMissileAcceleration ClearanceAcceleration;

    flag ClearanceIgnoresTargetProximity;

    flag IgnoresTerrain;

    EMotionTurnType TurnType;

    EMotionActorTrackingType ActorTracking;

    EMotionArrivalTestType ArrivalTestType;

    EMotionBlendType BlendType;

    CPhaseOutro Outro;

    EMotionRotationLaunchActorType RotationLaunchActorType;

    EMotionRotationActorType RotationActorType;

    CFixed Timeout;

    EMotionThrowRotationType ThrowRotationType;

    C3fVector ThrowVector;

    CThrowBand ThrowBandYaw;

    CThrowBand ThrowBandPitch;

    C3fVector ThrowForward;

    flag AdaptableParabolaIsUpright;

    CVariatorGameFixed AdaptableParabolaClearance;

    std::vector<CFixed> AdaptableParabolaDistances;

    std::vector<CMissileAcceleration> AdaptableParabolaAccels;

    CYawPitchRoll YawPitchRoll;

    CYawPitchRoll YawPitchRollRange;

    CYawPitchRoll YawPitchRollAccel;

    CYawPitchRoll YawPitchRollAccelRange;

    CFangle PowerslideAngle;

    CMissileAcceleration PowerslideDecel;

    CVariatorGameFixed FlightTime;

    CPhaseOutro OutroAltitude;

    std::vector<SMotionOverlayPhase> Overlays;
};

class CMover
{
public:
    CFlags Flags;

    EHeightMap HeightMap;

    EPathMode PathMode;

    std::vector<SPathingData> PlacementArray;
};

class CMoverAvoid : CMover
{
public:
};

class CMoverFlock : CMover
{
public:
};

class CMoverMissile : CMover
{
public:
    std::vector<SMotionPhase> MotionPhases;

    std::vector<SMotionOverlay> MotionOverlays;

    flag RotationIgnoredByUnit;

    flag RespectUnitHeightAtDestination;
};

class CMoverNull : CMover
{
public:
};

#endif // MOVER_H