Game.h

Go to the documentation of this file.

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

#ifndef GAME_H
#define GAME_H

#include "UnderlyingTypes.h"

typedef enum
{
    e_classIdCGame,

} EClassIdCGame;

const int32 e_classIdCGameCount = 1;

typedef enum
{
    e_gameSyncGameRunSyncValue,

    e_gameSyncDebug,

    e_gameSyncInternal,

    e_gameSyncGameData,

    e_gameSyncUpgradeManager,

    e_gameSyncRandom,

    e_gameSyncCheat,

    e_gameSyncGameEvent,

    e_gameSyncPathing,

    e_gameSyncUnitFinder,

    e_gameSyncCreep,

    e_gameSyncDensity,

    e_gameSyncHeight,

    e_gameSyncVision,

    e_gameSyncTerrainSync,

    e_gameSyncBuild,

    e_gameSyncTechTree,

    e_gameSyncAlliance,

    e_gameSyncUnitTables,

    e_gameSyncPlayer,

    e_gameSyncUser,

    e_gameSyncSelection,

    e_gameSyncStartLocations,

    e_gameSyncAbil,

    e_gameSyncBehavior,

    e_gameSyncChanneler,

    e_gameSyncEffects,

    e_gameSyncRevealer,

    e_gameSyncPersistent,

    e_gameSyncUnit,

    e_gameSyncBeam,

    e_gameSyncTriggerPlacedRefs,

    e_gameSyncTriggerEventRegistry,

    e_gameSyncTriggerVariables,

    e_gameSyncTriggerQueue,

    e_gameSyncTriggerLastCreated,

    e_gameSyncTriggerState,

    e_gameSyncTriggerThread,

    e_gameSyncTriggerSound,

    e_gameSyncTrigger,

    e_gameSyncRegionMonitor,

    e_gameSyncMarker,

    e_gameSyncGalaxyText,

    e_gameSyncGalaxy,

    e_gameSyncBrain,

    e_gameSyncBrainCPU,

    e_gameSyncConjoined,

    e_gameSyncObjective,

    e_gameSyncResourceRequest,

    e_gameSyncHelp,

    e_gameSyncPortrait,

    e_gameSyncConversation,

    e_gameSyncConversationDriver,

    e_gameSyncPurchase,

    e_gameSyncTransmission,

    e_gameSyncTriggerDialog,

    e_gameSyncPing,

    e_gameSyncPlanet,

    e_gameSyncBank,

    e_gameSyncScore,

    e_gameSyncResearch,

    e_gameSyncMercenary,

    e_gameSyncBattleReport,

    e_gameSyncPause,

    e_gameSyncPlaceholders,

    e_gameSyncGameSyncUI,

    e_gameSyncCinematicsDriver,

    e_gameSyncObjectGroups,

    e_gameSyncVictory,

    e_gameSyncDamageHistory,

} EGameSync;

const int32 e_gameSyncCount = 70;

typedef enum
{
    e_gameResultUndecided,

    e_gameResultVictory,

    e_gameResultDefeat,

    e_gameResultTie,

} EGameResult;

const int32 e_gameResultCount = 4;

typedef enum
{
    e_allianceIdPassive,

    e_allianceIdVision,

    e_allianceIdControl,

    e_allianceIdSpend,

    e_allianceIdTrade,

    e_allianceIdSeekHelp,

    e_allianceIdGiveHelp,

    e_allianceIdChat,

    e_allianceIdDefeat,

    e_allianceIdPushable,

    e_allianceIdPower,

} EAllianceId;

const int32 e_allianceIdCount = 11;

typedef enum
{
    e_playerTypeNone,

    e_playerTypeUser,

    e_playerTypeComputer,

    e_playerTypeNeutral,

    e_playerTypeHostile,

} EPlayerType;

const int32 e_playerTypeCount = 5;

