(node)

({ animate, focusPlayer, team, timeout, users, wide, ...props }: GameCardProps & { animate: bo

({ isFocused, map, onTeamChange, placeholders, }: { isFocused?: boolean; map: MapData; onTeamCha

({ animatePlayer, focusPlayer, teams, ...props }: GameCardProps & { animatePlayer: boolean; focusP

({ state, unit, vector, }: { state: State; unit: Unit | null; vector: Vector | null; })

({ animationConfig: { AnimationDuration, UnitAnimationStep, UnitMoveDuration }, children, className, p

({ biome, field, modifier, playerDetails, tileSize, vector, vision, }: { biome: Biome; field

({ children }: { children: ReactNode })

({ getLayer, map, radius, tileSize, vector, vision, }: { getLayer: GetLayerFunction; isVisible

({ biome, size = 'small', tile, ...props }: { biome: Biome; tile: TileInfo; } & InlineTagProps)

({ children, map, size, }: { children?: ReactNode; map: MapData; size?: BuildingHeight; })

({ size = 'small', tileType, ...props }: { tileType: TileType; } & InlineTagProps)

({ effects: initialEffects, type, }: { effects: TileMovementMap; type: 'attack' | 'defense'; })

({ player, timeout }: { player: Player; timeout: number })

({ time: initialTime }: { time: number })

({ children, player }: { children: ReactNode; player: Player })

({ duration, setDuration, }: { duration: number; setDuration: (fn: (duration: number) => number) => vo

({ first, index, last, onChange }: TopBarProps)

({ animationConfig, highlight, map, playerDetails, tileSize, unit, }: { animationConfig: Animati

({ player, timeout }: { player: Player; timeout: number })

({ autoFocus, autoHide = true, dataSource, emptyResult, emptySuggestions, freeform, ignoreList,

({ className, color }: { className?: string; color: PlayerID })

({ canUndo, canUndoAction, fade, undo, }: { canUndo: boolean; canUndoAction: boolean; fade?: boo

({ actions, availableActions, state }: MenuItemProps)

({ actions: { update }, availableActions, state }: MenuItemProps)

({ player, unit }: { player: Player; unit: Unit })

({ ability, children, icon, }: { ability: Ability; children: ReactNode; icon: SVGIcon; })

({ biome, damageChartRoute, map, player, unit, vector, }: { biome: Biome; damageChartRoute: Ro

({ effect }: { effect: number })

({ blocked, color }: { blocked: ReadonlySet<number>; color: BaseColor })

({ color, cost, unit }: { color: BaseColor; cost: number; unit: UnitInfo })

({ color, costs }: { color: BaseColor; costs: ReadonlyMap<ID, number> })

({ movementTypes, radius, }: { movementTypes: ReadonlyArray<MovementType>; radius: number; })

({ effect, movementTypes, type, }: { effect: number; movementTypes: ReadonlyArray<MovementType>; t

({ color, unit }: { color: BaseColor; unit: UnitInfo })

({ color, size = 'small', unit, unitColor = 1, ...props }: { color: BaseColor; unit: UnitInfo;

({ color, units }: { color: BaseColor; units: ReadonlyArray<UnitInfo> })

({ onClick, unit, }: { onClick?: (event: MouseEvent, unit: Unit) => void; unit: Unit; })

()

({ color, range, }: { color: BaseColor; range: ReadonlyMap<number, [number, number]>; })

({ color, range, unit, }: { color: BaseColor; range: [number, number]; unit: UnitInfo; })

({ color, effects, type, }: { color: BaseColor; effects: ReadonlyMap<number, number>; type: 'attac

({ absolute, animation, animationConfig, animationKey, biome, customSprite, dim, direction,

({ biome, player, unit, }: { biome: Biome; player: PlayerID; unit: Unit; })

({ biome, map, player, unit, vector, }: { biome: Biome; map: MapData; player: PlayerID; unit

({ color, effect, type, units, }: { color: BaseColor; effect: number; type: 'attack' | 'defense'

({ onUpgrade, position: { x, y }, size, update, ...props }: Omit<AnimationProps, 'sound' | 'delay'>

({ enableInputControls, invert, layer, showPauseButton = true, type = 'master', }: { enableInputCo

()

({ className, fade, hide, max, position, setZoom, zoom, }: { className?: string; fade?: bool

(canvas: Canvas)

()

(map: MapData)

(map: MapData)

(map: MapData)

(map: MapData)

(state: State)

(state: State)

()

()

(state: State)

(state: State)

(state: State)

({ map, selectedPosition, selectedUnit, vision }: State)

(state: State)

(state: State)

(state: State, actions?: Actions, shouldConfirm?: boolean)

(skill: Skill)

()

()

()

( actionResponse: ActionResponse, previousMap: MapData, currentMap: MapData, )

(map: MapData)

(map: MapData)

(unit: T)

( actions: Actions, from: Vector, unitA: Unit, to: Vector, entityB: Entity, state: State, )

()

()

(map: MapData)

(distance: number, range: [number, number] | null)

()

(state: State, unit: Unit, building: Building)

(map: MapData, player: PlayerID)

()

()

(vector: Vector)

(vector: Vector)

(vector: Vector)

(vector: Vector)

( previousMap: MapData, map: MapData, actionResponse: ActionResponse, isDestructive: boolean, isCapt

()

(state: State)

(state: State)

()

({ actions, state }: StateWithActions)

({ editor, state }: StateWithActions)

()

(previousProps: Props)

()

( public readonly id: ID, public readonly health: number, public readonly player: PlayerID, pr