@chronodivide/game-api 0.35.0

package/dist/index.d.ts

@@ -0,0 +1,1734 @@
+export declare class ActionsApi {
+    #private;
+    placeBuilding(buildingName: string, rx: number, ry: number): void;
+    sellBuilding(buildingId: number): void;
+    toggleRepairWrench(buildingId: number): void;
+    toggleAlliance(toPlayer: string, enabled: boolean): void;
+    pauseProduction(queueType: QueueType): void;
+    resumeProduction(queueType: QueueType): void;
+    queueForProduction(queueType: QueueType, objName: string, objType: ObjectType, quantity: number): void;
+    unqueueFromProduction(queueType: QueueType, objName: string, objType: ObjectType, quantity: number): void;
+    activateSuperWeapon(type: SuperWeaponType, tile: {
+        rx: number;
+        ry: number;
+    }, tile2?: {
+        rx: number;
+        ry: number;
+    }): void;
+    orderUnits(unitIds: number[], orderType: OrderType): void;
+    orderUnits(unitIds: number[], orderType: OrderType, targetUnit: number): void;
+    orderUnits(unitIds: number[], orderType: OrderType, rx: number, ry: number, onBridge?: boolean): void;
+    quitGame(): void;
+}
+
+export declare interface Agent {
+    name: string;
+    /** Country name as found in rules.ini [Countries] */
+    country: string;
+}
+
+export declare class AiRules {
+    buildPower: string[];
+    buildRefinery: string[];
+    buildTech: string[];
+    tiberiumFarScan: number;
+    tiberiumNearScan: number;
+    readIni(ini: IniSection): void;
+}
+
+export declare type ApiEvent = ObjectOwnerChangeApiEvent | ObjectSpawnUnspawnApiEvent | ObjectDestroyApiEvent;
+
+export declare enum ApiEventType {
+    ObjectOwnerChange = 0,
+    ObjectSpawn = 1,
+    ObjectUnspawn = 2,
+    ObjectDestroy = 3
+}
+
+export declare enum ArmorType {
+    None = 0,
+    Flak = 1,
+    Plate = 2,
+    Light = 3,
+    Medium = 4,
+    Heavy = 5,
+    Wood = 6,
+    Steel = 7,
+    Concrete = 8,
+    Special_1 = 9,
+    Special_2 = 10
+}
+
+export declare enum AttackState {
+    Idle = 0,
+    /** Check range + LoS and move to a valid position if needed */
+    CheckRange = 1,
+    /** Perform LoS checks, wait for weapon cooldown etc. */
+    PrepareToFire = 2,
+    /** This means the fire animation was started, but the weapon wasn't fired yet */
+    FireUp = 3,
+    Firing = 4,
+    JustFired = 5
+}
+
+export declare class Bot {
+    name: string;
+    country: string;
+    protected gameApi: GameApi;
+    protected actionsApi: ActionsApi;
+    protected productionApi: ProductionApi;
+    constructor(name: string, country: string);
+    onGameStart(gameApi: GameApi): void;
+    onGameTick(gameApi: GameApi): void;
+    onGameEvent(ev: ApiEvent, gameApi: GameApi): void;
+}
+
+export declare enum BuildCat {
+    Combat = 0,
+    Tech = 1,
+    Resource = 2,
+    Power = 3
+}
+
+export declare interface BuildingPlacementData {
+    /** The size of the building foundation in tiles */
+    foundation: Size;
+    /** The offset of the foundation center tile */
+    foundationCenter: Point2D;
+}
+
+export declare enum BuildStatus {
+    BuildUp = 0,
+    Ready = 1,
+    /** When the building is being deconstructed (e.g. sold or undeployed) */
+    BuildDown = 2
+}
+
+export declare const cdapi: PublicApi;
+
+export declare class CombatDamageRules {
+    ballisticScatter: number;
+    bridgeStrength: number;
+    c4Delay: number;
+    c4Warhead: string;
+    deathWeapon: string;
+    dMislEliteWarhead: string;
+    dMislWarhead: string;
+    ironCurtainDuration: number;
+    ivanDamage: number;
+    ivanIconFlickerRate: number;
+    ivanTimedDelay: number;
+    ivanWarhead: string;
+    splashList: string[];
+    v3EliteWarhead: string;
+    v3Warhead: string;
+    readIni(ini: IniSection): void;
+}
+
+/** Player faction */
+export declare class Country {
+    private rules;
+    get side(): SideType;
+    get name(): string;
+    isPlayable(): boolean;
+    hasVeteranUnit(objectType: ObjectType, name: string): boolean;
+}
+
+/** Data structure for rules.ini country sections */
+export declare class CountryRules {
+    side: SideType;
+    /** string identifier */
+    name: string;
+    /** translation key */
+    uiName: string;
+    /** translation key */
+    uiTooltip: string | undefined;
+    /** allowed in multiplayer */
+    multiplay: boolean;
+    multiplayPassive: boolean;
+    veteranAircraft: string[];
+    veteranInfantry: string[];
+    veteranUnits: string[];
+    readIni(ini: IniSection): void;
+}
+
+export declare class CrateRules {
+    /** Crates can never exceed this quantity */
+    crateMaximum: number;
+    /**
+     * Minimum number of crates to be on the map at any given time.
+     * This is normally one crate per human player although it will never be below this number.
+     */
+    crateMinimum: number;
+    /** The radius, in cells, that crate powerup bonuses (e.g. armor or speed) will affect. */
+    crateRadius: number;
+    /** Average minutes between random powerup crate regeneration */
+    crateRegen: number;
+    /**
+     * Specify the unit which a player gets from a crate.
+     * If this is not set then the game will pick a unit randomly from those that do not have CrateGoodie=no set
+     */
+    unitCrateType: string | undefined;
+    healCrateSound: string;
+    /** The OverlayType to use as an image for the standard crate */
+    crateImg: string;
+    waterCrateImg: string;
+    /** Give free MCV from crate if no buildings but still has money */
+    freeMCV: boolean;
+    readIni(ini: IniSection): this;
+}
+
+export declare interface CreateBaseOpts {
+    mapName: string;
+    gameMode: number;
+    shortGame: boolean;
+    mcvRepacks: boolean;
+    cratesAppear: boolean;
+    superWeapons: boolean;
+    gameSpeed: number;
+    credits: number;
+    unitCount: number;
+    buildOffAlly: boolean;
+}
+
+export declare interface CreateOfflineOpts extends CreateBaseOpts {
+    online?: false;
+    agents: Bot[];
+}
+
+export declare interface CreateOnlineOpts extends CreateBaseOpts {
+    online: true;
+    serverUrl: string;
+    clientUrl: string;
+    agents: [Bot, ...Agent[]];
+}
+
+export declare type CreateOpts = CreateOfflineOpts | CreateOnlineOpts;
+
+export declare class CrewRules {
+    alliedCrew: string;
+    alliedSurvivorDivisor: number;
+    crewEscape: number;
+    sovietCrew: string;
+    sovietSurvivorDivisor: number;
+    survivorRate: number;
+    readIni(ini: IniSection): this;
+}
+
+export declare class DMislRules extends MissileRules {
+    readIni(ini: IniSection): this;
+}
+
+export declare interface FactoryData {
+    status: FactoryStatus;
+    /** The unit currently being delivered by the factory, if its status is {@link FactoryStatus.Delivering} */
+    deliveringUnit: number | undefined;
+}
+
+export declare enum FactoryStatus {
+    Idle = 0,
+    Delivering = 1
+}
+
+export declare enum FactoryType {
+    None = 0,
+    BuildingType = 1,
+    InfantryType = 2,
+    /**
+     * Includes only ground vehicles or those considered as aircrafts which are produces from a war factory.
+     * Unlike original game, naval factory type is now split into its own type.
+     */
+    UnitType = 3,
+    /** Original game uses a single UnitType for both naval and non-naval units */
+    NavalUnitType = 4,
+    AircraftType = 5
+}
+
+export declare class GameApi {
+    #private;
+    mapApi: MapApi;
+    rulesApi: RulesApi;
+    isPlayerDefeated(playerName: string): boolean;
+    areAlliedPlayers(p1Name: string, p2Name: string): boolean;
+    canPlaceBuilding(playerName: string, buildingName: string, tile: Tile): boolean;
+    getBuildingPlacementData(objName: string): BuildingPlacementData;
+    getPlayers(): string[];
+    getPlayerData(playerName: string): PlayerData;
+    getAllTerrainObjects(): number[];
+    getAllUnits(): number[];
+    /**
+     * Gets a list of units which are visible to the given player (not under the shroud), based on hostility
+     *
+     * An additional filter predicate can be passed to further narrow down results
+     */
+    getVisibleUnits(playerName: string, type: "self" | "allied" | "hostile", filter?: (r: TechnoRules) => boolean): number[];
+    getGameObjectData(objId: number): GameObjectData | undefined;
+    getUnitData(unitId: number): UnitData | undefined;
+    getAllSuperWeaponData(): SuperWeaponData[];
+    /** Returns a data structure that wraps the rules.ini [General] section */
+    getGeneralRules(): GeneralRules;
+    getRulesIni(): IniFile;
+    getArtIni(): IniFile;
+    /**
+     * Generates a random integer in the specified [min, max] interval using the internal PRNG.
+     * Must be used instead of Math.random() when computing game state to prevent desyncs between clients
+     */
+    generateRandomInt(min: number, max: number): number;
+    /**
+     * Generates a random float in the [0,1) interval using the internal PRNG.
+     * Must be used instead of Math.random() when computing game state to prevent desyncs between clients
+     */
+    generateRandom(): number;
+    /** Current game speed in ticks/second. IMPORTANT: The game speed can change during a game */
+    getTickRate(): number;
+    getCurrentTick(): number;
+}
+
+export declare class GameInstanceApi {
+    #private;
+    isFinished(): boolean;
+    /** Advances the game turn in offline mode or waits for the next turn in online mode */
+    update(): Promise<void>;
+    getCurrentTick(): number;
+    getTickRate(): number;
+    getPlayerStats(): PlayerStats[];
+    saveReplay(targetDir?: string): void;
+    dispose(): void;
+}
+
+export declare interface GameObjectData {
+    id: number;
+    type: ObjectType;
+    /** The name of the object, given by its rules.ini section label */
+    name: string;
+    /** Data structure that corresponds to the rules.ini section for this object type */
+    rules: ObjectRules;
+    /** What tile the object is currently on. If the object occupies more than one tile, this is the top-most tile */
+    tile: Tile;
+    /** The object position in world space */
+    worldPosition: THREE.Vector3;
+    /** The object elevation above the ground, in Z levels */
+    tileElevation: number;
+    /** The size in tiles occupied by this object */
+    foundation: Size;
+    /** The current HP */
+    hitPoints?: number;
+    /** The maximum HP */
+    maxHitPoints?: number;
+}
+
+export declare class GeneralRules {
+    aircraftFogReveal: number;
+    alliedDisguise: string;
+    baseUnit: string[];
+    bridgeVoxelMax: number;
+    /** general build speed [time (in minutes) to produce a 1000 credit cost item] */
+    buildSpeed: number;
+    /** Average minutes that building build-up animation runs */
+    buildupTime: number;
+    chronoDelay: number;
+    chronoDistanceFactor: number;
+    chronoHarvTooFarDistance: number;
+    chronoMinimumDelay: number;
+    chronoRangeMinimum: number;
+    chronoTrigger: boolean;
+    cliffBackImpassability: number;
+    cloakDelay: number;
+    closeEnough: number;
+    crew: CrewRules;
+    defaultMirageDisguises: string[];
+    dMisl: DMislRules;
+    engineer: string;
+    flightLevel: number;
+    guardAreaTargetingDelay: number;
+    harvesterTooFarDistance: number;
+    harvesterUnit: string[];
+    hover: HoverRules;
+    infantryBlinkDisguiseTime: number;
+    lightningStorm: LightningStormRules;
+    lowPowerPenaltyModifier: number;
+    minLowPowerProductionSpeed: number;
+    maxLowPowerProductionSpeed: number;
+    maximumCheerRate: number;
+    maximumQueuedObjects: number;
+    maxWaypointPathLength: number;
+    multipleFactory: number;
+    /** Used to provide explicit control of targeting rates in frames, when not engaged in a mission or AI trigger. */
+    normalTargetingDelay: number;
+    padAircraft: string[];
+    /** Fall speed in cells / second */
+    parachuteMaxFallRate: number;
+    paradrop: ParadropRules;
+    prereqCategories: Map<PrereqCategory, string[]>;
+    prism: PrismRules;
+    purifierBonus: number;
+    radar: RadarRules;
+    refundPercent: number;
+    repair: RepairRules;
+    shipSinkingWeight: number;
+    sovietDisguise: string;
+    spyMoneyStealPercent: number;
+    spyPowerBlackout: number;
+    technician: string;
+    threat: ThreatRules;
+    treeStrength: number;
+    v3Rocket: V3RocketRules;
+    veteran: VeteranRules;
+    wallBuildSpeedCoefficient: number;
+    readIni(ini: IniSection): void;
+    private readPrereqCategories;
+    getMissileRules(type: string): V3RocketRules | DMislRules;
+}
+
+export declare class HoverRules {
+    height: number;
+    dampen: number;
+    bob: number;
+    boost: number;
+    acceleration: number;
+    brake: number;
+    readIni(ini: IniSection): this;
+}
+
+/** Infantry death types, based on warhead */
+export declare enum InfDeathType {
+    None = 0,
+    /** Twirl death (plays Die1 sequence) */
+    Gunfire = 1,
+    /** High explosive death (plays Die2 seq) */
+    Explode = 2,
+    /** Flying death (armor piercing). Plays anim specified by "InfantryExplode" in rules.ini */
+    ExplodeAlt = 3,
+    /** Burn death. Plays animation specified by "FlamingInfantry" in rules.ini */
+    Fire = 4,
+    /** Electro death. Plays animation specified by 2nd item in rules.ini [Animations] array */
+    Electro = 5,
+    /** Yuri deployed death. Plays animation specified by "InfantryHeadPop" */
+    HeadExplode = 6,
+    /** Nuke death. Plays animation specified by "InfantryNuked" */
+    Nuke = 7
+}
+
+export declare class IniFile {
+    private sections;
+    fromString(data: string): this;
+    fromJson(data: Record<string, unknown>): void;
+    toString(): string;
+    clone(): IniFile;
+    getOrCreateSection(name: string): IniSection;
+    getSection(name: string): IniSection | undefined;
+    getOrderedSections(): IniSection[];
+    private isValueArray;
+    mergeWith(ini: IniFile): this;
+}
+
+export declare class IniSection {
+    name: string;
+    entries: Map<string, string>;
+    constructor(name: string);
+    clone(): IniSection;
+    set(name: string, value: string): void;
+    get(name: string): string | undefined;
+    has(name: string): boolean;
+    getString(name: string, defaultValue?: string): string;
+    getNumber(key: string, defaultValue?: number): number;
+    /**
+     * Parses an integer, decimal number (e.g. "1.23" or ".2") or percent value (e.g "20%") string into a regular
+     * JavaScript IEEE 754 floating-point number representation
+     */
+    private parseNumber;
+    /**
+     * Reads a decimal number (e.g. "1.23" or ".2") or percent value (e.g "20%") string into a regular JavaScript
+     * IEEE 754 floating-point representation, but emulates fixed-point precision.
+     *
+     * See https://github.com/electronicarts/CnC_Remastered_Collection/blob/master/REDALERT/FIXED.CPP
+     */
+    getFixed(key: string, defaultValue?: number): number;
+    /** Emulates fixed-point precision given a floating-point number */
+    private toFixedPointPrecision;
+    getBool(key: string, defaultValue?: boolean): boolean;
+    getArray(key: string, sep?: RegExp, defaultValue?: never[]): string[];
+    getNumberArray(key: string, sep?: RegExp, defaultValue?: number[]): number[];
+    getFixedArray(key: string, sep?: RegExp, defaultValue?: number[]): number[];
+    getEnum<T>(key: string, enumType: any, defaultValue: T, caseInsensitive?: boolean): T;
+    getEnumArray<T>(key: string, enumType: any, sep?: RegExp, defaultValue?: T[], caseInsensitive?: boolean): T[];
+    getHighestNumericIndex(): number;
+    getConcatenatedValues(): string;
+    toString(): string;
+}
+
+export declare interface IsoTile {
+    dx: number;
+    dy: number;
+    rx: number;
+    ry: number;
+    z: number;
+    tileNum: number;
+    subTile: number;
+}
+
+export declare enum LandTargeting {
+    LandOk = 0,
+    LandNotOk = 1,
+    /** Can shoot land, but only with secondary weapon */
+    LandSecondary = 2
+}
+
+export declare enum LandType {
+    /** normal clear terrain */
+    Clear = 0,
+    /** roads (both dirt and paved) */
+    Road = 1,
+    /** rocky terrain (including rocks themselves) */
+    Rock = 2,
+    /** where water joins land */
+    Beach = 3,
+    /** rough terrain (debris for example) */
+    Rough = 4,
+    /** ice covering water (although this may be disabled in Red Alert 2) */
+    /** Train tracks (works in Tiberian Sun, in Red Alert 2 requires Terrain Expansion (aka TX)). */
+    Railroad = 5,
+    /** Tunnel entrance/exit (works in Tiberian Sun, in Red Alert 2 requires Terrain Expansion (aka TX)). */
+    /** Tiberium Veins (Works in TS, in RA2 it is not assigned to anything and can be used for new movement rules). */
+    /** Water as in lakes or ocean areas. */
+    Water = 6,
+    /** Non-firestorm/non-laserfence walls. */
+    Wall = 7,
+    /** Ore/Gem/Tiberium overlays. */
+    Tiberium = 8,
+    /** Cliffs (before Red Alert 2 Rock was used for cliffs). */
+    Cliff = 9
+}
+
+export declare class LightningStormRules {
+    deferment: number;
+    damage: number;
+    duration: number;
+    warhead: string;
+    hitDelay: number;
+    scatterDelay: number;
+    cellSpread: number;
+    separation: number;
+    readIni(ini: IniSection): this;
+}
+
+export declare enum LocomotorType {
+    Statue = 0,
+    Aircraft = 1,
+    Chrono = 2,
+    Hover = 3,
+    Infantry = 4,
+    Jumpjet = 5,
+    Missile = 6,
+    Ship = 7,
+    Vehicle = 8
+}
+
+export declare class MapApi {
+    #private;
+    /** Tile coordinates for each player starting position */
+    getStartingLocations(): Point2D[];
+    getTheaterType(): TheaterType;
+    getTile(rx: number, ry: number): Tile | undefined;
+    getTilesInRect(baseTile: Tile, size: Size): Tile[];
+    getObjectsOnTile(tile: Tile): number[];
+    hasBridgeOnTile(tile: Tile): boolean;
+    hasHighBridgeOnTile(tile: Tile): boolean;
+    isPassableTile(tile: Tile, speedType: SpeedType, onBridge: boolean): boolean;
+    /** If the tile is not covered by shroud for the specified player */
+    isVisibleTile(tile: Tile, playerName: string): boolean;
+    getTileResourceData(tile: Tile): TileResourceData | undefined;
+    getAllTilesResourceData(): TileResourceData[];
+}
+
+export declare class MissileRules {
+    /** How many frames the rocket pauses on the launcher before tilting */
+    pauseFrames: number;
+    /** How many frames it takes for the V3 rocket to tilt to firing position */
+    tiltFrames: number;
+    /** Starting pitch of the rocket before tilting up (0=horizontal,1=vertical) */
+    pitchInitial: number;
+    /** Ending pitch of the rocket after tilting up; now it fires */
+    pitchFinal: number;
+    /** Pitch maneuverability of rocket in air.  Adjust by trial and error. */
+    turnRate: number;
+    /** This much is added to the rocket's velocity each frame during launch */
+    acceleration: number;
+    /** Cruising altitude in leptons: at this height rocket BEGINS leveling off */
+    altitude: number;
+    /** Exploding V3 does this much damage (at center of explosion, presumably). */
+    damage: number;
+    /** Exploding V3 does this much damage (at center of explosion, presumably). */
+    eliteDamage: number;
+    /** The body of the rocket is this many leptons long */
+    bodyLength: number;
+    /** The rocket's path is a big, lazy curve.  V3 yes.  DMisl no. */
+    lazyCurve: boolean;
+    type: string;
+}
+
+export declare enum MovementZone {
+    /** when pathfinding, the unit will consider both ground and water as passable. */
+    Amphibious = 0,
+    /**
+     * When pathfinding, the unit will consider both ground and water as passible.
+     * In addition, it will assume that it is capable of crushing infantry, but is unarmed.1.
+     */
+    AmphibiousCrusher = 1,
+    /**
+     * Same as above, additionally can destroy terrain obstacles.
+     * In RA2 this is tied to being an amphibious infantry.
+     */
+    AmphibiousDestroyer = 2,
+    /**
+     * when pathfinding, only clear ground is considered passable.
+     * Also assumes that it can crush infantry, but is not armed.1
+     */
+    Crusher = 3,
+    /** Same as above, additionally assumes that it can crush any mobile object, as well as walls. 2 */
+    CrusherAll = 4,
+    /** when pathfinding, considers ground passable. Can destroy terrain obstacles and crush infantry obstacles. */
+    Destroyer = 5,
+    /** when pathfinding, it assumes everything passable. */
+    Fly = 6,
+    /** when pathfinding, only clear ground is considered passable. */
+    Infantry = 7,
+    /** Same as above, but can destroy terrain obstacles such as trees. */
+    InfantryDestroyer = 8,
+    /**
+     * when pathfinding, considers clear ground passable.
+     * Assumes it can destroy terrain obstacles and crush infantry.
+     */
+    Normal = 9,
+    /**
+     * when pathfinding, considers clear ground passable.
+     * When destination is too far away for surface travel, or there is an obstacle in the way,
+     * unit will dig underground. Unit cannot dig on pavement.
+     * In other cases, when subterranean travel is not possible, or surface travel is quicker,
+     * acts like a unit with MovementZone=Crusher or MovementZone=Destroyer.
+     */
+    Subterranean = 10,
+    /** when pathfinding, considers only water as passable. */
+    Water = 11
+}
+
+export declare enum NavalTargeting {
+    /** Can't shoot at all at underwater */
+    UnderwaterNever = 0,
+    /** Use Second weapon against underwater */
+    UnderwaterSecondary = 1,
+    /** Can only shoot underwater */
+    UnderwaterOnly = 2,
+    /** Use second Weapon on organic */
+    OrganicSecondary = 3,
+    /** Primary on Amphibious and organic, Second on Naval and underwater-not-organic */
+    SealSpecial = 4,
+    /** Go ahead and shoot everything with Primary */
+    NavalAll = 5,
+    /** Don't even shoot into the water */
+    NavalNone = 6
+}
+
+export declare interface ObjectDestroyApiEvent {
+    type: ApiEventType.ObjectDestroy;
+    target: number;
+    attackerInfo: {
+        playerName: string;
+        objId?: number;
+        weaponName?: string;
+    } | undefined;
+}
+
+export declare interface ObjectOwnerChangeApiEvent {
+    type: ApiEventType.ObjectOwnerChange;
+    target: number;
+    prevOwnerName: string;
+    newOwnerName: string;
+}
+
+/** Base class for rules.ini game entity sections */
+export declare class ObjectRules {
+    type: ObjectType;
+    protected ini: IniSection;
+    static readonly IMAGE_NONE = "none";
+    alphaImage: string | undefined;
+    /** Only for SHP-based entities */
+    alternateArcticArt: boolean;
+    crushable: boolean;
+    crushSound: string | undefined;
+    dontScore: boolean;
+    /** Makes the object ignored for scoring and killing purposes */
+    insignificant: boolean;
+    /** If this object can be targeted or fired upon */
+    legalTarget: boolean;
+    /** This is an override for art.ini Shadow */
+    noShadow: boolean;
+    uiName: string;
+    static iniSpeedToLeptonsPerTick(iniSpeed: number): number;
+    static iniRotToDegsPerTick(iniRot: number): number;
+    constructor(type: ObjectType, ini: IniSection);
+    protected parse(): void;
+    get name(): string;
+    get imageName(): string;
+}
+
+export declare interface ObjectSpawnUnspawnApiEvent {
+    type: ApiEventType.ObjectSpawn | ApiEventType.ObjectUnspawn;
+    target: number;
+}
+
+export declare enum ObjectType {
+    None = 0,
+    Aircraft = 1,
+    Building = 2,
+    Infantry = 3,
+    Overlay = 4,
+    Smudge = 5,
+    Terrain = 6,
+    Vehicle = 7,
+    Animation = 8,
+    Projectile = 9,
+    VoxelAnim = 10,
+    Debris = 11
+}
+
+export declare enum OrderType {
+    Move = 0,
+    ForceMove = 1,
+    Attack = 2,
+    ForceAttack = 3,
+    AttackMove = 4,
+    Guard = 5,
+    GuardArea = 6,
+    Capture = 7,
+    Occupy = 8,
+    Deploy = 9,
+    DeploySelected = 10,
+    Stop = 11,
+    Cheer = 12,
+    Dock = 13,
+    Gather = 14,
+    Repair = 15,
+    Scatter = 16,
+    EnterTransport = 17,
+    PlaceBomb = 18
+}
+
+/** Data structure for rules.ini overlay types */
+export declare class OverlayRules extends ObjectRules {
+    armor: ArmorType;
+    crate: boolean;
+    isARock: boolean;
+    /** See https://www.modenc.renegadeprojects.com/IsRubble */
+    isRubble: boolean;
+    isVeinholeMonster: boolean;
+    isVeins: boolean;
+    /** Only for overlays - Specifies the type of land that this overlay forms when placed on the map. */
+    land: LandType;
+    noUseTileLandType: boolean;
+    radarInvisible: boolean;
+    strength: number;
+    tiberium: boolean;
+    wall: boolean;
+    protected parse(): void;
+}
+
+export declare class ParadropRules {
+    allyParaDrop: ParadropSquad[];
+    amerParaDrop: ParadropSquad[];
+    paradropPlane: string;
+    /** In leptons */
+    paradropRadius: number;
+    sovParaDrop: ParadropSquad[];
+    readIni(ini: IniSection): this;
+    private readParadropSquad;
+    getParadropSquads(sideType: SideType): ParadropSquad[];
+}
+
+export declare interface ParadropSquad {
+    /** Infantry name */
+    inf: string;
+    /** Number of units to drop */
+    num: number;
+}
+
+export declare enum PipColor {
+    Green = 0,
+    Yellow = 1,
+    White = 2,
+    Red = 3,
+    Blue = 4
+}
+
+export declare interface PlayerData {
+    name: string;
+    country: Country | undefined;
+    /** The starting tile coordinates for the player (where the initial MCV is placed) */
+    startLocation: Point2D;
+    isObserver: boolean;
+    /** Whether the player is an integrated AI. Not applicable to sandbox agents. */
+    isAi: boolean;
+    /** Whether the player is not an observer and hasn't been defeated */
+    isCombatant: boolean;
+    credits: number;
+    power: PowerData;
+    radarDisabled: boolean;
+}
+
+export declare interface PlayerStats {
+    name: string;
+    country: Country;
+    ai: boolean;
+    defeated: boolean;
+    credits: number;
+    startLocation: number;
+}
+
+export declare interface Point2D {
+    x: number;
+    y: number;
+}
+
+export declare interface PowerData {
+    /** Total power generated by buildings such as power plants */
+    total: number;
+    /** How much power is consumed */
+    drain: number;
+    /** If the base is on low power (e.g. the power drain is larger than the generated power, or power sabotaged) */
+    isLowPower: boolean;
+}
+
+export declare enum PrereqCategory {
+    Power = 0,
+    Factory = 1,
+    Barracks = 2,
+    Radar = 3,
+    Tech = 4,
+    Proc = 5
+}
+
+export declare class PrismRules {
+    type: string;
+    supportHeight: number;
+    supportMax: number;
+    supportModifier: number;
+    readIni(ini: IniSection): this;
+}
+
+export declare class ProductionApi {
+    #private;
+    isAvailableForProduction(objRules: TechnoRules): boolean;
+    getAvailableObjects(queueType?: QueueType): TechnoRules[];
+    getQueueTypeForObject(objRules: TechnoRules): QueueType;
+    getQueueData(queueType: QueueType): QueueData;
+}
+
+export declare class ProjectileRules extends ObjectRules {
+    acceleration: number;
+    arcing: boolean;
+    courseLockDuration: number;
+    detonationAltitude: number;
+    /**
+     * If set, the projectile will be drawn in the unit palette regardless of the settings in projectile image code.
+     * This also makes the projectile remappable.
+     */
+    firersPalette: boolean;
+    flakScatter: boolean;
+    inaccurate: boolean;
+    inviso: boolean;
+    isAntiAir: boolean;
+    /** No = can't force fire at ground, but can still attack objects on the ground, unless LandTargeting=1 */
+    isAntiGround: boolean;
+    level: boolean;
+    /** Rate of turn in degs/tick */
+    rot: number;
+    /** Original ROT value from INI */
+    iniRot: number;
+    shrapnelWeapon: string | undefined;
+    shrapnelCount: number;
+    subjectToCliffs: boolean;
+    subjectToElevation: boolean;
+    subjectToWalls: boolean;
+    vertical: boolean;
+    protected parse(): void;
+}
+
+export declare class PublicApi {
+    #private;
+    init(mixDir: string): Promise<void>;
+    getAvailableMaps(): string[];
+    getAvailableGameModes(mapName: string): number[];
+    /**
+     * Creates a new game
+     *
+     * If {@link CreateOfflineOpts.online} is false, an offline game is created, in which multiple AI agents can battle
+     * each other in a sandboxed environment. The game simulation runs programatically at the fastest possible speed.
+     *
+     * If {@link CreateOnlineOpts.online} is true, an online game is created, in which human players can fight
+     * in real time against the AI.
+     *
+     * In online mode, the {@link CreateOnlineOpts.agents} array specifies both human and AI agents. In this case,
+     * there can be only one AI agent (the game host) and it must be the first item in the array.
+     */
+    createGame(opts: CreateOpts): Promise<GameInstanceApi>;
+}
+
+export declare interface QueueData {
+    size: number;
+    maxSize: number;
+    status: QueueStatus;
+    type: QueueType;
+    items: QueueItemData[];
+}
+
+export declare interface QueueItemData {
+    rules: TechnoRules;
+    quantity: number;
+}
+
+export declare enum QueueStatus {
+    Idle = 0,
+    Active = 1,
+    /** Production is paused */
+    OnHold = 2,
+    /** First item is ready and is waiting to be removed before starting the next */
+    Ready = 3
+}
+
+export declare enum QueueType {
+    Structures = 0,
+    Armory = 1,
+    Infantry = 2,
+    Vehicles = 3,
+    Aircrafts = 4,
+    Ships = 5
+}
+
+export declare enum RadarEventType {
+    GenericCombat = 0,
+    GenericNonCombat = 1,
+    DropZone = 2,
+    BaseUnderAttack = 3,
+    HarvesterUnderAttack = 4,
+    EnemyObjectSensed = 5
+}
+
+export declare class RadarRules {
+    /** suppression distance in cells */
+    private eventSuppressionDistances;
+    /** event visibility in frames */
+    private eventVisibilityDurations;
+    /** event duration in frames */
+    private eventDurations;
+    flashFrameTime: number;
+    combatFlashTime: number;
+    eventMinRadius: number;
+    eventSpeed: number;
+    eventRotationSpeed: number;
+    eventColorSpeed: number;
+    readIni(ini: IniSection): this;
+    getEventSuppresionDistance(type: RadarEventType): number;
+    getEventVisibilityDuration(type: RadarEventType): number;
+    getEventDuration(type: RadarEventType): number;
+}
+
+export declare class RadiationRules {
+    /**
+     * Number of frames site lasts per level of radiation.
+     *
+     * When rad level goes to zero, rad site deletes itself.
+     * --&gt; Site lasts ( Level x RadDurationMultiple ) frames.
+     * For reference, the Nuke puts down 2000 units of radiation.
+     * A mult. of 3 frames means the rad site is active for 6000
+     * frames -- something over 3 minutes at 30 Hz.
+     */
+    radDurationMultiple: number;
+    /** Delay between times when radiation is applied to units. */
+    radApplicationDelay: number;
+    /**
+     * Maximum radiation allowable in a cell. The cell can actually have more radiation
+     * but it will only damage as if it had the maximum level.
+     */
+    radLevelMax: number;
+    /**
+     * Delay in frames between radiation level decrements.
+     *
+     * The level updates this often, but the rate is still as specified
+     * in RadDurationMultiple.
+     */
+    radLevelDelay: number;
+    /**
+     * Delay in frames between radiation lighting intensity decrements.
+     * This should never be less than the RadLevelDelay, as it will
+     * produce no visual benefit and just waste processor cycles.
+     */
+    radLightDelay: number;
+    /** Scales damage done by a given radiation level. */
+    radLevelFactor: number;
+    /** Scales the factor brightness plays in the radiation display. */
+    radLightFactor: number;
+    /** Scales the factor tint plays in the radiation display. */
+    radTintFactor: number;
+    /** The color of the radiation. (0-255 rgb array) */
+    radColor: number[];
+    /** Sets the warhead used by irradiated tiles. */
+    radSiteWarhead: string;
+    readIni(ini: IniSection): void;
+}
+
+export declare class RepairRules {
+    /** minutes to reload each ammo point for aircraft or helicopters (also affects repair rate) */
+    reloadRate: number;
+    /** percent cost to fully repair as ratio of full cost */
+    repairPercent: number;
+    /** minutes between applying repair step */
+    repairRate: number;
+    /** hit points to heal per repair 'tick' */
+    repairStep: number;
+    /** [units only] minutes between applying repair step */
+    uRepairRate: number;
+    /** [infantry only] minutes between applying repair step */
+    iRepairRate: number;
+    /** [infantry only] hit points to heal per repair 'tick' for infantry */
+    iRepairStep: number;
+    readIni(ini: IniSection): this;
+}
+
+export declare class RulesApi {
+    #private;
+    get allObjectRules(): Map<ObjectType, Map<string, ObjectRules>>;
+    get buildingRules(): Map<string, TechnoRules>;
+    get infantryRules(): Map<string, TechnoRules>;
+    get vehicleRules(): Map<string, TechnoRules>;
+    get aircraftRules(): Map<string, TechnoRules>;
+    get terrainRules(): Map<string, TerrainRules>;
+    get overlayRules(): Map<string, OverlayRules>;
+    get countryRules(): Map<string, CountryRules>;
+    get general(): GeneralRules;
+    get ai(): AiRules;
+    get crateRules(): CrateRules;
+    get combatDamage(): CombatDamageRules;
+    get radiation(): RadiationRules;
+    hasObject(name: string, type: ObjectType): boolean | undefined;
+    getObject(name: string, type: ObjectType): ObjectRules;
+    getBuilding(name: string): TechnoRules;
+    getWeapon(name: string): WeaponRules;
+    getWarhead(name: string): WarheadRules;
+    getProjectile(name: string): ProjectileRules;
+    getOverlayName(id: number): string;
+    getOverlayId(name: string): number;
+    getOverlay(name: string): OverlayRules;
+    getCountry(name: string): CountryRules;
+    getMultiplayerCountries(): CountryRules[];
+    getIni(): IniFile;
+}
+
+/** Side/faction types (ally/soviet). Relic naming since tiberian sun */
+export declare enum SideType {
+    GDI = 0,
+    Nod = 1,
+    Civilian = 2,
+    Mutant = 3
+}
+
+export declare interface Size {
+    width: number;
+    height: number;
+}
+
+export declare enum SpeedType {
+    Foot = 0,
+    Track = 1,
+    Wheel = 2,
+    Hover = 3,
+    Float = 4,
+    FloatBeach = 5,
+    Amphibious = 6,
+    Winged = 7
+}
+
+export declare enum StanceType {
+    None = 0,
+    Guard = 1,
+    Prone = 2,
+    Deployed = 3,
+    Paradrop = 4,
+    Cheer = 5
+}
+
+export declare interface SuperWeaponData {
+    playerName: string;
+    type: SuperWeaponType;
+    status: SuperWeaponStatus;
+    timerSeconds: number;
+}
+
+export declare enum SuperWeaponStatus {
+    Charging = 0,
+    Paused = 1,
+    Ready = 2
+}
+
+export declare enum SuperWeaponType {
+    MultiMissile = 0,
+    IronCurtain = 1,
+    LightningStorm = 2,
+    ChronoSphere = 3,
+    ChronoWarp = 4,
+    ParaDrop = 5,
+    AmerParaDrop = 6
+}
+
+/** Data structure for rules.ini tehno types sections (buildings, infantry, vehicles, aircrafts) */
+export declare class TechnoRules extends ObjectRules {
+    static readonly MAX_SIGHT = 11;
+    /** Magic number that corrects infantry/projectile speed relative to vehicles */
+    static readonly MAGIC_SPEED_MULT = 0.65;
+    /** Countries that can build this */
+    owner: string[];
+    /** Side that building belongs to; should match SideType enum values */
+    aiBasePlanningSide: SideType | undefined;
+    /** Building category - used for sidebar placement */
+    buildCat: BuildCat;
+    /** -1 = can't build */
+    techLevel: number;
+    prerequisite: string[];
+    private requiredHouses;
+    private forbiddenHouses;
+    requiresStolenAlliedTech: boolean;
+    requiresStolenSovietTech: boolean;
+    cost: number;
+    points: number;
+    soylent: number;
+    crateGoodie: boolean;
+    /**
+     * Only for buildings
+     * Positive values indicate that it produces power (e.g. a Power Plant) and
+     * negative values indicate that it uses (drains) power.
+     */
+    power: number;
+    /** Only for buildings */
+    powered: boolean;
+    /** Max placement distance from other buildings */
+    adjacent: number;
+    /** Considered for adjacency checks? */
+    baseNormal: boolean;
+    /**
+     * How many can be built
+     *
+     * Omit = no limit;
+     * 0 = only AI allowed to build, don't show in sidebar;
+     * &lt;0 (UNSUPPORTED) = the absolute value limits the number of units that can be trained for the entire match
+     */
+    buildLimit: number;
+    airRangeBonus: number;
+    /**
+     * For walls this is the connect distance. For other types overrides weapon range when scanning for targets.
+     * Despite the name, this doesn't seem to be used in guard area mode
+     */
+    guardRange: number;
+    defaultToGuardArea: boolean;
+    /** Only for buildings */
+    eligibileForAllyBuilding: boolean;
+    numberImpassableRows: number;
+    bridgeRepairHut: boolean;
+    constructionYard: boolean;
+    refinery: boolean;
+    factory: FactoryType;
+    weaponsFactory: boolean;
+    helipad: boolean;
+    hospital: boolean;
+    unitRepair: boolean;
+    unitReload: boolean;
+    isBaseDefense: boolean;
+    superWeapon: string;
+    chargedAnimTime: number;
+    naval: boolean;
+    underwater: boolean;
+    waterBound: boolean;
+    orePurifier: boolean;
+    cloning: boolean;
+    nukeSilo: boolean;
+    /** Only for buildings */
+    repairable: boolean;
+    /** Only for buildings */
+    clickRepairable: boolean;
+    unsellable: boolean;
+    gdiBarracks: boolean;
+    nodBarracks: boolean;
+    numberOfDocks: number;
+    landTargeting: LandTargeting;
+    navalTargeting: NavalTargeting;
+    tooBigToFitUnderBridge: boolean;
+    canBeOccupied: boolean;
+    maxNumberOccupants: number;
+    leaveRubble: boolean;
+    undeploysInto: string;
+    deploysInto: string;
+    capturable: boolean;
+    spyable: boolean;
+    needsEngineer: boolean;
+    c4: boolean;
+    /** Only for buildings */
+    canC4: boolean;
+    /** credits when captured from the Neutral house */
+    produceCashStartup: number;
+    /** Amount every Delay */
+    produceCashAmount: number;
+    /** Frame delay between Amounts */
+    produceCashDelay: number;
+    /** For infantry and vehicles */
+    ifvMode: number;
+    turretIndexesByIfvMode: Map<number, number>;
+    turret: boolean;
+    turretCount: number;
+    explosion: string[];
+    explodes: boolean;
+    turretAnim: string;
+    turretAnimIsVoxel: boolean;
+    turretAnimX: number;
+    turretAnimY: number;
+    turretAnimZAdjust: number;
+    isChargeTurret: boolean;
+    overpowerable: boolean;
+    freeUnit: string;
+    primary: string | undefined;
+    secondary: string | undefined;
+    elitePrimary: string | undefined;
+    eliteSecondary: string | undefined;
+    /** Special weapon count. If greater than zero, (Elite)Weapon%d values are used over (Elite)Primary/Secondary */
+    weaponCount: number;
+    deathWeapon: string | undefined;
+    deathWeaponDamageModifier: number;
+    veteranAbilities: Set<VeteranAbility>;
+    eliteAbilities: Set<VeteranAbility>;
+    selfHealing: boolean;
+    wall: boolean;
+    gate: boolean;
+    armor: ArmorType;
+    strength: number;
+    immune: boolean;
+    immuneToRadiation: boolean;
+    immuneToPsionics: boolean;
+    typeImmune: boolean;
+    warpable: boolean;
+    /** Only for vehicles */
+    isTilter: boolean;
+    /** Only for shp vehicles */
+    walkRate: number;
+    /** Only for vehicles */
+    idleRate: number;
+    /** Only for vehicles that spawn child units */
+    noSpawnAlt: boolean;
+    /** Only for vehicles */
+    crusher: boolean;
+    /** Only for vehicles and infantry */
+    consideredAircraft: boolean;
+    /** Only for infantry and vehicles */
+    crashable: boolean;
+    /** Only for aircrafts or other objects that are considered aircraft */
+    landable: boolean;
+    /** Only for aicrafts */
+    airportBound: boolean;
+    /** Only for aircrafts or other objects that are considered aircraft */
+    balloonHover: boolean;
+    /** Only for aircrafts or other objects that are considered aircraft */
+    hoverAttack: boolean;
+    /** Only for aircrafts */
+    omniFire: boolean;
+    /** Only for aircrafts */
+    fighter: boolean;
+    /** Only for aircrafts */
+    flightLevel: number | undefined;
+    /** Only for vehicles, aircrafts and infantry */
+    speedType: SpeedType | undefined;
+    /** Speed in leptons/tick. Only for moving units */
+    speed: number;
+    /** Only for vehicles, aircrafts and infantry */
+    locomotor: LocomotorType;
+    movementZone: MovementZone;
+    /** Only for infantry */
+    fearless: boolean;
+    /** Only for infantry and vehicles - if it has a deploy action */
+    deployer: boolean;
+    /** Only for infantry and vehicles */
+    deployFire: boolean;
+    /** Only for infantry and vehicles */
+    deployFireWeapon: WeaponType;
+    /** Only for infantry and vehicles */
+    undeployDelay: number;
+    /** Only for infantry - Can panic when attacked */
+    fraidycat: boolean;
+    /** Only for infantry */
+    isHuman: boolean;
+    /** Only for infantry */
+    organic: boolean;
+    /** Only for infantry */
+    occupier: boolean;
+    /** Only for infantry */
+    engineer: boolean;
+    /** Only for infantry */
+    ivan: boolean;
+    civilian: boolean;
+    agent: boolean;
+    infiltrate: boolean;
+    threatPosed: number;
+    specialThreatValue: number;
+    canPassiveAquire: boolean;
+    canRetaliate: boolean;
+    /** Only for units */
+    preventAttackMove: boolean;
+    /** Only for units */
+    opportunityFire: boolean;
+    distributedFire: boolean;
+    radialFireSegments: number;
+    attackCursorOnFriendlies: boolean;
+    bombable: boolean;
+    /** Whether it can be promoted */
+    trainable: boolean;
+    /** (Not infantry) Specifies whether this object is occupied by infantry which can escape when it is destroyed */
+    crewed: boolean;
+    parasiteable: boolean;
+    suppressionThreshold: number;
+    reselectIfLimboed: boolean;
+    rejoinTeamIfLimboed: boolean;
+    /** Only for vehicles */
+    weight: number;
+    accelerates: boolean;
+    accelerationFactor: number;
+    /** Only for infantry and vehicles */
+    teleporter: boolean;
+    /** Only for infantry and vehicles */
+    canDisguise: boolean;
+    /** Only for infantry and vehicles */
+    disguiseWhenStill: boolean;
+    /** Only for infantry and vehicles */
+    permaDisguise: boolean;
+    detectDisguise: boolean;
+    detectDisguiseRange: number;
+    cloakable: boolean;
+    sensors: boolean;
+    sensorArray: boolean;
+    sensorsSight: number;
+    burstDelay: (number | undefined)[];
+    vhpScan: VhpScan;
+    /** Only for infantry */
+    pip: PipColor;
+    /** Only for vehicles - for PipScale=Passengers */
+    passengers: number;
+    /** Only for vehicles - considers the first passager as a gunner (affects turret and is evac'd separately) */
+    gunner: boolean;
+    ammo: number;
+    initialAmmo: number;
+    manualReload: boolean;
+    /**
+     * Only for vehicles - for PipScale=Tiberium
+     *
+     * Number of ore "bails" (1bail = $25/$50 see [Riparius] and [Cruentus])
+     */
+    storage: number;
+    /** Only for aircraft - created by another object and therefore not player controllable */
+    spawned: boolean;
+    /** Only for vehicles - name of aircraft spawned by this unit */
+    spawns: string;
+    /** Only for vehicles - how many aircraft of "Spawns" type are spawned */
+    spawnsNumber: number;
+    /** Only for vehicles - the rate, in frames, at which this object regenerates spawned objects */
+    spawnRegenRate: number;
+    /** Only for vehicles - the rate, in frames, at which spawned are resupplied with ammo */
+    spawnReloadRate: number;
+    /** Only for aircrafts - marks as a missile spawned by another unit */
+    missileSpawn: boolean;
+    /** Storage space used inside a transport */
+    size: number;
+    /** Maximum size of a unit that is allowed to enter this unit as a passenger. */
+    sizeLimit: number;
+    sight: number;
+    spySat: boolean;
+    gapGenerator: boolean;
+    gapRadiusInCells: number;
+    psychicDetectionRadius: number;
+    hasRadialIndicator: boolean;
+    harvester: boolean;
+    unloadingClass: string;
+    /** What buildings can this unit type dock to? */
+    dock: string[];
+    /** Only for building types */
+    radar: boolean;
+    radarInvisible: boolean;
+    /** Only for building types */
+    revealToAll: boolean;
+    selectable: boolean;
+    isSelectableCombatant: boolean;
+    /**
+     * Only for buildings - Determines whether or not this object is invisible to all players ingame,
+     * including the owner. It also cannot be targeted or destroyed by any other object on the map.
+     */
+    invisibleInGame: boolean;
+    moveToShroud: boolean;
+    leadershipRating: number;
+    allowedToStartInMultiplayer: boolean;
+    /** Rate of turn for unit body/turret in degrees/tick. Also see ROT */
+    rot: number;
+    jumpjetAccel: number;
+    jumpjetClimb: number;
+    jumpjetCrash: number;
+    jumpjetDeviation: number;
+    jumpjetHeight: number;
+    jumpjetNoWobbles: boolean;
+    jumpjetSpeed: number;
+    jumpjetTurnRate: number;
+    jumpjetWobbles: number;
+    /** Only for aircraft */
+    pitchAngle: number;
+    /** Only for aircraft */
+    pitchSpeed: number;
+    damageParticleSystems: string[];
+    damageSmokeOffset: THREE.Vector3;
+    minDebris: number;
+    maxDebris: number;
+    /** Only for vehicles */
+    debrisTypes: string[];
+    /** Only for buildings */
+    debrisAnims: string[];
+    /** Only for lamps */
+    isLightpost: boolean;
+    /** Only for lamps */
+    lightVisibility: number;
+    /** Only for lamps */
+    lightIntensity: number;
+    /** Only for lamps */
+    lightRedTint: number;
+    /** Only for lamps */
+    lightGreenTint: number;
+    /** Only for lamps */
+    lightBlueTint: number;
+    ambientSound: string | undefined;
+    createSound: string | undefined;
+    deploySound: string | undefined;
+    undeploySound: string | undefined;
+    voiceSelect: string | undefined;
+    voiceMove: string | undefined;
+    voiceAttack: string | undefined;
+    voiceFeedback: string | undefined;
+    voiceSpecialAttack: string | undefined;
+    voiceEnter: string | undefined;
+    voiceCapture: string | undefined;
+    voiceCrashing: string | undefined;
+    crashingSound: string | undefined;
+    impactLandSound: string | undefined;
+    /** Take-off sound */
+    auxSound1: string | undefined;
+    /** Land sound */
+    auxSound2: string | undefined;
+    dieSound: string | undefined;
+    moveSound: string | undefined;
+    enterWaterSound: string | undefined;
+    leaveWaterSound: string | undefined;
+    turretRotateSound: string | undefined;
+    workingSound: string | undefined;
+    notWorkingSound: string | undefined;
+    chronoInSound: string | undefined;
+    chronoOutSound: string | undefined;
+    enterTransportSound: string | undefined;
+    leaveTransportSound: string | undefined;
+    protected parse(): void;
+    private parseTurretIndexes;
+    private parseBurstDelay;
+    /** If the specified country is listed as an Owner */
+    hasOwner(country: Country): boolean;
+    /** If the object is available to the specified country (meets the Required/ForbiddenHouses values) */
+    isAvailableTo(country: Country): boolean;
+    /** Only for infantry */
+    get proneWhenAttacked(): boolean;
+    getWeaponAtIndex(idx: number): string | undefined;
+    getEliteWeaponAtIndex(idx: number): string | undefined;
+}
+
+/** Data structure for rules.ini terrain types */
+export declare class TerrainRules extends ObjectRules {
+    animationRate: number;
+    animationProbability: number;
+    gate: boolean;
+    immune: boolean;
+    isAnimated: boolean;
+    radarInvisible: boolean;
+    snowOccupationBits: number;
+    spawnsTiberium: boolean;
+    strength: number;
+    temperateOccupationBits: number;
+    protected parse(): void;
+    private normalizeOccupationBits;
+    getOccupationBits(theaterType: TheaterType): number;
+    /** List of sub-cells that are occupied by this object */
+    getOccupiedSubCells(theaterType: TheaterType): number[];
+}
+
+export declare enum TerrainType {
+    Default = 0,
+    Tunnel = 5,
+    Railroad = 6,
+    Rock1 = 7,
+    Rock2 = 8,
+    Water = 9,
+    Shore = 10,
+    /** Paved road, bridge start (paved?), paved road, pavement detail, wood bridge start */
+    Pavement = 11,
+    /** Dirt road */
+    Dirt = 12,
+    /** Snow, grass */
+    Clear = 13,
+    /** Dirty snow, ice, sand */
+    Rough = 14,
+    Cliff = 15
+}
+
+export declare enum TheaterType {
+    None = 0,
+    Temperate = 1,
+    Urban = 2,
+    Snow = 4,
+    Lunar = 8,
+    Desert = 16,
+    NewUrban = 32,
+    All = 63
+}
+
+export declare class ThreatRules {
+    myEffectivenessCoefficientDefault: number;
+    targetEffectivenessCoefficientDefault: number;
+    targetSpecialThreatCoefficientDefault: number;
+    targetStrengthCoefficientDefault: number;
+    targetDistanceCoefficientDefault: number;
+    readIni(ini: IniSection): this;
+}
+
+export declare interface Tile extends IsoTile {
+    /**
+     * Raw terrain type, as found in the mapfile.
+     * This is altered by placed map objects and results in the landType property
+     */
+    terrainType: TerrainType;
+    landType: LandType;
+    /** If this tile has a bridge, it will have a different land type on the bridge */
+    onBridgeLandType: LandType | undefined;
+    rampType: number;
+    /** This is needed for generating passability graph nodes */
+    id: string;
+    /** Duplicates tile occlusion state for data locality */
+    occluded: boolean;
+}
+
+export declare interface TileResourceData {
+    tile: Tile;
+    /** Number of gem bails */
+    gems: number;
+    /** Number of ore bails */
+    ore: number;
+    /** Is this a mining drill? (tiberium tree) */
+    spawnsOre: boolean;
+}
+
+export declare interface UnitData extends GameObjectData {
+    rules: TechnoRules;
+    owner: string;
+    /** Distance in tiles at which the unit can see. Used for revealing shroud and auto-attack. */
+    sight: number;
+    veteranLevel: VeteranLevel;
+    guardMode: boolean;
+    purchaseValue: number;
+    primaryWeapon?: WeaponData;
+    secondaryWeapon?: WeaponData;
+    deathWeapon?: WeaponData;
+    attackState?: AttackState;
+    hitPoints: number;
+    maxHitPoints: number;
+    /** Facing angle in degrees (counter-clockwise, relative to world N / screen NE) */
+    direction?: number;
+    onBridge?: boolean;
+    zone?: ZoneType;
+    buildStatus?: BuildStatus;
+    factory?: FactoryData;
+    rallyPoint?: Tile;
+    isPoweredOn?: boolean;
+    garrisonUnitCount?: number;
+    garrisonUnitsMax?: number;
+    /** Facing angle of the turret in degrees, if applicable (counter-clockwise, relative to world N / screen NE) */
+    turretFacing?: number;
+    /** Which turret is currently being used, if applicable (for IFV) */
+    turretNo?: number;
+    isIdle?: boolean;
+    /** If the unit is not currently incapacitated and is able to move */
+    canMove?: boolean;
+    /** The current velocity vector in world space */
+    velocity?: THREE.Vector3;
+    /** Only applicable to infantry */
+    stance?: StanceType;
+    /** Only applicable to harvesters */
+    harvestedOre?: number;
+    /** Only applicable to harvesters */
+    harvestedGems?: number;
+    /** Only applicable to aircraft */
+    ammo?: number;
+    /** If the unit is under the effect of a chrono/temporal weapon */
+    isWarpedOut: boolean;
+    /** The ID of the unit currently mind controlling us, if applicable */
+    mindControlledBy?: number;
+    /** The number of ticks remaining until dynamite attached to this unit explodes (from Crazy Ivan) */
+    tntTimer?: number;
+}
+
+export declare class V3RocketRules extends MissileRules {
+    readIni(ini: IniSection): this;
+}
+
+export declare enum VeteranAbility {
+    FASTER = 0,
+    STRONGER = 1,
+    FIREPOWER = 2,
+    SCATTER = 3,
+    ROF = 4,
+    SIGHT = 5,
+    SELF_HEAL = 6
+}
+
+export declare enum VeteranLevel {
+    None = 0,
+    Veteran = 1,
+    Elite = 2
+}
+
+export declare class VeteranRules {
+    /** must destroy this multiple of self-value to become a veteran [per level] */
+    veteranRatio: number;
+    /** multiplier to damage */
+    veteranCombat: number;
+    /** multiplier to max speed */
+    veteranSpeed: number;
+    /** multiplier to sight */
+    veteranSight: number;
+    /** For armor, think of it as max strength being multiplied by the number (in reality, damage is divided by this */
+    veteranArmor: number;
+    /** ROF delay multiplier */
+    veteranROF: number;
+    /** maximum veteran level that can be obtained */
+    veteranCap: number;
+    /** Do initial forces start as veterans? */
+    initialVeteran: boolean;
+    readIni(ini: IniSection): this;
+}
+
+export declare enum VhpScan {
+    None = 0,
+    Normal = 1,
+    Strong = 2
+}
+
+export declare class WarheadRules {
+    private rules;
+    animList: string[];
+    bombDisarm: boolean;
+    bullets: boolean;
+    cellSpread: number;
+    /** This flag determines whether this warhead sinks and causes a water splash anim */
+    conventional: boolean;
+    culling: boolean;
+    electricAssault: boolean;
+    emEffect: boolean;
+    infDeath: InfDeathType;
+    ivanBomb: boolean;
+    makesDisguise: boolean;
+    mindControl: boolean;
+    nukeMaker: boolean;
+    paralyzes: number;
+    parasite: boolean;
+    percentAtMax: number;
+    proneDamage: number;
+    psychicDamage: boolean;
+    radiation: boolean;
+    rocker: boolean;
+    sonic: boolean;
+    temporal: boolean;
+    /** Damage multiplier per armor type */
+    verses: Map<ArmorType, number>;
+    wallAbsoluteDestroyer: boolean;
+    wall: boolean;
+    wood: boolean;
+    constructor(rules: IniSection);
+    get name(): string;
+    private parse;
+}
+
+export declare interface WeaponData {
+    type: WeaponType;
+    rules: WeaponRules;
+    projectileRules: ProjectileRules;
+    warheadRules: WarheadRules;
+    /** Minimum distance in tiles at which weapon can be fired */
+    minRange: number;
+    /** Maximum distance in tiles at which weapon can be fired */
+    maxRange: number;
+    /** Speed of the weapon's projectile in leptons/tick */
+    speed: number;
+    /** If the weapon just fired and is currently on cooldown, how many ticks remaining before it can fire again */
+    cooldownTicks: number;
+}
+
+/** Data structure for a rules.ini weapon section */
+export declare class WeaponRules {
+    private rules;
+    ambientDamage: number;
+    anim: string[];
+    areaFire: boolean;
+    burst: number;
+    cellRangefinding: boolean;
+    damage: number;
+    decloakToFire: boolean;
+    fireOnce: boolean;
+    isAlternateColor: boolean;
+    isElectricBolt: boolean;
+    isHouseColor: boolean;
+    isLaser: boolean;
+    isRadBeam: boolean;
+    isSonic: boolean;
+    laserDuration: number;
+    limboLaunch: boolean;
+    minimumRange: number;
+    name: string;
+    neverUse: boolean;
+    omniFire: boolean;
+    projectile: string;
+    radLevel: number;
+    range: number;
+    report: string[];
+    revealOnFire: boolean;
+    rof: number;
+    sabotageCursor: boolean;
+    spawner: boolean;
+    /** Speed in leptons/tick */
+    speed: number;
+    /** Original INI speed value */
+    iniSpeed: number;
+    suicide: boolean;
+    useSparkParticles: boolean;
+    warhead: string;
+    constructor(rules: IniSection);
+    private parse;
+}
+
+export declare enum WeaponType {
+    Primary = 0,
+    Secondary = 1,
+    DeathWeapon = 2
+}
+
+export declare enum ZoneType {
+    /** Unit is on the ground */
+    Ground = 0,
+    /** Unit is in the air */
+    Air = 1,
+    /** Unit is in the water */
+    Water = 2
+}
+
+export { }