typedef enum
{
    e_targetFilterSelf,

    e_targetFilterPlayer,

    e_targetFilterAlly,

    e_targetFilterNeutral,

    e_targetFilterEnemy,

    e_targetFilterAir,

    e_targetFilterGround,

    e_targetFilterLight,

    e_targetFilterArmored,

    e_targetFilterBiological,

    e_targetFilterRobotic,

    e_targetFilterMechanical,

    e_targetFilterPsionic,

    e_targetFilterMassive,

    e_targetFilterStructure,

    e_targetFilterHover,

    e_targetFilterHeroic,

    e_targetFilterWorker,

    e_targetFilterRawResource,

    e_targetFilterHarvestableResource,

    e_targetFilterMissile,

    e_targetFilterDestructible,

    e_targetFilterItem,

    e_targetFilterUncommandable,

    e_targetFilterCanHaveEnergy,

    e_targetFilterCanHaveShields,

    e_targetFilterPreventDefeat,

    e_targetFilterPreventReveal,

    e_targetFilterBuried,

    e_targetFilterCloaked,

    e_targetFilterVisible,

    e_targetFilterStasis,

    e_targetFilterUnderConstruction,

    e_targetFilterDead,

    e_targetFilterRevivable,

    e_targetFilterHidden,

    e_targetFilterHallucination,

    e_targetFilterInvulnerable,

    e_targetFilterHasEnergy,

    e_targetFilterHasShields,

    e_targetFilterBenign,

    e_targetFilterPassive,

    e_targetFilterDetector,

    e_targetFilterRadar,

    e_targetFilterStunned,

    e_targetFilterSummoned,

    e_targetFilterUnstoppable,

    e_targetFilterOuter,

} ETargetFilter;

const int32 e_targetFilterCount = 48;

typedef enum
{
    e_markerMatchId,

    e_markerMatchLink,

    e_markerMatchCasterPlayer,

    e_markerMatchCasterUnit,

} EMarkerMatch;

const int32 e_markerMatchCount = 4;

typedef enum
{
    e_heightMapAir,

    e_heightMapGlide,

    e_heightMapGround,

} EHeightMap;

const int32 e_heightMapCount = 3;

typedef enum
{
    e_pathGroundNoSpawn,

    e_pathNoBuild,

    e_pathNearResources,

    e_pathDropOff,

    e_pathCreep,

    e_pathNoCreep,

    e_pathMasked,

    e_pathFogged,

    e_pathBlockVision,

    e_pathBoostCliff,

    e_pathBoostHeight,

    e_pathShrubVision,

    e_pathDense,

    e_pathNoCanSee,

} EPath;

const int32 e_pathCount = 14;

typedef enum
{
    e_planeGround,

    e_planeAir,

} EPlane;

const int32 e_planeCount = 2;

typedef enum
{
    e_placementTestCreep,

    e_placementTestPower,

    e_placementTestFog,

    e_placementTestIgnoreBlockers,

    e_placementTestIgnoreInvisible,

    e_placementTestZone,

    e_placementTestCliff,

    e_placementTestDensity,

} EPlacementTest;

const int32 e_placementTestCount = 8;

typedef enum
{
    e_unitVitalLife,

    e_unitVitalShields,

    e_unitVitalEnergy,

} EUnitVital;

const int32 e_unitVitalCount = 3;

typedef enum
{
    e_acquireLevelNone,

    e_acquireLevelPassive,

    e_acquireLevelDefensive,

    e_acquireLevelOffensive,

} EAcquireLevel;

const int32 e_acquireLevelCount = 4;

typedef enum
{
    e_damageKindSpell,

    e_damageKindMelee,

    e_damageKindRanged,

    e_damageKindSplash,

} EDamageKind;

const int32 e_damageKindCount = 4;

typedef enum
{
    e_deathTypeNormal,

    e_deathTypeRemove,

    e_deathTypeBlast,

    e_deathTypeDisintegrate,

    e_deathTypeEat,

    e_deathTypeElectrocute,

    e_deathTypeEviscerate,

    e_deathTypeFire,

    e_deathTypeFreeze,

    e_deathTypeImpact,

    e_deathTypeMorph,

    e_deathTypeSilentkill,

    e_deathTypeSquish,

    e_deathTypeTimeout,

    e_deathTypeUnlink,

    e_deathTypeUnderConstruction,

    e_deathTypeSalvage,

    e_deathTypeCancel,

} EDeathType;

