(map: MapData)

(entity: Entity)

( map: MapData, unit: UnitInfo, vector: Vector, player: PlayerID, )

(behavior: AIBehavior)

(fn: (value: T, vector: Vector, index: number) => T, value: T)

( map: MapData, id: DynamicPlayerID, player = map.getCurrentPlayer().id, )

()

(skill: Skill, from: Vector | null)

( ...args: Events[T] extends undefined ? [type: T] : [type: T, detail: Events[T]] )

(ability: Ability)

(teams: Teams, players: ReadonlyArray<Player | null>)

(player: Player)

( map: MapData, vector: Vector, player: PlayerID, info: UnitInfo, offset = 0, hasLeader = _hasLead

(map: MapData)

(map: MapData)

( size: SizeVector, vectors: ReadonlyArray<Vector>, maxClusters = 10, )

( map: MapData, info: BuildingInfo, player: PlayerOrPlayerID, to: Vector, isEditor = false, )

(entity: Entity)

(y, type)

(behavior: Behavior)

(l: SpriteVector, r: SpriteVector)

()

(unitInfo: UnitInfo, tile: TileInfo)

()

({ accessBuildings, capture, convert, createBuildings, createTracks, heal, heavyEq

()

(label: PlayerIDSet | undefined)

( map: MapData, to: Vector, fields: ReadonlyMap<Vector, RadiusItem>, vision: VisionT | null, )

(id: number)

(tile: MaybeTileID)

(seed: number)

()

(damage: DamageMap)

(from: Vector, to: Vector)

()

( map: MapData, currentPlayer: Player, playerUnits: ReadonlyArray<Unit>, buildableUnits: ReadonlyArray

( map: MapData, unit: Unit, from: Vector, _targets: ReadonlyArray<Vector> | Vector, isPendingUnit =

( ...args: Events[T] extends undefined ? [type: T] : [type: T, detail: Events[T]] )

( origin: Vector, drawingMode: DrawingMode, mapSize: SizeVector, )

(id: number)

( lu: SpriteVector, ru: SpriteVector, ld: SpriteVector, rd: SpriteVector, )

( newMap: Array<TileField>, newModifiers: Array<ModifierField>, index: number, info: TileInfo | null,

(map: DamageMap, change: number)

(map: MapData, vector: Vector, tile: TileInfo)

()

(map: MapData, player: PlayerID)

(unit: PlainUnit)

(vector: Vector, layer?: TileLayer)

(viewer?: PlayerID | null)

(playerDetails: PlayerDetails, player: PlayerID)

()

()

(from: Vector, index: number, to: Vector)

(map: MapData, player: Player)

(player: Player)

(fn: (vector: Vector, index: number) => void)

(name: string)

(player: PlayerOrPlayerID)

(body: string)

(entity: Entity)

(unit: TransportedUnit)

( vector: Vector, state: State, actions: Actions, )

(player: PlayerID)

(positions: WeaponPositions, mirror?: boolean)

(from: Vector, to: Vector)

( animations: Animations, { children, color, onComplete = (state) => state, position,

(map: MapData, group: number, vector: Vector)

(labels: PlayerIDSet)

(label: PlayerIDSet)

(biome: Biome)

(entityA: Entity)

()

(u: SpriteVector, d: SpriteVector)

(from: Vector)

( map: MapData, vision: VisionT, action: Action, )

(fn: (buildingInfo: BuildingInfo) => boolean)

(unitInfos: ReadonlyArray<UnitInfo>)

(isLeader = false)

( map: MapData, unit: Unit, vector: Vector | null, tile: TileInfo | null, )

(range: ReadonlyArray<number>, value: number)

( map: MapData, entity: Entity, tile: TileInfo | null, )

(map: MapData)

(id: TileField, layer?: TileLayer)

(performanceType: PerformanceType)

( map: MapData, vision: VisionT, player: Player, supplyUnits: Vector | ReadonlyArray<Vector>, )

(playerDetails: PlayerDetails, player: PlayerID | null)

(map: MapData)

(reward: EncodedReward | null | undefined)

(reward: Reward | null | undefined)

(button?: ButtonResult)

( event: LongPressReactEvents<Element> | PointerEvent | ClientCoordinates, )

(player: Player)

(data: PlainMap)

( spriteSize: number, frameCount: number, property: 'vertical' | 'horizontal', )

(entity: Entity)

( object: { prototype: Prototype; }, entityMap: Record<string, () => string>, fields?: [T, S], )

(objectA: AnyEntity, entityB: Entity)

(t: TileInfo)

( map: MapData, player: PlayerID, building: Building | undefined, vector: Vector, )

(value: number, boundary: number)