( { map, messages, vision }: State, vector: Vector | null, )

( maps: ReadonlyArray<MapData>, viewers: string | ReadonlyArray<string>, gameActionResponses?: ReadonlyA

(map: MapData | undefined)

( { processGameActionResponse, throwError, update }: Actions, remoteAction: Promise<GameActionResponse>,

(state: State)

({ from }: { from: Vector })

({ cell, frames, mirror, positions, recoil, repeat, rotate, size, sound,

({ forceRemoteAudio } = { forceRemoteAudio: false })

(map: MapData)

(crystal: Crystal, alpha = 1)

( buildings: PlainEntitiesList<PlainBuilding>, )

( size: SizeVector, decorators: PlainEntitiesList<Decorator> | undefined, )

( actionName: string, actionType: ActionType, props: ReadonlyArray<Prop>, counter = 0, )

({ update }: Actions, { selectedPosition }: State)

( fn: T, intervalRange: ReadonlyArray<number>, )

( props: ReadonlyArray<Prop>, actionType: ActionType, prefix?: string, )

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

()

(seconds: number)

(statusEffect: UnitStatusEffect | null)

(map: MapData, biomes: ReadonlyArray<Biome> = Biomes)

(map: MapData)

( map: MapData, actionResponse: ActionResponse, )

()

( map: MapData, vision: VisionT, player: Player, type: 'visible' | 'hidden' = 'visible', )

( map: MapData, position: Vector, unit: Unit, vision: VisionT, attackable: ReadonlyMap<Vector, Radiu

()

(id: number)

(slug: string, route?: UserCampaignRoute)

(criteria: Criteria)

( unitA: Unit, entityB: Entity, map: MapData, from: Vector, to: Vector, modifier = 1, )

(index: Decorator)

( unitInfo: UnitInfo, currentPlayer: Player, enemyAirUnits: ReadonlyArray<Unit>, )

( map: MapData, mapObject: Pick<MapObject, 'effects'> | null = null, mode: EditorMode = 'design', edit

(name: string)

(map: MapData, position: Vector)

(map: MapData, tileSize: number, scale: number)

( map: MapData, player?: PlayerID, )

(entityB: Entity, index: number)

( map: MapData, actionResponse: ActionResponse, )

( action: CharacterMessageEffectAction | CharacterMessageActionResponse, )

()

()

( unitInfo: UnitInfo, currentPlayer: Player, enemyAirUnits: ReadonlyArray<Unit>, )

({ destroyedUnits, lostUnits }: PlayerStatistics)

( map: MapData, position: Vector, )

(tileSize: number)

(skillType: SkillStatusType, skill: Skill)

()

({ movementType }: { movementType: MovementType })

(tag: MessageTag)

(unit: Unit, player: Player)

(username: string, route?: UserRoute)

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

( map: MapData, currentViewer: PlayerID | null, spectatorCodes: ReadonlyArray<string> | undefined, isE

( type: 'GameEnd' | 'OptionalObjective', id: DynamicEffectObjectiveID, conditions?: Conditions, )

()

()

(map: MapData)

(unitState: UnitState)

(gameMap: TestGameMap)

(map: MapData, unit: Unit, vector: Vector)

( actionResponse: ActionResponse | undefined, )

()

( actionResponse: ActionResponse, )

(map: MapData, vector: Vector)

(entity: Entity, tileInfo: TileInfo)

( count: number, position: number, navigationDirection: NavigationDirection | null, )

()

(player: PlayerID)

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

(fn: (tile: TileInfo) => T)

( fn: (unitInfo: UnitInfo, index: number) => T, skills: ReadonlySet<Skill>, )

(mapA: ReadonlyMap<K, V>, mapB: ReadonlyMap<K, V> | null)

(conversion: UnitConversion)

( map: MapData, unit: Unit, vector: Vector, attackingUnit: Unit | null | undefined, state: 'recover'

( map: MapData, initialTeams: Teams | undefined, entities: ImmutableMap<Vector, Entity>, )

(vector: Vector, layer?: TileLayer)

(map: MapData, newTeams: Teams | undefined)

(list: ReadonlySet<ID>, id: ID)

( objective: Objective, )

(event: DragEvent<HTMLDivElement>)

(value: string)

( fn: ( value: T, vector: Vector, tile: TileInfo, layer: TileLayer, modifier

(map: MapData, unitsToRefill: UnitsWithPosition)

()

(repeat: number)

(map: MapData, player: PlayerID)

()

( editor: EditorState, conditionIndex: DynamicEffectObjectiveID, objective?: Objective, )

(map: MapData, skill: Skill)

(unitClass: typeof Unit)

()

(time: number | undefined)

(editor: EditorState | undefined)

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

(map: MapData, player: PlayerOrPlayerID)

({ description, levels, name, next, }: PlainCampaign<T>)

(campaign: Campaign<T>)

( map: MapData, actionResponse: ActionResponse, value: T, vector: Vector | null, )