const int32 e_deathTypeCount = 18;

typedef enum
{
    e_effectTimeScaleCaster,

    e_effectTimeScaleTarget,

    e_effectTimeScaleGlobal,

} EEffectTimeScale;

const int32 e_effectTimeScaleCount = 3;

typedef enum
{
    e_chargeLocationAbil,

    e_chargeLocationUnit,

    e_chargeLocationPlayer,

    e_chargeLocationGlobal,

    e_chargeLocationBehavior,

} EChargeLocation;

const int32 e_chargeLocationCount = 5;

typedef enum
{
    e_cooldownLocationAbil,

    e_cooldownLocationUnit,

    e_cooldownLocationPlayer,

    e_cooldownLocationGlobal,

    e_cooldownLocationBehavior,

} ECooldownLocation;

const int32 e_cooldownLocationCount = 5;

typedef enum
{
    e_resourceStateRaw,

    e_resourceStateHarvestable,

} EResourceState;

const int32 e_resourceStateCount = 2;

typedef enum
{
    e_resourceTypeMinerals,

    e_resourceTypeVespene,

    e_resourceTypeTerrazine,

    e_resourceTypeCustom,

} EResourceType;

const int32 e_resourceTypeCount = 4;

typedef enum
{
    e_costCategoryNone,

    e_costCategoryArmy,

    e_costCategoryEconomy,

    e_costCategoryTechnology,

} ECostCategory;

const int32 e_costCategoryCount = 4;

typedef enum
{
    e_editorFlagNoPlacement,

    e_editorFlagNoPalettes,

    e_editorFlagBlockStructures,

    e_editorFlagAmbientOcclusion,

    e_editorFlagCanRotate,

    e_editorFlagNoAutoRotate,

    e_editorFlagNeutralDefault,

    e_editorFlagHostileDefault,

} EEditorFlag;

const int32 e_editorFlagCount = 8;

typedef enum
{
    e_fogVisibilityHidden,

    e_fogVisibilitySnapshot,

    e_fogVisibilityDimmed,

    e_fogVisibilityVisible,

} EFogVisibility;

const int32 e_fogVisibilityCount = 4;

typedef enum
{
    e_effectLocationCasterUnit,

    e_effectLocationCasterPoint,

    e_effectLocationCasterUnitOrPoint,

    e_effectLocationCasterOuterUnit,

    e_effectLocationCasterOuterPoint,

    e_effectLocationCasterOuterUnitOrPoint,

    e_effectLocationSourceUnit,

    e_effectLocationSourcePoint,

    e_effectLocationSourceUnitOrPoint,

    e_effectLocationOuterUnit,

    e_effectLocationOuterPoint,

    e_effectLocationOuterUnitOrPoint,

    e_effectLocationTargetUnit,

    e_effectLocationTargetPoint,

    e_effectLocationTargetUnitOrPoint,

    e_effectLocationTargetOuterUnit,

    e_effectLocationTargetOuterPoint,

    e_effectLocationTargetOuterUnitOrPoint,

    e_effectLocationOriginUnit,

    e_effectLocationOriginPoint,

    e_effectLocationOriginUnitOrPoint,

} EEffectLocation;

const int32 e_effectLocationCount = 21;

typedef enum
{
    e_effectLocationTypeUnit,

    e_effectLocationTypePoint,

    e_effectLocationTypeUnitOrPoint,

} EEffectLocationType;

const int32 e_effectLocationTypeCount = 3;

typedef enum
{
    e_effectPlayerOrigin,

    e_effectPlayerCreator,

    e_effectPlayerCaster,

    e_effectPlayerCasterOuter,

    e_effectPlayerOuter,

    e_effectPlayerSource,

    e_effectPlayerTarget,

    e_effectPlayerTargetOuter,

    e_effectPlayerNeutral,

    e_effectPlayerHostile,

} EEffectPlayer;

const int32 e_effectPlayerCount = 10;

typedef enum
{
    e_effectUnitCaster,

    e_effectUnitCasterOuter,

    e_effectUnitOuter,

    e_effectUnitSource,

    e_effectUnitTarget,

    e_effectUnitTargetOuter,

    e_effectUnitOrigin,

} EEffectUnit;

const int32 e_effectUnitCount = 7;

typedef enum
{
    e_teamColorDiffuse,

    e_teamColorEmissive,

} ETeamColor;

const int32 e_teamColorCount = 2;

typedef enum
{
    e_shieldImpactDamage,

    e_shieldImpactFizzle,

} EShieldImpact;

const int32 e_shieldImpactCount = 2;

typedef enum
{
    e_effectSearchFlagCallForHelp,

    e_effectSearchFlagCenterAtLaunch,

    e_effectSearchFlagExtendByUnitRadius,

    e_effectSearchFlagOffsetByUnitRadius,

    e_effectSearchFlagOffsetAreaByAngle,

    e_effectSearchFlagSameCliff,

} EEffectSearchFlag;

const int32 e_effectSearchFlagCount = 6;

typedef enum
{
    e_costDisplayLife,

    e_costDisplayShields,

    e_costDisplayEnergy,

    e_costDisplayMinerals,

    e_costDisplayVespene,

    e_costDisplayTerrazine,

    e_costDisplayCustom,

} ECostDisplay;

const int32 e_costDisplayCount = 7;

typedef enum
{
    e_techStateQueued,

    e_techStateInProgress,

    e_techStateComplete,

} ETechCountState;

const int32 e_techStateCount = 3;

typedef enum
{
    e_playerRelationshipSelf,

    e_playerRelationshipAlly,

    e_playerRelationshipNeutral,

    e_playerRelationshipEnemy,

} EPlayerRelationship;

const int32 e_playerRelationshipCount = 4;

typedef enum
{
    e_equipmentDisplayFlagCollapseBuffed,

    e_equipmentDisplayFlagExpandUpgraded,

    e_equipmentDisplayFlagDisplayRounded,

} EEquipmentDisplayFlag;

const int32 e_equipmentDisplayFlagCount = 3;

typedef enum
{
    e_valueCompareEq,

    e_valueCompareNE,

    e_valueCompareLT,

    e_valueCompareGT,

    e_valueCompareLE,

    e_valueCompareGE,

} EValueCompare;

const int32 e_valueCompareCount = 6;

typedef enum
{
    e_fidgetAnim,

    e_fidgetIdle,

    e_fidgetMove,

    e_fidgetTurn,

} EFidget;

const int32 e_fidgetCount = 4;

typedef enum
{
    e_beaconArmy,

    e_beaconDefend,

    e_beaconAttack,

    e_beaconHarass,

    e_beaconIdle,

    e_beaconAuto,

    e_beaconDetect,

    e_beaconScout,

    e_beaconClaim,

    e_beaconExpand,

    e_beaconRally,

    e_beaconCustom1,

    e_beaconCustom2,

    e_beaconCustom3,

    e_beaconCustom4,

} EBeacon;

const int32 e_beaconCount = 15;

typedef enum
{
    e_customBuildOpeningInvalid,

    e_customBuildOpeningOne,

    e_customBuildOpeningTwo,

    e_customBuildOpeningThree,

    e_customBuildOpeningFour,

    e_customBuildOpeningFive,

} ECustomBuildOpening;

const int32 e_customBuildOpeningCount = 6;

typedef enum
{
    e_customBuildLateGameInvalid,

    e_customBuildLateGameOne,

    e_customBuildLateGameTwo,

    e_customBuildLateGameThree,

    e_customBuildLateGameFour,

    e_customBuildLateGameFive,

} ECustomBuildLateGame;

const int32 e_customBuildLateGameCount = 6;

typedef enum
{
    e_customCombinedBuildListInvalid,

    e_customCombinedBuildListStartOpen,

    e_customCombinedBuildListOpenOne,

    e_customCombinedBuildListOpenTwo,

    e_customCombinedBuildListOpenThree,

    e_customCombinedBuildListOpenFour,

    e_customCombinedBuildListOpenFive,

    e_customCombinedBuildListEndOpen,

    e_customCombinedBuildListStartLate,

    e_customCombinedBuildListLateOne,

    e_customCombinedBuildListLateTwo,

    e_customCombinedBuildListLateThree,

    e_customCombinedBuildListLateFour,

    e_customCombinedBuildListLateFive,

    e_customCombinedBuildListEndLate,

} ECustomCombinedBuildList;

const int32 e_customCombinedBuildListCount = 15;

typedef enum
{
    e_beaconFlagNone,

    e_beaconFlagAutoCastOn,

    e_beaconFlagAutoCastOff,

    e_beaconFlagClearAll,

    e_beaconFlagClearExtra,

    e_beaconFlagCustomBuild,

    e_beaconFlagViewNext,

    e_beaconFlagViewPrev,

    e_beaconFlagDropoff,

} EBeaconFlag;

const int32 e_beaconFlagCount = 9;

typedef enum
{
    e_unitTauntCheer,

    e_unitTauntDance,

} EUnitTaunt;

const int32 e_unitTauntCount = 2;

typedef enum
{
    e_difficultyFlagTrialAllowed,

} EDifficultyFlag;

const int32 e_difficultyFlagCount = 1;

typedef enum
{
    e_cliffLevelCompareLower,

    e_cliffLevelCompareEqual,

    e_cliffLevelCompareHigher,

} ECliffLevelCompare;

const int32 e_cliffLevelCompareCount = 3;

typedef enum
{
    e_vitalColorLife,

    e_vitalColorShields,

    e_vitalColorEnergy,

} EVitalColor;

const int32 e_vitalColorCount = 3;

struct SAIDescription
{
    CFourCC Id;

    CStringLink Name;

    CIdentifier File;

    CString32 Suffix;
};

struct SBankPath
{
    CString File;

    CString Section;

    CString Key;
};

struct SCharge
{
    CFixed CountMax;

    CFixed CountStart;

    CFixed CountUse;

    flag HideCount;

    TChargeLink Link;

    EChargeLocation Location;

    CGameTime TimeStart;

    CGameTime TimeUse;
};

struct SCooldown
{
    TCooldownLink Link;

    ECooldownLocation Location;

    CGameTime TimeStart;

    CGameTime TimeUse;
};

struct STechCost
{
    std::vector<int32> Resource;
};

struct SCost : STechCost
{
    CFlags Display;

    std::vector<CFixed> Vital;

    std::vector<CFixed> VitalFraction;

    SCharge Charge;

    SCooldown Cooldown;
};

struct SCostFactor
{
    std::vector<CFixed> Vital;

    std::vector<CFixed> VitalFraction;

    std::vector<CFixed> Resource;

    CFixed Charge;

    CFixed Cooldown;
};

struct SMarker
{
    TMarkerCount Count;

    CMarkerFlags MatchFlags;

    CMarkerFlags MismatchFlags;

    TMarkerLink Link;
};

struct SDifficultyLevel
{
    CFourCC AttributeId;

    CStringLink Name;

    CStringLink NameCampaign;

    CStringLink NameMelee;

    CStringLink MenuTooltip;

    flag Enabled;

    CFlags Flags;

    int32 ActionsPerMinute;

    uint8 DefaultRebuildUnit;

    uint8 DefaultRebuildStructure;
};

struct SAIBuild
{
    CFourCC AttributeId;

    CStringLink Name;

    CStringLink MenuTooltip;

    flag Enabled;

    CRaceLink Race;

    NNet::Game::TDifficulty MinDiff;

    NNet::Game::TDifficulty MaxDiff;

    int32 BuildScriptNum;
};

struct SHandicap
{
    CStringLink MenuTooltip;

    NNet::Game::THandicap Percent;
};

struct SMapSize
{
    CStringLink Name;

    uint32 MaxCells;
};

struct SEffectWhichLocation
{
    CEffectLink Effect;

    EEffectLocation Value;
};

struct SEffectWhichPlayer
{
    CEffectLink Effect;

    EEffectPlayer Value;
};

struct SEffectWhichTimeScale
{
    CEffectLink Effect;

    EEffectTimeScale Value;
};

struct SEffectWhichUnit
{
    CEffectLink Effect;

    EEffectUnit Value;
};

struct STeamColor
{
    real32 HDRMultiplier;

    CStringLink Name;

    std::vector<C4Vector> Value;

    flag UserChoice;

    int32 MinPlayerCount;

    CFourCC AttributeId;
};

struct STargetFilterResult
{
    CTargetFilters Filter;

    TCmdResult Result;
};

struct SFidget
{
    std::vector<uint8> ChanceArray;

    CGameTime DelayMax;

    CGameTime DelayMin;

    CFixed DistanceMax;

    CFixed DistanceMin;

    CFangle TurnAngle;

    CFangleRate TurningRate;
};

struct SBeaconInfo
{
    CAlertLink Alert;

    CUnitLink Unit;

    CStringLink Tooltip;

    CFlags Clear;
};

struct SUnitKillRank
{
    uint32 MinKills;

    CStringLink Text;
};

struct SAspectMargin
{
    uint32 AspectWidth;

    uint32 AspectHeight;

    CiQuad Margin;
};

struct STriggerLib
{
    TTriggerLibId Id;

    CString IncludePath;
};

struct SResourceConvert
{
    std::vector<CFixed> RatioArray;
};

struct SMeleePointThreshold
{
    uint32 Value;

    CFixed Factor;
};

struct SVitalColor
{
    std::vector<CColor> ColorArray;
};

class CGame
{
public:
    CBehaviorLink AttackRevealBehavior;

    CFixed AcquireMovementLimit;

    CFixed AcquireLeashRadius;

    CFixed AcquireLeashResetRadius;

    CGameTime CallForHelpPeriod;

    CFixed CallForHelpRadius;

    CGameTime CreepBlendTime;

    CSoundLink CreepDecaySound;

    CGameTime CreepDecayTime;

    CSoundLink CreepGrowSound;

    CGameTime DensityDecayTime;

    flag8 DensityPersistent;

    CFixed DamageMinimum;

    CGameTime AttackRevealTime;

    CGameTime PenaltyRevealTime;

    CGameTime StalemateTestTime;

    CGameTime StalemateWarningTime;

    std::vector<SDifficultyLevel> DifficultyLevels;

    TDifficultyLevel DifficultyDefault;

    std::vector<SAIBuild> AIBuilds;

    NNet::Game::TAIBuild AIBuildDefault;

    std::vector<SHandicap> HandicapValues;

    CFixed AirFormationDiameter;

    CFixed MixedFormationDiameter;

    std::vector<SMapSize> MapSizes;

    CiQuad UnpathableMargin;

    CiQuad CameraMargin;

    std::vector<SAspectMargin> CameraMarginAspectAdjust;

    std::vector<STeamColor> TeamColors;

    CEffectLink SplashDamageEffect;

    CFixed UnitSightRangeDead;

    CFixed UnitSightRangeUnderConstruction;

    std::vector<SAIDescription> AI;

    std::vector<STriggerLib> TriggerLibs;

    std::vector<STargetFilterResult> FilterResults;

    std::vector<SBeaconInfo> BeaconInfoArray;

    CAbilLink TauntAbil;

    CGameTime UncontestedCombatPeriod;

    std::vector<uint32> AIResourceRequest;

    CFixed VeterancySearchRadius;

    CTargetFilters VeterancySearchFilters;

    std::vector<SResourceConvert> ResourceConvertArray;

    CFixed DamageHistoryIntervalMax;

    SMeleePointThreshold MeleePointsThreshold;

    CGameTime MeleePointsGameDurationMin;

    CFixed FoodCappedMax;
};

#endif // GAME_H