Options
All
  • Public
  • Public/Protected
  • All
Menu

Overmind

Index

Enumerations

Classes

Interfaces

Type aliases

Variables

Functions

Object literals

Type aliases

BufferTarget

BufferTarget: StructureStorage | StructureTerminal

LogisticsTarget

LogisticsTarget: EnergyStructure | StoreStructure | StructureLab | StructureNuker | StructurePowerSpawn | Tombstone | Resource

TransportRequestTarget

TransportRequestTarget: EnergyStructure | StoreStructure | StructureLab | StructureNuker | StructurePowerSpawn

attackTargetType

attackTargetType: Creep | Structure

buildTargetType

buildTargetType: ConstructionSite

claimTargetType

claimTargetType: StructureController

dismantleTargetType

dismantleTargetType: Structure

dropTargetType

dropTargetType: object | RoomPosition

fortifyTargetType

fortifyTargetType: StructureWall | StructureRampart

getBoostedTargetType

getBoostedTargetType: StructureLab

getRenewedTargetType

getRenewedTargetType: StructureSpawn

goToRoomTargetType

goToRoomTargetType: string

goToTargetType

goToTargetType: object | RoomPosition

harvestTargetType

harvestTargetType: Source | Mineral

healTargetType

healTargetType: Creep

meleeAttackTargetType

meleeAttackTargetType: Creep | Structure

pickupTargetType

pickupTargetType: Resource

rangedAttackTargetType

rangedAttackTargetType: Creep | Structure

rechargeTargetType

rechargeTargetType: null

repairTargetType

repairTargetType: Structure

reserveTargetType

reserveTargetType: StructureController

signControllerTargetType

signControllerTargetType: StructureController

transferAllTargetType

transferAllTargetType: StructureStorage | StructureTerminal | StructureContainer

transferTargetType

transferTargetType: EnergyStructure | StoreStructure | StructureLab | StructureNuker | StructurePowerSpawn | Creep

upgradeTargetType

upgradeTargetType: StructureController

withdrawAllTargetType

withdrawAllTargetType: StoreStructure | Tombstone

withdrawTargetType

withdrawTargetType: EnergyStructure | StoreStructure | StructureLab | StructurePowerSpawn | Tombstone

Variables

Const ALL_RESOURCE_TYPE_ERROR

ALL_RESOURCE_TYPE_ERROR: "Improper logistics request: 'all' can only be used for store structure or tombstone!" = `Improper logistics request: 'all' can only be used for store structure or tombstone!`

Const AllContracts

AllContracts: Contract[] = []

Const AttackStructurePriorities

AttackStructurePriorities: BuildableStructureConstant[] = [STRUCTURE_SPAWN,STRUCTURE_TOWER,STRUCTURE_EXTENSION,STRUCTURE_LINK,STRUCTURE_LAB,STRUCTURE_NUKER,STRUCTURE_OBSERVER,STRUCTURE_EXTRACTOR,STRUCTURE_POWER_SPAWN,STRUCTURE_CONTAINER,STRUCTURE_ROAD,STRUCTURE_STORAGE,STRUCTURE_TERMINAL,STRUCTURE_RAMPART,STRUCTURE_WALL,]

Prioritized list of what order enemy structures should be attacked in

Const AttackStructureScores

AttackStructureScores: object = _.zipObject(_.map(AttackStructurePriorities, type =>[type, AttackStructurePriorities.length - _.indexOf(AttackStructurePriorities, type)])) as { [t: string]: number }

Type declaration

  • [t: string]: number

Const BUNKER_RADIUS

BUNKER_RADIUS: 6 = 6

Const BuildPriorities

BuildPriorities: BuildableStructureConstant[] = [STRUCTURE_SPAWN,STRUCTURE_TOWER,STRUCTURE_EXTENSION,STRUCTURE_STORAGE,STRUCTURE_TERMINAL,STRUCTURE_CONTAINER,STRUCTURE_LINK,STRUCTURE_EXTRACTOR,STRUCTURE_LAB,STRUCTURE_NUKER,STRUCTURE_OBSERVER,STRUCTURE_POWER_SPAWN,STRUCTURE_WALL,STRUCTURE_RAMPART,STRUCTURE_ROAD,]

Prioritized list of what order structures should be built in

Const DEFAULT_OPERATION_MODE

DEFAULT_OPERATION_MODE: operationMode = "automatic"

If this is enabled, Memory.bot will default to true. This will not change the mode if already set - use setMode().

Const DEFAULT_OVERMIND_SIGNATURE

DEFAULT_OVERMIND_SIGNATURE: string = leftAngleQuote + OVERMIND_SMALL_CAPS + rightAngleQuote

Const DEFAULT_PARTNER_TICK_DIFFERENCE

DEFAULT_PARTNER_TICK_DIFFERENCE: 650 = 650

Const DEFAULT_PRESPAWN

DEFAULT_PRESPAWN: 50 = 50

Const DEFAULT_SWARM_TICK_DIFFERENCE

DEFAULT_SWARM_TICK_DIFFERENCE: 650 = 650

Const DemolishStructurePriorities

DemolishStructurePriorities: object[] = [{structureType: STRUCTURE_EXTENSION, maxRemoved: 15},{structureType: STRUCTURE_SPAWN, maxRemoved: 1},{structureType: STRUCTURE_CONTAINER},{structureType: STRUCTURE_TOWER, maxRemoved: 1},{structureType: STRUCTURE_LINK},{structureType: STRUCTURE_LAB},{structureType: STRUCTURE_NUKER},{structureType: STRUCTURE_OBSERVER},// {structureType: STRUCTURE_EXTRACTOR, maxRemoved: 1}, // skip extractor; doesn't need to be relocated{structureType: STRUCTURE_POWER_SPAWN},// {structureType: STRUCTURE_ROAD}, // just let roads decay{structureType: STRUCTURE_CONTAINER},{structureType: STRUCTURE_STORAGE, maxRemoved: 1},{structureType: STRUCTURE_TERMINAL, maxRemoved: 1},{structureType: STRUCTURE_WALL},{structureType: STRUCTURE_RAMPART},]

Prioritized list of what order owned structures should be demolished (and then moved) in

Const DoubleMinerSetupCost

DoubleMinerSetupCost: number = bodyCost(Setups.drones.miners.double.generateBody(Infinity))

Const ERR_CANNOT_PUSH_CREEP

ERR_CANNOT_PUSH_CREEP: -30 = -30

Const EXPANSION_EVALUATION_FREQ

EXPANSION_EVALUATION_FREQ: 500 = 500

Const LOG_LEVEL

LOG_LEVEL: number = LogLevels.INFO

Default debug level for log output

Const LOG_LOAD_SOURCE_MAP

LOG_LOAD_SOURCE_MAP: boolean = false

Load source maps and resolve source lines back to typeascript.

Const LOG_MAX_PAD

LOG_MAX_PAD: number = 100

Maximum padding for source links (for aligning log output).

Const LOG_PRINT_LINES

LOG_PRINT_LINES: boolean = false

Prepend log output with source line.

Const LOG_PRINT_TICK

LOG_PRINT_TICK: boolean = true

Prepend log output with current tick number.

Const LOG_STATS_INTERVAL

LOG_STATS_INTERVAL: 8 = 8

Operational statistics, stored in Memory.stats, will be updated every (this many) ticks

Const MAX_ENERGY_SELL_ORDERS

MAX_ENERGY_SELL_ORDERS: 5 = 5

Const MAX_OBSERVE_DISTANCE

MAX_OBSERVE_DISTANCE: 7 = 7

Const MAX_OWNED_ROOMS

MAX_OWNED_ROOMS: number = Infinity

Limit how many rooms you can claim (for any shard)

Const MAX_SPAWN_REQUESTS

MAX_SPAWN_REQUESTS: 100 = 100

Const MIN_EXPANSION_DISTANCE

MIN_EXPANSION_DISTANCE: 2 = 2

Const MIN_LIFETIME_FOR_BOOST

MIN_LIFETIME_FOR_BOOST: 0.85 = 0.85

Const MUON

MUON: "Muon" = "Muon"

My Screeps username; used for a variety of updating and communications purposes. (Changing this might break things.)

Const MY_USERNAME

MY_USERNAME: string = getUsername()

Your username - you shouldn't need to change this.

Const NEW_OVERMIND_INTERVAL

NEW_OVERMIND_INTERVAL: 5 | 20 = onPublicServer() ? 20 : 5

The global Overmind object will be re-instantiated after this many ticks. In the meantime, refresh() is used.

Const NO_ACTION

NO_ACTION: -20 = -20

Const OVERMIND_SMALL_CAPS

OVERMIND_SMALL_CAPS: "ᴏᴠᴇʀᴍɪɴᴅ" = "ᴏᴠᴇʀᴍɪɴᴅ"

Const PROFILER_COLONY_LIMIT

PROFILER_COLONY_LIMIT: number = Math.ceil(Game.gcl.level / 2)

Profiling is incredibly expensive and can cause the script to time out. By setting this option, you can limit the number of colonies that will be handled while profiling. Colonies above this limit do not get run.

Const PROFILER_INCLUDE_COLONIES

PROFILER_INCLUDE_COLONIES: string[] = [/*'E15S49'*/]

While profiling, ensure these colonies are included in the randomly chosen ones specified by PROFILER_COLONY_LIMIT.

Const RESOURCE_IMPORTANCE

RESOURCE_IMPORTANCE: ("power" | "U" | "L" | "K" | "G" | "Z" | "O" | "H" | "X" | "OH" | "ZK" | "UL" | "UH" | "UO" | "KH" | "KO" | "LH" | "LO" | "ZH" | "ZO" | "GH" | "GO" | "UH2O" | "UHO2" | "KH2O" | "KHO2" | "LH2O" | "LHO2" | "ZH2O" | "ZHO2" | "GH2O" | "GHO2" | "XUH2O" | "XUHO2" | "XKH2O" | "XKHO2" | "XLH2O" | "XLHO2" | "XZH2O" | "XZHO2" | "XGH2O" | "XGHO2" | "energy")[] = [RESOURCE_CATALYZED_GHODIUM_ALKALIDE,RESOURCE_CATALYZED_GHODIUM_ACID,RESOURCE_CATALYZED_ZYNTHIUM_ALKALIDE,RESOURCE_CATALYZED_ZYNTHIUM_ACID,RESOURCE_CATALYZED_LEMERGIUM_ALKALIDE,RESOURCE_CATALYZED_LEMERGIUM_ACID,RESOURCE_CATALYZED_KEANIUM_ALKALIDE,RESOURCE_CATALYZED_KEANIUM_ACID,RESOURCE_CATALYZED_UTRIUM_ALKALIDE,RESOURCE_CATALYZED_UTRIUM_ACID,RESOURCE_POWER,RESOURCE_GHODIUM_ALKALIDE,RESOURCE_GHODIUM_ACID,RESOURCE_ZYNTHIUM_ALKALIDE,RESOURCE_ZYNTHIUM_ACID,RESOURCE_LEMERGIUM_ALKALIDE,RESOURCE_LEMERGIUM_ACID,RESOURCE_KEANIUM_ALKALIDE,RESOURCE_KEANIUM_ACID,RESOURCE_UTRIUM_ALKALIDE,RESOURCE_UTRIUM_ACID,RESOURCE_GHODIUM_OXIDE,RESOURCE_GHODIUM_HYDRIDE,RESOURCE_ZYNTHIUM_OXIDE,RESOURCE_ZYNTHIUM_HYDRIDE,RESOURCE_LEMERGIUM_OXIDE,RESOURCE_LEMERGIUM_HYDRIDE,RESOURCE_KEANIUM_OXIDE,RESOURCE_KEANIUM_HYDRIDE,RESOURCE_UTRIUM_OXIDE,RESOURCE_UTRIUM_HYDRIDE,RESOURCE_UTRIUM_LEMERGITE,RESOURCE_ZYNTHIUM_KEANITE,RESOURCE_HYDROXIDE,RESOURCE_GHODIUM,RESOURCE_CATALYST,RESOURCE_ZYNTHIUM,RESOURCE_LEMERGIUM,RESOURCE_KEANIUM,RESOURCE_UTRIUM,RESOURCE_OXYGEN,RESOURCE_HYDROGEN,RESOURCE_ENERGY,]

Const ROOMTYPE_ALLEY

ROOMTYPE_ALLEY: "ALLEY" = "ALLEY"

Const ROOMTYPE_CONTROLLER

ROOMTYPE_CONTROLLER: "CTRL" = "CTRL"

Const ROOMTYPE_CORE

ROOMTYPE_CORE: "CORE" = "CORE"

Const ROOMTYPE_SOURCEKEEPER

ROOMTYPE_SOURCEKEEPER: "SK" = "SK"

Const SHARD3_MAX_OWNED_ROOMS

SHARD3_MAX_OWNED_ROOMS: 3 = 3

If you are running on shard3 (CPU limit 20), only claim this many rooms

Const StandardMinerSetupCost

StandardMinerSetupCost: number = bodyCost(Setups.drones.miners.standard.generateBody(Infinity))

Const USE_PROFILER

USE_PROFILER: boolean = false

Enable this to build from source including screeps-profiler. (This is separate from Overmind-Profiler.)

Const USE_TRY_CATCH

USE_TRY_CATCH: boolean = true

Enable this to wrap evaluations of constructor, init, and run phase for each colony in try...catch statemenets.

Const alignedNewline

alignedNewline: string = '\n' + ' '.repeat('INFO '.length + Game.time.toString().length + ' '.length)

Const allBunkerCoords

allBunkerCoords: object = _allBunkerCoords

Type declaration

  • [rcl: number]: Coord[]

Const asciiLogo

asciiLogo: string[] = ['___________________________________________________________','',' _____ _ _ _______ ______ _______ _____ __ _ ______ ','| | \\ / |______ |_____/ | | | | | \\ | | \\','|_____| \\/ |______ | \\_ | | | __|__ | \\_| |_____/','','_______________________ Screeps AI ________________________']

Const asciiLogoSmall

asciiLogoSmall: string[] = [' _____ _ _ _______ ______ _______ _____ __ _ ______ ','| | \\ / |______ |_____/ | | | | | \\ | | \\','|_____| \\/ |______ | \\_ | | | __|__ | \\_| |_____/']

Const attackTaskName

attackTaskName: "attack" = "attack"

Const buildTaskName

buildTaskName: "build" = "build"

Const bullet

bullet: "‣ " = "‣ "

Const bunkerChargingSpots

bunkerChargingSpots: Coord[] = [{'x': 29, 'y': 24}, {'x': 24, 'y': 21}]

Const bunkerCoordLookup

bunkerCoordLookup: object = _.mapValues(_allBunkerCoords,(coordArr: Coord[]) =>_.zipObject(_.map(coordArr,c => [coordName(c), true]))) as { [rcl: number]: { [coordName: string]: true | undefined } }

Type declaration

  • [rcl: number]: object
    • [coordName: string]: true | undefined

Const claimTaskName

claimTaskName: "claim" = "claim"

Const dismantleTaskName

dismantleTaskName: "dismantle" = "dismantle"

Const dropTaskName

dropTaskName: "drop" = "drop"

Const energyStructureOrder

energyStructureOrder: Coord[] = (<Coord[]>[]).concat(quadrantFillOrder.lowerRight,quadrantFillOrder.upperLeft,quadrantFillOrder.lowerLeft,quadrantFillOrder.upperRight)

Const fortifyTaskName

fortifyTaskName: "fortify" = "fortify"

Const getBoostedTaskName

getBoostedTaskName: "getBoosted" = "getBoosted"

Const getRenewedTaskName

getRenewedTaskName: "getRenewed" = "getRenewed"

Const goToRoomTaskName

goToRoomTaskName: "goToRoom" = "goToRoom"

Const goToTaskName

goToTaskName: "goTo" = "goTo"

Const harvestTaskName

harvestTaskName: "harvest" = "harvest"

Const healTaskName

healTaskName: "heal" = "heal"

Const leftAngleQuote

leftAngleQuote: "«" = "«"

Const leftArrow

leftArrow: "⟵" = "⟵"

Const log

log: Log = new Log()

Const logoComponents

logoComponents: object = _.mapValues(_logoComponents,c => ({style : c.style,points: _.map(c.points, xy => [logoX + logoScale * xy[0],logoY + logoScale * xy[1]])})) as { [part: string]: { style: PolyStyle, points: [number, number][] } }

Type declaration

  • [part: string]: object

Const logoText

logoText: object = _.mapValues(_logoText, function (c) {let ret = {style : c.style,points: _.map(c.points, xy => [textX + textScale * (offset + xy[0]),textY + textScale * xy[1]])};offset += charScale * (c.coords[1] - c.coords[0]);return ret;}) as { [part: string]: { style: PolyStyle, points: [number, number][] } }

Type declaration

  • [part: string]: object

Const meleeAttackTaskName

meleeAttackTaskName: "meleeAttack" = "meleeAttack"

Const pickupTaskName

pickupTaskName: "pickup" = "pickup"

Const priorityStock

priorityStock: Reaction[] = _priorityStock

Const rangedAttackTaskName

rangedAttackTaskName: "rangedAttack" = "rangedAttack"

Const rechargeTaskName

rechargeTaskName: "recharge" = "recharge"

Const repairTaskName

repairTaskName: "repair" = "repair"

Const reserveTaskName

reserveTaskName: "colony" = "colony"

Const rightAngleQuote

rightAngleQuote: "»" = "»"

Const rightArrow

rightArrow: "⟶" = "⟶"

Const signControllerTaskName

signControllerTaskName: "signController" = "signController"

Const transferAllTaskName

transferAllTaskName: "transferAll" = "transferAll"

Const transferTaskName

transferTaskName: "transfer" = "transfer"

Const upgradeTaskName

upgradeTaskName: "upgrade" = "upgrade"

Const wantedStock

wantedStock: Reaction[] = _wantedStock

Const withdrawAllTaskName

withdrawAllTaskName: "withdrawAll" = "withdrawAll"

Const withdrawTaskName

withdrawTaskName: "withdraw" = "withdraw"

Functions

DirectiveWrapper

  • DirectiveWrapper(flag: Flag): Directive | undefined

  • This is the initializer for directives, which maps flags by their color code to the corresponding directive

    Parameters

    • flag: Flag

    Returns Directive | undefined

Const LOG_VSC_URL_TEMPLATE

  • LOG_VSC_URL_TEMPLATE(path: string, line: string): string

  • URL template for VSC links, this one works for github and gitlab.

    Parameters

    • path: string
    • line: string

    Returns string

assimilationLocked

  • assimilationLocked(code: any): void

averageBy

  • averageBy<T>(objects: T[], iteratee: function): number | undefined

  • Type parameters

    • T

    Parameters

    • objects: T[]
    • iteratee: function
        • (obj: T): number

        • Parameters

          • obj: T

          Returns number

    Returns number | undefined

blankPriorityQueue

  • blankPriorityQueue(): object

bodyCost

  • bodyCost(bodyparts: BodyPartConstant[]): number

bulleted

  • bulleted(text: string[], aligned?: boolean, startWithNewLine?: boolean): string

  • Parameters

    • text: string[]
    • Default value aligned: boolean = true
    • Default value startWithNewLine: boolean = true

    Returns string

clone2DArray

  • clone2DArray<T>(a: T[][]): T[][]

color

  • color(str: string, color: string): string

coordName

  • coordName(coord: Coord): string

createGraph

  • createGraph(roomName: string, toProtect: Rectangle[], preferCloserBarriers?: boolean, preferCloserBarrierLimit?: number, visualize?: boolean, bounds?: Rectangle): void | Graph

  • Function to create Source, Sink, Tiles arrays: takes a rectangle-Array as input for Tiles that are to Protect

    Parameters

    • roomName: string
    • toProtect: Rectangle[]

      the coordinates to protect inside the walls

    • Default value preferCloserBarriers: boolean = true
    • Default value preferCloserBarrierLimit: number = Infinity
    • Default value visualize: boolean = true
    • Default value bounds: Rectangle = {x1: 0, y1: 0, x2: 49, y2: 49}

      the area to consider for the minCut

    Returns void | Graph

debug

  • debug(thing: object, ...args: any[]): void

derefCoords

  • derefCoords(coordName: string, roomName: string): RoomPosition

distanceTransform

  • distanceTransform(roomName: string): CostMatrix

doomsdayLaunch

  • doomsdayLaunch(): void

equalXYR

  • equalXYR(pos1: protoPos, pos2: protoPos): boolean

exponentialMovingAverage

  • exponentialMovingAverage(current: number, avg: number | undefined, window: number): number

  • Parameters

    • current: number
    • avg: number | undefined
    • window: number

    Returns number

get2DArray

  • get2DArray(roomName: string, bounds?: Rectangle): any[][]

  • An Array with Terrain information: -1 not usable, 2 Sink (Leads to Exit)

    Parameters

    • roomName: string
    • Default value bounds: Rectangle = {x1: 0, y1: 0, x2: 49, y2: 49}

    Returns any[][]

getAllColonies

getAllColonyRooms

  • getAllColonyRooms(): Room[]

getAllStructureCoordsFromLayout

  • getAllStructureCoordsFromLayout(layout: StructureLayout, rcl: number): Coord[]

getAutonomyLevel

  • getAutonomyLevel(): number

getCacheExpiration

  • getCacheExpiration(timeout: number, offset?: number): number

  • Parameters

    • timeout: number
    • Default value offset: number = 5

    Returns number

getCreepWeightInfo

  • getCreepWeightInfo(creep: Creep, analyzeCarry?: boolean): object

  • Returns the number of move parts and number of weight-generating parts in a creep

    Parameters

    • creep: Creep
    • Default value analyzeCarry: boolean = true

    Returns object

getCutTiles

  • getCutTiles(roomName: string, toProtect: Rectangle[], preferCloserBarriers?: boolean, preferCloserBarrierLimit?: number, visualize?: boolean, bounds?: Rectangle): Coord[]

  • Main function to be called by user: calculate min cut tiles from room using rectangles as protected areas

    Parameters

    • roomName: string
    • toProtect: Rectangle[]
    • Default value preferCloserBarriers: boolean = true
    • Default value preferCloserBarrierLimit: number = Infinity
    • Default value visualize: boolean = true
    • Default value bounds: Rectangle = {x1: 0, y1: 0, x2: 49, y2: 49}

      the area to be considered for the minCut

    Returns Coord[]

getOverlord

getPosFromBunkerCoord

  • getPosFromBunkerCoord(coord: Coord, colony: Colony): RoomPosition

getPosFromString

  • getPosFromString(str: string | undefined | null): RoomPosition | undefined

  • Parameters

    • str: string | undefined | null

    Returns RoomPosition | undefined

getTerrainCosts

  • getTerrainCosts(creep: Creep): object

  • Get terrain costs which take into account a creep's individual fatigue stats

    Parameters

    • creep: Creep

    Returns object

getUsername

  • getUsername(): string

hasColony

hasJustSpawned

  • hasJustSpawned(): boolean

hasMinerals

  • hasMinerals(store: object): boolean

  • Parameters

    • store: object
      • [resourceType: string]: number

    Returns boolean

hasPos

  • hasPos(obj: HasPos | RoomPosition): boolean

hmac

  • hmac(key: Uint8Array, data: Uint8Array): Uint8Array

initializeTask

  • initializeTask(protoTask: protoTask): Task

insideBunkerBounds

  • insideBunkerBounds(pos: RoomPosition, colony: Colony): boolean

irregularExponentialMovingAverage

  • irregularExponentialMovingAverage(current: number, avg: number, dt: number, window: number): number

  • Parameters

    • current: number
    • avg: number
    • dt: number
    • window: number

    Returns number

isCombatZerg

isCreep

  • isCreep(obj: RoomObject): boolean

isEnergyStructure

  • isEnergyStructure(obj: RoomObject): boolean

isExit

  • isExit(pos: Coord): boolean

  • Returns if the coordinate is on an exit tile

    Parameters

    • pos: Coord

    Returns boolean

isIVM

  • isIVM(): boolean

isOwnedStructure

  • isOwnedStructure(structure: Structure): boolean

isResource

  • isResource(obj: RoomObject): boolean

isSource

  • isSource(obj: Source | Mineral): boolean

isStoreStructure

  • isStoreStructure(obj: RoomObject): boolean

isStructure

  • isStructure(obj: RoomObject): boolean

isTombstone

  • isTombstone(obj: RoomObject): boolean

isZerg

  • isZerg(creep: Creep | Zerg): boolean

logHeapStats

  • logHeapStats(): void

loop

  • loop(): void

maxBy

  • maxBy<T>(objects: T[], iteratee: function): T | undefined

  • Type parameters

    • T

    Parameters

    • objects: T[]
    • iteratee: function
        • (obj: T): number | false

        • Parameters

          • obj: T

          Returns number | false

    Returns T | undefined

mergeSum

  • mergeSum(objects: object[]): object

minBy

  • minBy<T>(objects: T[], iteratee: function): T | undefined

  • Type parameters

    • T

    Parameters

    • objects: T[]
    • iteratee: function
        • (obj: T): number | false

        • Parameters

          • obj: T

          Returns number | false

    Returns T | undefined

minMax

  • minMax(value: number, min: number, max: number): number

mod

  • mod(n: number, m: number): number

normalizePos

  • normalizePos(destination: HasPos | RoomPosition): RoomPosition

  • Returns destination.pos if destination has a position, or destination if destination is a RoomPosition

    Parameters

    • destination: HasPos | RoomPosition

    Returns RoomPosition

normalizeZerg

  • normalizeZerg(creep: Zerg | Creep): Zerg | Creep

onPublicServer

  • onPublicServer(): boolean

patternCost

printRoomName

  • printRoomName(roomName: string): string

profile

  • profile(target: Function): void
  • profile(target: object, key: string | symbol, _descriptor: TypedPropertyDescriptor<Function>): void

pruneDeadEnds

  • pruneDeadEnds(roomName: string, cutTiles: Coord[]): Coord[]

  • Removes unnecessary tiles if they are blocking the path to a dead end Useful if minCut has been run on a subset of the room

    Parameters

    • roomName: string

      Room to work in

    • cutTiles: Coord[]

      Array of tiles which are in the minCut

    Returns Coord[]

randomHex

  • randomHex(length: number): string

resolve

  • resolve(fileLine: string): SourcePos

rotatedMatrix

  • rotatedMatrix<T>(matrix: T[][], clockwiseTurns: 0 | 1 | 2 | 3): T[][]

  • Type parameters

    • T

    Parameters

    • matrix: T[][]
    • clockwiseTurns: 0 | 1 | 2 | 3

    Returns T[][]

sameCoord

  • sameCoord(pos1: Coord, pos2: Coord): boolean

  • Checks if the coordinates of two room positions are the same

    Parameters

    • pos1: Coord
    • pos2: Coord

    Returns boolean

sandbox

  • sandbox(): void

setOverlord

  • setOverlord(creep: Zerg | Creep, newOverlord: Overlord | null): void

sha256

  • sha256(data: string): Uint8Array

testDistanceTransform

  • testDistanceTransform(roomName?: string): void

testMinCut

  • testMinCut(colonyName: string, preferCloserBarriers?: boolean): string

  • Example function: demonstrates how to get a min cut with 2 rectangles, which define a "to protect" area

    Parameters

    • colonyName: string
    • Default value preferCloserBarriers: boolean = true

    Returns string

testMinCutSubset

  • testMinCutSubset(colonyName: string): string

  • Example function: demonstrates how to get a min cut with 2 rectangles, which define a "to protect" area while considering a subset of the larger room.

    Parameters

    • colonyName: string

    Returns string

toColumns

  • toColumns(obj: object, opts?: toColumnsOpts): string[]

  • Parameters

    • obj: object
      • [key: string]: string
    • Default value opts: toColumnsOpts = {} as toColumnsOpts

    Returns string[]

toCreep

  • toCreep(creep: Zerg | Creep): Creep

translatePositions

  • translatePositions(positions: RoomPosition[], fromAnchor: Coord, toAnchor: Coord): RoomPosition[]

verifyLaunchManifest

  • verifyLaunchManifest(): void

Object literals

Const CombatSetups

CombatSetups: object

This object contains default body setups for various types of combat-related creeps

broodlings

broodlings: object

Broodlings are primarily melee creeps which may have a small amount of healing

default

default: CreepSetup = new CreepSetup(Roles.guardMelee, {pattern : [TOUGH, ATTACK, ATTACK, ATTACK, MOVE, MOVE, MOVE, MOVE, MOVE, HEAL],sizeLimit: Infinity,})

early

early: CreepSetup = new CreepSetup(Roles.guardMelee, {pattern : [ATTACK, MOVE],sizeLimit: Infinity,})

dismantlers

dismantlers: object

Dismantlers (lurkers) are creeps with work parts for dismantle sieges

armored

armored: CreepSetup = new CreepSetup(Roles.dismantler, {pattern : [TOUGH, WORK, WORK, WORK, MOVE, MOVE, MOVE, MOVE],sizeLimit: Infinity,})

boosted_T3

boosted_T3: CreepSetup = new CreepSetup(Roles.dismantler, {pattern : [TOUGH, TOUGH, WORK, WORK, WORK, WORK, WORK, WORK, MOVE, MOVE],sizeLimit: Infinity,})

default

default: CreepSetup = new CreepSetup(Roles.dismantler, {pattern : [WORK, MOVE],sizeLimit: Infinity,})

healers

healers: object

Healers (transfusers) are creeps which only do healing

armored

armored: CreepSetup = new CreepSetup(Roles.healer, {pattern : [TOUGH, HEAL, HEAL, HEAL, MOVE, MOVE, MOVE, MOVE],sizeLimit: Infinity,})

boosted_T3

boosted_T3: CreepSetup = new CreepSetup(Roles.healer, {pattern : [TOUGH, TOUGH, HEAL, HEAL, HEAL, HEAL, HEAL, HEAL, MOVE, MOVE],sizeLimit: Infinity,})

default

default: CreepSetup = new CreepSetup(Roles.healer, {pattern : [HEAL, MOVE],sizeLimit: Infinity,})

hydralisks

hydralisks: object

Hydralisks are ranged creeps which may have a small amount of healing

boosted_T3

boosted_T3: CreepSetup = new CreepSetup(Roles.ranged, {pattern : [TOUGH, TOUGH, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK,MOVE, MOVE, HEAL],sizeLimit: Infinity,})

default

default: CreepSetup = new CreepSetup(Roles.ranged, {pattern : [RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, MOVE, MOVE, MOVE, MOVE, HEAL],sizeLimit: Infinity,})

early

early: CreepSetup = new CreepSetup(Roles.ranged, {pattern : [RANGED_ATTACK, MOVE],sizeLimit: Infinity,})

sourceKeeper

sourceKeeper: CreepSetup = new CreepSetup(Roles.ranged, {pattern : [MOVE, MOVE, MOVE, MOVE, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, HEAL, HEAL, MOVE],sizeLimit: Infinity,})

zerglings

zerglings: object

Zerglings are melee-only creeps (with exception of sourceKeeper setup)

armored

armored: CreepSetup = new CreepSetup(Roles.melee, {pattern : [TOUGH, ATTACK, ATTACK, ATTACK, MOVE, MOVE, MOVE, MOVE],sizeLimit: Infinity,})

boosted_T3

boosted_T3: CreepSetup = new CreepSetup(Roles.melee, {pattern : [TOUGH, TOUGH, ATTACK, ATTACK, ATTACK, ATTACK, ATTACK, ATTACK, MOVE, MOVE],sizeLimit: Infinity,})

boosted_T3_defense

boosted_T3_defense: CreepSetup = new CreepSetup(Roles.melee, {pattern : [TOUGH, ATTACK, ATTACK, ATTACK, ATTACK, ATTACK, ATTACK, ATTACK, MOVE, MOVE],sizeLimit: Infinity,})

default

default: CreepSetup = new CreepSetup(Roles.melee, {pattern : [ATTACK, MOVE],sizeLimit: Infinity,})

sourceKeeper

sourceKeeper: CreepSetup = new CreepSetup(Roles.melee, {pattern : [MOVE, MOVE, MOVE, MOVE, ATTACK, ATTACK, ATTACK, ATTACK, HEAL, MOVE],sizeLimit: Infinity,})

Const LOG_VSC

LOG_VSC: object

VSC location, used to create links back to source. Repo and revision are filled in at build time for git repositories.

repo

repo: string = "@@_repo_@@"

revision

revision: string = "@@_revision_@@"

valid

valid: boolean = false

Const MatrixTypes

MatrixTypes: object

default

default: string = "def"

direct

direct: string = "dir"

obstacle

obstacle: string = "obst"

preferRampart

preferRampart: string = "preframp"

sk

sk: string = "sk"

Const MovePriorities

MovePriorities: object

__computed

__computed: number = 9

default

default: number = 10

OverlordPriority

OverlordPriority: object

Default ordering for processing spawning requests and prioritizing overlords

default

default: number = 99999

throttleThreshold

throttleThreshold: number = 699

warSpawnCutoff

warSpawnCutoff: number = 299

collection

collection: object

haul

haul: number = 1100

collectionUrgent

collectionUrgent: object

haul

haul: number = 700

colonization

colonization: object

claim

claim: number = 400

pioneer

pioneer: number = 401

core

core: object

manager

manager: number = 101

queen

queen: number = 100

defense

defense: object

meleeDefense

meleeDefense: number = 200

rangedDefense

rangedDefense: number = 201

emergency

emergency: object

bootstrap

bootstrap: number = 0

offense

offense: object

controllerAttack

controllerAttack: number = 399

destroy

destroy: number = 300

healPoint

healPoint: number = 301

siege

siege: number = 302

outpostDefense

outpostDefense: object

guard

guard: number = 551

outpostDefense

outpostDefense: number = 550

ownedRoom

ownedRoom: object

firstTransport

firstTransport: number = 500

mine

mine: number = 501

mineral

mineral: number = 520

mineralRCL8

mineralRCL8: number = 503

transport

transport: number = 510

work

work: number = 502

remoteRoom

remoteRoom: object

mine

mine: number = 901

reserve

reserve: number = 900

roomIncrement

roomIncrement: number = 5

remoteSKRoom

remoteSKRoom: object

mine

mine: number = 1002

mineral

mineral: number = 1001

roomIncrement

roomIncrement: number = 5

sourceReaper

sourceReaper: number = 1000

scouting

scouting: object

randomWalker

randomWalker: number = 801

stationary

stationary: number = 800

upgrading

upgrading: object

upgrade

upgrade: number = 600

Const REAGENTS

REAGENTS: object

__computed

__computed: ["U", "L"] = [RESOURCE_UTRIUM, RESOURCE_LEMERGIUM]

Const Roles

Roles: object

A mapping of role types to string constants used for naming creeps and accessing them by role

claim

claim: string = "infestor"

dismantler

dismantler: string = "lurker"

drone

drone: string = "drone"

filler

filler: string = "filler"

guardMelee

guardMelee: string = "broodling"

healer

healer: string = "transfuser"

manager

manager: string = "manager"

melee

melee: string = "zergling"

pioneer

pioneer: string = "pioneer"

queen

queen: string = "queen"

ranged

ranged: string = "hydralisk"

scout

scout: string = "scout"

transport

transport: string = "transport"

upgrader

upgrader: string = "upgrader"

worker

worker: string = "worker"

Const Setups

Setups: object

This object contains categorized default body setups for various types of creeps

filler

filler: CreepSetup = new CreepSetup(Roles.filler, {pattern : [CARRY, CARRY, MOVE],sizeLimit: 1,})

pioneer

pioneer: CreepSetup = new CreepSetup(Roles.pioneer, {pattern : [WORK, CARRY, MOVE, MOVE],sizeLimit: Infinity,})

scout

scout: CreepSetup = new CreepSetup(Roles.scout, {pattern : [MOVE],sizeLimit: 1,})

drones

drones: object

extractor

extractor: CreepSetup = new CreepSetup(Roles.drone, {pattern : [WORK, WORK, CARRY, MOVE],sizeLimit: Infinity,})

miners

miners: object

default

default: CreepSetup = new CreepSetup(Roles.drone, {pattern : [WORK, WORK, CARRY, MOVE],sizeLimit: 3,})

double

double: CreepSetup = new CreepSetup(Roles.drone, {pattern : [WORK, WORK, WORK, WORK, WORK, WORK, CARRY, MOVE, MOVE, MOVE],sizeLimit: 2,})

emergency

emergency: CreepSetup = new CreepSetup(Roles.drone, {pattern : [WORK, WORK, CARRY, MOVE],sizeLimit: 1,})

sourceKeeper

sourceKeeper: CreepSetup = new CreepSetup(Roles.drone, {pattern : [WORK, WORK, CARRY, MOVE],sizeLimit: 5,})

standard

standard: CreepSetup = new CreepSetup(Roles.drone, {pattern : [WORK, WORK, WORK, WORK, WORK, WORK, CARRY, MOVE, MOVE, MOVE],sizeLimit: 1,})

infestors

infestors: object

claim

claim: CreepSetup = new CreepSetup(Roles.claim, {pattern : [CLAIM, MOVE],sizeLimit: 1})

controllerAttacker

controllerAttacker: CreepSetup = new CreepSetup(Roles.claim, {pattern : [CLAIM, MOVE],sizeLimit: Infinity,})

reserve

reserve: CreepSetup = new CreepSetup(Roles.claim, {pattern : [CLAIM, MOVE],sizeLimit: 4,})

managers

managers: object

default

default: CreepSetup = new CreepSetup(Roles.manager, {pattern : [CARRY, CARRY, CARRY, CARRY, MOVE],sizeLimit: 3,})

stationary

stationary: CreepSetup = new CreepSetup(Roles.manager, {pattern : [CARRY, CARRY],sizeLimit: 8,})

stationary_work

stationary_work: CreepSetup = new CreepSetup(Roles.manager, {pattern : [WORK, WORK, WORK, WORK, CARRY, CARRY],sizeLimit: 8,})

twoPart

twoPart: CreepSetup = new CreepSetup(Roles.manager, {pattern : [CARRY, CARRY, MOVE],sizeLimit: 8,})

queens

queens: object

default

default: CreepSetup = new CreepSetup(Roles.queen, {pattern : [CARRY, CARRY, MOVE],sizeLimit: Infinity,})

early

early: CreepSetup = new CreepSetup(Roles.queen, {pattern : [CARRY, MOVE],sizeLimit: Infinity,})

transporters

transporters: object

default

default: CreepSetup = new CreepSetup(Roles.transport, {pattern : [CARRY, CARRY, MOVE],sizeLimit: Infinity,})

early

early: CreepSetup = new CreepSetup(Roles.transport, {pattern : [CARRY, MOVE],sizeLimit: Infinity,})

upgraders

upgraders: object

default

default: CreepSetup = new CreepSetup(Roles.upgrader, {pattern : [WORK, WORK, WORK, CARRY, MOVE],sizeLimit: Infinity,})

rcl8

rcl8: CreepSetup = new CreepSetup(Roles.upgrader, {pattern : [WORK, WORK, WORK, CARRY, MOVE],sizeLimit: 5,})

workers

workers: object

default

default: CreepSetup = new CreepSetup(Roles.worker, {pattern : [WORK, CARRY, MOVE],sizeLimit: Infinity,})

early

early: CreepSetup = new CreepSetup(Roles.worker, {pattern : [WORK, CARRY, MOVE, MOVE],sizeLimit: Infinity,})

Const TerminalState_Emergency

TerminalState_Emergency: object

name

name: string = "emergency"

tolerance

tolerance: number = 500

type

type: "in" = "in"

amounts

amounts: object

__computed

__computed: number = 3000

Const TerminalState_Evacuate

TerminalState_Evacuate: object

amounts

amounts: object

Type declaration

name

name: string = "evacuate"

tolerance

tolerance: number = 500

type

type: "out" = "out"

Const TerminalState_Rebuild

TerminalState_Rebuild: object

name

name: string = "rebuild"

tolerance

tolerance: number = 500

type

type: "out" = "out"

amounts

amounts: object

__computed

__computed: number = 25000

Const baseStockAmounts

baseStockAmounts: object

__computed

__computed: number = 5000

Const boostParts

boostParts: object

GH

GH: "work" = WORK

GH2O

GH2O: "work" = WORK

GHO2

GHO2: "tough" = TOUGH

GO

GO: "tough" = TOUGH

KH

KH: "carry" = CARRY

KH2O

KH2O: "carry" = CARRY

KHO2

KHO2: "ranged_attack" = RANGED_ATTACK

KO

KO: "ranged_attack" = RANGED_ATTACK

LH

LH: "work" = WORK

LH2O

LH2O: "work" = WORK

LHO2

LHO2: "heal" = HEAL

LO

LO: "heal" = HEAL

UH

UH: "attack" = ATTACK

UH2O

UH2O: "attack" = ATTACK

UHO2

UHO2: "work" = WORK

UO

UO: "work" = WORK

XGH2O

XGH2O: "work" = WORK

XGHO2

XGHO2: "tough" = TOUGH

XKH2O

XKH2O: "carry" = CARRY

XKHO2

XKHO2: "ranged_attack" = RANGED_ATTACK

XLH2O

XLH2O: "work" = WORK

XLHO2

XLHO2: "heal" = HEAL

XUH2O

XUH2O: "attack" = ATTACK

XUHO2

XUHO2: "work" = WORK

XZH2O

XZH2O: "work" = WORK

XZHO2

XZHO2: "move" = MOVE

ZH

ZH: "work" = WORK

ZH2O

ZH2O: "work" = WORK

ZHO2

ZHO2: "move" = MOVE

ZO

ZO: "move" = MOVE

Const boostResources

boostResources: object

attack

attack: object

1

1: "UH" = "UH"

2

2: "UH2O" = "UH2O"

3

3: "XUH2O" = "XUH2O"

carry

carry: object

1

1: "KH" = "KH"

2

2: "KH2O" = "KH2O"

3

3: "XKH2O" = "XKH2O"

construct

construct: object

1

1: "LH" = "LH"

2

2: "LH2O" = "LH2O"

3

3: "XLH2O" = "XLH2O"

dismantle

dismantle: object

1

1: "ZH" = "ZH"

2

2: "ZH2O" = "ZH2O"

3

3: "XZH2O" = "XZH2O"

harvest

harvest: object

1

1: "UO" = "UO"

2

2: "UHO2" = "UHO2"

3

3: "XUHO2" = "XUHO2"

heal

heal: object

1

1: "LO" = "LO"

2

2: "LHO2" = "LHO2"

3

3: "XLHO2" = "XLHO2"

move

move: object

1

1: "ZO" = "ZO"

2

2: "ZHO2" = "ZHO2"

3

3: "XZHO2" = "XZHO2"

ranged_attack

ranged_attack: object

1

1: "KO" = "KO"

2

2: "KHO2" = "KHO2"

3

3: "XKHO2" = "XKHO2"

tough

tough: object

1

1: "GO" = "GO"

2

2: "GHO2" = "GHO2"

3

3: "XGHO2" = "XGHO2"

upgrade

upgrade: object

1

1: "GH" = "GH"

2

2: "GH2O" = "GH2O"

3

3: "XGH2O" = "XGH2O"

Const bunkerLayout

bunkerLayout: object

1

1: object

name

name: string = "bunkerCore"

rcl

rcl: string = "1"

shard

shard: string = "shard2"

buildings

buildings: object

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}]

2

2: object

name

name: string = "bunkerCore"

rcl

rcl: string = "2"

shard

shard: string = "shard2"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x': 27, 'y': 30}]

extension

extension: object

pos

pos: object[] = [{'x': 28, 'y': 26}, {'x': 28, 'y': 27}, {'x': 27, 'y': 27}, {'x': 27,'y': 28}, {'x': 29, 'y': 26}]

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}]

3

3: object

name

name: string = "bunkerCore"

rcl

rcl: string = "3"

shard

shard: string = "shard2"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x': 27, 'y': 30}]

extension

extension: object

pos

pos: object[] = [{'x': 28, 'y': 26}, {'x': 29, 'y': 27}, {'x': 28, 'y': 27}, {'x': 27,'y': 27}, {'x': 27, 'y': 28}, {'x': 28, 'y': 28}, {'x': 29, 'y': 28}, {'x': 28, 'y': 29}, {'x': 27,'y': 29}, {'x': 29, 'y': 26}]

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}]

tower

tower: object

pos

pos: object[] = [{'x': 25, 'y': 26}]

4

4: object

name

name: string = "bunkerCore"

rcl

rcl: string = "4"

shard

shard: string = "shard2"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x': 27, 'y': 30}]

extension

extension: object

pos

pos: object[] = [{'x': 30, 'y': 24}, {'x': 30, 'y': 25}, {'x': 30, 'y': 26}, {'x': 28,'y': 26}, {'x': 29, 'y': 27}, {'x': 28, 'y': 27}, {'x': 27, 'y': 27}, {'x': 27, 'y': 28}, {'x': 28,'y': 28}, {'x': 29, 'y': 28}, {'x': 28, 'y': 29}, {'x': 27, 'y': 29}, {'x': 26, 'y': 28}, {'x': 24,'y': 30}, {'x': 25, 'y': 30}, {'x': 26, 'y': 30}, {'x': 29, 'y': 26}, {'x': 24, 'y': 29}, {'x': 30,'y': 27}, {'x': 25, 'y': 29}]

lab

lab: object

pos

pos: never[] = []

link

link: object

pos

pos: never[] = []

nuker

nuker: object

pos

pos: never[] = []

observer

observer: object

pos

pos: never[] = []

powerSpawn

powerSpawn: object

pos

pos: never[] = []

road

road: object

pos

pos: object[] = [{'x': 24, 'y': 23}, {'x': 25, 'y': 22}, {'x': 26, 'y': 23}, {'x': 27,'y': 24}, {'x': 28, 'y': 25}, {'x': 27, 'y': 26}, {'x': 26, 'y': 27}, {'x': 25, 'y': 28}, {'x': 24,'y': 27}, {'x': 23, 'y': 26}, {'x': 22, 'y': 25}, {'x': 23, 'y': 24}, {'x': 28, 'y': 20}, {'x': 30,'y': 22}, {'x': 24, 'y': 21}, {'x': 30, 'y': 28}, {'x': 28, 'y': 30}, {'x': 26, 'y': 29}, {'x': 20,'y': 22}, {'x': 22, 'y': 20}, {'x': 20, 'y': 28}, {'x': 22, 'y': 30}, {'x': 24, 'y': 19}, {'x': 26,'y': 19}, {'x': 27, 'y': 19}, {'x': 31, 'y': 23}, {'x': 31, 'y': 24}, {'x': 31, 'y': 25}, {'x': 31,'y': 26}, {'x': 31, 'y': 27}, {'x': 27, 'y': 31}, {'x': 27, 'y': 31}, {'x': 26, 'y': 31}, {'x': 24,'y': 31}, {'x': 23, 'y': 31}, {'x': 19, 'y': 27}, {'x': 19, 'y': 26}, {'x': 19, 'y': 25}, {'x': 19,'y': 24}, {'x': 25, 'y': 19}, {'x': 19, 'y': 23}, {'x': 25, 'y': 31}, {'x': 23, 'y': 19}, {'x': 29,'y': 21}, {'x': 21, 'y': 21}, {'x': 21, 'y': 29}, {'x': 29, 'y': 29}, {'x': 21, 'y': 26}, {'x': 29,'y': 24}, {'x': 30, 'y': 23}, {'x': 20, 'y': 27}, {'x': 23, 'y': 25}, {'x': 27, 'y': 25}, {'x': 23,'y': 20}, {'x': 24, 'y': 28}, {'x': 23, 'y': 29}, {'x': 23, 'y': 30}, {'x': 27, 'y': 30}]

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}]

storage

storage: object

pos

pos: object[] = [{'x': 24, 'y': 25}]

terminal

terminal: object

pos

pos: never[] = []

tower

tower: object

pos

pos: object[] = [{'x': 25, 'y': 26}]

5

5: object

name

name: string = "bunkerCore"

rcl

rcl: string = "5"

shard

shard: string = "shard2"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x': 27, 'y': 30}]

extension

extension: object

pos

pos: object[] = [{'x': 30, 'y': 24}, {'x': 30, 'y': 25}, {'x': 30, 'y': 26}, {'x': 28,'y': 26}, {'x': 29, 'y': 27}, {'x': 28, 'y': 27}, {'x': 27, 'y': 27}, {'x': 27, 'y': 28}, {'x': 28,'y': 28}, {'x': 29, 'y': 28}, {'x': 28, 'y': 29}, {'x': 27, 'y': 29}, {'x': 26, 'y': 28}, {'x': 23,'y': 27}, {'x': 24, 'y': 28}, {'x': 23, 'y': 28}, {'x': 22, 'y': 27}, {'x': 21, 'y': 27}, {'x': 22,'y': 28}, {'x': 23, 'y': 29}, {'x': 21, 'y': 28}, {'x': 24, 'y': 30}, {'x': 25, 'y': 30}, {'x': 26,'y': 30}, {'x': 29, 'y': 26}, {'x': 24, 'y': 29}, {'x': 23, 'y': 30}, {'x': 30, 'y': 27}, {'x': 25,'y': 29}, {'x': 22, 'y': 29}]

lab

lab: object

pos

pos: never[] = []

link

link: object

pos

pos: object[] = [{'x': 26, 'y': 26}]

nuker

nuker: object

pos

pos: never[] = []

observer

observer: object

pos

pos: never[] = []

powerSpawn

powerSpawn: object

pos

pos: never[] = []

road

road: object

pos

pos: object[] = [{'x': 24, 'y': 23}, {'x': 25, 'y': 22}, {'x': 26, 'y': 23}, {'x': 27,'y': 24}, {'x': 28, 'y': 25}, {'x': 27, 'y': 26}, {'x': 26, 'y': 27}, {'x': 25, 'y': 28}, {'x': 24,'y': 27}, {'x': 23, 'y': 26}, {'x': 22, 'y': 25}, {'x': 23, 'y': 24}, {'x': 28, 'y': 20}, {'x': 30,'y': 22}, {'x': 24, 'y': 21}, {'x': 30, 'y': 28}, {'x': 28, 'y': 30}, {'x': 26, 'y': 29}, {'x': 20,'y': 22}, {'x': 22, 'y': 20}, {'x': 20, 'y': 28}, {'x': 22, 'y': 30}, {'x': 24, 'y': 19}, {'x': 26,'y': 19}, {'x': 27, 'y': 19}, {'x': 31, 'y': 23}, {'x': 31, 'y': 24}, {'x': 31, 'y': 25}, {'x': 31,'y': 26}, {'x': 31, 'y': 27}, {'x': 27, 'y': 31}, {'x': 27, 'y': 31}, {'x': 26, 'y': 31}, {'x': 24,'y': 31}, {'x': 23, 'y': 31}, {'x': 19, 'y': 27}, {'x': 19, 'y': 26}, {'x': 19, 'y': 25}, {'x': 19,'y': 24}, {'x': 25, 'y': 19}, {'x': 19, 'y': 23}, {'x': 25, 'y': 31}, {'x': 23, 'y': 19}, {'x': 29,'y': 21}, {'x': 21, 'y': 21}, {'x': 21, 'y': 29}, {'x': 29, 'y': 29}, {'x': 21, 'y': 26}, {'x': 29,'y': 24}, {'x': 30, 'y': 23}, {'x': 20, 'y': 27}, {'x': 23, 'y': 25}, {'x': 27, 'y': 25}, {'x': 23,'y': 20}, {'x': 27, 'y': 30}]

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}]

storage

storage: object

pos

pos: object[] = [{'x': 24, 'y': 25}]

terminal

terminal: object

pos

pos: never[] = []

tower

tower: object

pos

pos: object[] = [{'x': 25, 'y': 24}, {'x': 25, 'y': 26}]

6

6: object

name

name: string = "bunkerCore"

rcl

rcl: string = "6"

shard

shard: string = "shard2"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x': 27, 'y': 30}]

extension

extension: object

pos

pos: object[] = [{'x': 22, 'y': 24}, {'x': 22, 'y': 23}, {'x': 21, 'y': 23}, {'x': 30,'y': 24}, {'x': 30, 'y': 25}, {'x': 30, 'y': 26}, {'x': 20, 'y': 24}, {'x': 20, 'y': 25}, {'x': 20,'y': 26}, {'x': 21, 'y': 22}, {'x': 28, 'y': 26}, {'x': 29, 'y': 27}, {'x': 28, 'y': 27}, {'x': 27,'y': 27}, {'x': 27, 'y': 28}, {'x': 28, 'y': 28}, {'x': 29, 'y': 28}, {'x': 28, 'y': 29}, {'x': 27,'y': 29}, {'x': 26, 'y': 28}, {'x': 22, 'y': 26}, {'x': 23, 'y': 27}, {'x': 24, 'y': 28}, {'x': 23,'y': 28}, {'x': 22, 'y': 27}, {'x': 21, 'y': 27}, {'x': 22, 'y': 28}, {'x': 23, 'y': 29}, {'x': 22,'y': 29}, {'x': 21, 'y': 28}, {'x': 24, 'y': 30}, {'x': 25, 'y': 30}, {'x': 26, 'y': 30}, {'x': 29,'y': 26}, {'x': 21, 'y': 24}, {'x': 24, 'y': 29}, {'x': 23, 'y': 30}, {'x': 20, 'y': 23}, {'x': 30,'y': 27}, {'x': 25, 'y': 29}]

lab

lab: object

pos

pos: object[] = [{'x': 27, 'y': 23}, {'x': 28, 'y': 24}, {'x': 28, 'y': 23}]

link

link: object

pos

pos: object[] = [{'x': 26, 'y': 26}]

nuker

nuker: object

pos

pos: never[] = []

observer

observer: object

pos

pos: never[] = []

powerSpawn

powerSpawn: object

pos

pos: never[] = []

road

road: object

pos

pos: object[] = [{'x': 24, 'y': 23}, {'x': 25, 'y': 22}, {'x': 26, 'y': 23}, {'x': 27,'y': 24}, {'x': 28, 'y': 25}, {'x': 27, 'y': 26}, {'x': 26, 'y': 27}, {'x': 25, 'y': 28}, {'x': 24,'y': 27}, {'x': 23, 'y': 26}, {'x': 22, 'y': 25}, {'x': 23, 'y': 24}, {'x': 28, 'y': 20}, {'x': 30,'y': 22}, {'x': 24, 'y': 21}, {'x': 30, 'y': 28}, {'x': 28, 'y': 30}, {'x': 26, 'y': 29}, {'x': 20,'y': 22}, {'x': 22, 'y': 20}, {'x': 20, 'y': 28}, {'x': 22, 'y': 30}, {'x': 24, 'y': 19}, {'x': 26,'y': 19}, {'x': 27, 'y': 19}, {'x': 31, 'y': 23}, {'x': 31, 'y': 24}, {'x': 31, 'y': 25}, {'x': 31,'y': 26}, {'x': 31, 'y': 27}, {'x': 27, 'y': 31}, {'x': 27, 'y': 31}, {'x': 26, 'y': 31}, {'x': 24,'y': 31}, {'x': 23, 'y': 31}, {'x': 19, 'y': 27}, {'x': 19, 'y': 26}, {'x': 19, 'y': 25}, {'x': 19,'y': 24}, {'x': 25, 'y': 19}, {'x': 19, 'y': 23}, {'x': 25, 'y': 31}, {'x': 23, 'y': 19}, {'x': 29,'y': 21}, {'x': 21, 'y': 21}, {'x': 21, 'y': 29}, {'x': 29, 'y': 29}, {'x': 21, 'y': 26}, {'x': 29,'y': 24}, {'x': 30, 'y': 23}, {'x': 20, 'y': 27}, {'x': 23, 'y': 25}, {'x': 27, 'y': 25}, {'x': 22,'y': 22}, {'x': 23, 'y': 23}, {'x': 23, 'y': 20}, {'x': 27, 'y': 30}]

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}]

storage

storage: object

pos

pos: object[] = [{'x': 24, 'y': 25}]

terminal

terminal: object

pos

pos: object[] = [{'x': 26, 'y': 25}]

tower

tower: object

pos

pos: object[] = [{'x': 25, 'y': 24}, {'x': 25, 'y': 26}]

7

7: object

name

name: string = "bunkerCore"

rcl

rcl: string = "7"

shard

shard: string = "shard2"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x': 27, 'y': 30}, {'x': 23, 'y': 20}]

extension

extension: object

pos

pos: object[] = [{'x': 24, 'y': 22}, {'x': 23, 'y': 23}, {'x': 22, 'y': 24}, {'x': 22,'y': 23}, {'x': 23, 'y': 22}, {'x': 23, 'y': 21}, {'x': 22, 'y': 22}, {'x': 21, 'y': 23}, {'x': 25,'y': 20}, {'x': 26, 'y': 20}, {'x': 30, 'y': 24}, {'x': 30, 'y': 25}, {'x': 30, 'y': 26}, {'x': 20,'y': 24}, {'x': 20, 'y': 25}, {'x': 20, 'y': 26}, {'x': 22, 'y': 21}, {'x': 21, 'y': 22}, {'x': 28,'y': 26}, {'x': 29, 'y': 27}, {'x': 28, 'y': 27}, {'x': 27, 'y': 27}, {'x': 27, 'y': 28}, {'x': 28,'y': 28}, {'x': 29, 'y': 28}, {'x': 28, 'y': 29}, {'x': 27, 'y': 29}, {'x': 26, 'y': 28}, {'x': 22,'y': 26}, {'x': 23, 'y': 27}, {'x': 24, 'y': 28}, {'x': 23, 'y': 28}, {'x': 22, 'y': 27}, {'x': 21,'y': 27}, {'x': 22, 'y': 28}, {'x': 23, 'y': 29}, {'x': 22, 'y': 29}, {'x': 21, 'y': 28}, {'x': 24,'y': 30}, {'x': 25, 'y': 30}, {'x': 26, 'y': 30}, {'x': 29, 'y': 26}, {'x': 21, 'y': 24}, {'x': 26,'y': 21}, {'x': 24, 'y': 29}, {'x': 23, 'y': 30}, {'x': 20, 'y': 23}, {'x': 27, 'y': 20}, {'x': 30,'y': 27}, {'x': 25, 'y': 29}]

lab

lab: object

pos

pos: object[] = [{'x': 27, 'y': 23}, {'x': 28, 'y': 24}, {'x': 28, 'y': 22}, {'x': 28,'y': 23}, {'x': 29, 'y': 23}, {'x': 29, 'y': 22}]

link

link: object

pos

pos: object[] = [{'x': 26, 'y': 26}]

nuker

nuker: object

pos

pos: never[] = []

observer

observer: object

pos

pos: never[] = []

powerSpawn

powerSpawn: object

pos

pos: never[] = []

road

road: object

pos

pos: object[] = [{'x': 24, 'y': 23}, {'x': 25, 'y': 22}, {'x': 26, 'y': 23}, {'x': 27,'y': 24}, {'x': 28, 'y': 25}, {'x': 27, 'y': 26}, {'x': 26, 'y': 27}, {'x': 25, 'y': 28}, {'x': 24,'y': 27}, {'x': 23, 'y': 26}, {'x': 22, 'y': 25}, {'x': 23, 'y': 24}, {'x': 28, 'y': 20}, {'x': 30,'y': 22}, {'x': 24, 'y': 21}, {'x': 30, 'y': 28}, {'x': 28, 'y': 30}, {'x': 26, 'y': 29}, {'x': 20,'y': 22}, {'x': 22, 'y': 20}, {'x': 20, 'y': 28}, {'x': 22, 'y': 30}, {'x': 24, 'y': 19}, {'x': 26,'y': 19}, {'x': 27, 'y': 19}, {'x': 31, 'y': 23}, {'x': 31, 'y': 24}, {'x': 31, 'y': 25}, {'x': 31,'y': 26}, {'x': 31, 'y': 27}, {'x': 27, 'y': 31}, {'x': 27, 'y': 31}, {'x': 26, 'y': 31}, {'x': 24,'y': 31}, {'x': 23, 'y': 31}, {'x': 19, 'y': 27}, {'x': 19, 'y': 26}, {'x': 19, 'y': 25}, {'x': 19,'y': 24}, {'x': 25, 'y': 19}, {'x': 19, 'y': 23}, {'x': 25, 'y': 31}, {'x': 23, 'y': 19}, {'x': 29,'y': 21}, {'x': 21, 'y': 21}, {'x': 21, 'y': 29}, {'x': 29, 'y': 29}, {'x': 21, 'y': 26}, {'x': 29,'y': 24}, {'x': 30, 'y': 23}, {'x': 20, 'y': 27}, {'x': 27, 'y': 22}, {'x': 28, 'y': 21}, {'x': 23,'y': 25}, {'x': 27, 'y': 25}, {'x': 27, 'y': 30}, {'x': 23, 'y': 20}]

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}, {'x': 26, 'y': 24}]

storage

storage: object

pos

pos: object[] = [{'x': 24, 'y': 25}]

terminal

terminal: object

pos

pos: object[] = [{'x': 26, 'y': 25}]

tower

tower: object

pos

pos: object[] = [{'x': 25, 'y': 24}, {'x': 25, 'y': 26}, {'x': 25, 'y': 23}]

8

8: object

name

name: string = "bunkerCore"

rcl

rcl: string = "8"

shard

shard: string = "shard2"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x': 27, 'y': 30}, {'x': 23, 'y': 20}]

extension

extension: object

pos

pos: object[] = [{'x': 24, 'y': 22}, {'x': 23, 'y': 23}, {'x': 22, 'y': 24}, {'x': 22,'y': 23}, {'x': 23, 'y': 22}, {'x': 23, 'y': 21}, {'x': 22, 'y': 22}, {'x': 21, 'y': 23}, {'x': 24,'y': 20}, {'x': 25, 'y': 20}, {'x': 26, 'y': 20}, {'x': 30, 'y': 24}, {'x': 30, 'y': 25}, {'x': 30,'y': 26}, {'x': 20, 'y': 24}, {'x': 20, 'y': 25}, {'x': 20, 'y': 26}, {'x': 22, 'y': 21}, {'x': 21,'y': 22}, {'x': 28, 'y': 26}, {'x': 29, 'y': 27}, {'x': 28, 'y': 27}, {'x': 27, 'y': 27}, {'x': 27,'y': 28}, {'x': 28, 'y': 28}, {'x': 29, 'y': 28}, {'x': 28, 'y': 29}, {'x': 27, 'y': 29}, {'x': 26,'y': 28}, {'x': 22, 'y': 26}, {'x': 23, 'y': 27}, {'x': 24, 'y': 28}, {'x': 23, 'y': 28}, {'x': 22,'y': 27}, {'x': 21, 'y': 27}, {'x': 22, 'y': 28}, {'x': 23, 'y': 29}, {'x': 22, 'y': 29}, {'x': 21,'y': 28}, {'x': 24, 'y': 30}, {'x': 25, 'y': 30}, {'x': 26, 'y': 30}, {'x': 29, 'y': 26}, {'x': 21,'y': 24}, {'x': 26, 'y': 21}, {'x': 24, 'y': 29}, {'x': 23, 'y': 30}, {'x': 20, 'y': 23}, {'x': 27,'y': 20}, {'x': 30, 'y': 27}, {'x': 25, 'y': 29}]

lab

lab: object

pos

pos: object[] = [{'x': 26, 'y': 22}, {'x': 27, 'y': 23}, {'x': 28, 'y': 24}, {'x': 27,'y': 22}, {'x': 27, 'y': 21}, {'x': 28, 'y': 22}, {'x': 28, 'y': 23}, {'x': 29, 'y': 23}, {'x': 28,'y': 21}, {'x': 29, 'y': 22}]

link

link: object

pos

pos: object[] = [{'x': 26, 'y': 26}]

nuker

nuker: object

pos

pos: object[] = [{'x': 24, 'y': 24}]

observer

observer: object

pos

pos: object[] = [{'x': 21, 'y': 25}]

powerSpawn

powerSpawn: object

pos

pos: object[] = [{'x': 24, 'y': 26}]

road

road: object

pos

pos: object[] = [{'x': 24, 'y': 23}, {'x': 25, 'y': 22}, {'x': 26, 'y': 23}, {'x': 27,'y': 24}, {'x': 28, 'y': 25}, {'x': 27, 'y': 26}, {'x': 26, 'y': 27}, {'x': 25, 'y': 28}, {'x': 24,'y': 27}, {'x': 23, 'y': 26}, {'x': 22, 'y': 25}, {'x': 23, 'y': 24}, {'x': 28, 'y': 20}, {'x': 30,'y': 22}, {'x': 24, 'y': 21}, {'x': 30, 'y': 28}, {'x': 28, 'y': 30}, {'x': 26, 'y': 29}, {'x': 20,'y': 22}, {'x': 22, 'y': 20}, {'x': 20, 'y': 28}, {'x': 22, 'y': 30}, {'x': 24, 'y': 19}, {'x': 26,'y': 19}, {'x': 27, 'y': 19}, {'x': 31, 'y': 23}, {'x': 31, 'y': 24}, {'x': 31, 'y': 25}, {'x': 31,'y': 26}, {'x': 31, 'y': 27}, {'x': 27, 'y': 31}, {'x': 27, 'y': 31}, {'x': 26, 'y': 31}, {'x': 24,'y': 31}, {'x': 23, 'y': 31}, {'x': 19, 'y': 27}, {'x': 19, 'y': 26}, {'x': 19, 'y': 25}, {'x': 19,'y': 24}, {'x': 25, 'y': 19}, {'x': 19, 'y': 23}, {'x': 25, 'y': 31}, {'x': 23, 'y': 19}, {'x': 29,'y': 21}, {'x': 21, 'y': 21}, {'x': 21, 'y': 29}, {'x': 29, 'y': 29}, {'x': 21, 'y': 26}, {'x': 29,'y': 24}, {'x': 30, 'y': 23}, {'x': 20, 'y': 27}, {'x': 27, 'y': 30}, {'x': 23, 'y': 20}]

spawn

spawn: object

pos

pos: object[] = [{'x': 29, 'y': 25}, {'x': 26, 'y': 24}, {'x': 25, 'y': 21}]

storage

storage: object

pos

pos: object[] = [{'x': 24, 'y': 25}]

terminal

terminal: object

pos

pos: object[] = [{'x': 26, 'y': 25}]

tower

tower: object

pos

pos: object[] = [{'x': 27, 'y': 25}, {'x': 23, 'y': 25}, {'x': 25, 'y': 27}, {'x': 25,'y': 23}, {'x': 25, 'y': 24}, {'x': 25, 'y': 26}]

data

data: object

anchor

anchor: object

x

x: number = 25

y

y: number = 25

commandCenterLayout

commandCenterLayout: object

3

3: object

name

name: string = "commandCenter"

rcl

rcl: string = "3"

shard

shard: string = "shard0"

buildings

buildings: object

tower

tower: object

pos

pos: object[] = [{'x':24,'y':27}]

4

4: object

name

name: string = "commandCenter"

rcl

rcl: string = "4"

shard

shard: string = "shard0"

buildings

buildings: object

road

road: object

pos

pos: object[] = [{'x':21,'y':24},{'x':22,'y':24},{'x':23,'y':24},{'x':24,'y':24},{'x':25,'y':24},{'x':26,'y':24},{'x':21,'y':25},{'x':26,'y':25},{'x':21,'y':26},{'x':23,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':25,'y':27},{'x':26,'y':27},{'x':21,'y':28},{'x':22,'y':28},{'x':25,'y':28},{'x':26,'y':28},{'x':21,'y':29},{'x':26,'y':29},{'x':21,'y':30},{'x':26,'y':30},{'x':21,'y':31},{'x':22,'y':31},{'x':23,'y':31},{'x':24,'y':31},{'x':25,'y':31},{'x':26,'y':31}]

storage

storage: object

pos

pos: object[] = [{'x':25,'y':25}]

tower

tower: object

pos

pos: object[] = [{'x':24,'y':27}]

5

5: object

name

name: string = "commandCenter"

rcl

rcl: string = "5"

shard

shard: string = "shard0"

buildings

buildings: object

link

link: object

pos

pos: object[] = [{'x':24,'y':25}]

road

road: object

pos

pos: object[] = [{'x':21,'y':24},{'x':22,'y':24},{'x':23,'y':24},{'x':24,'y':24},{'x':25,'y':24},{'x':26,'y':24},{'x':21,'y':25},{'x':26,'y':25},{'x':21,'y':26},{'x':23,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':25,'y':27},{'x':26,'y':27},{'x':21,'y':28},{'x':22,'y':28},{'x':25,'y':28},{'x':26,'y':28},{'x':21,'y':29},{'x':26,'y':29},{'x':21,'y':30},{'x':26,'y':30},{'x':21,'y':31},{'x':22,'y':31},{'x':23,'y':31},{'x':24,'y':31},{'x':25,'y':31},{'x':26,'y':31}]

storage

storage: object

pos

pos: object[] = [{'x':25,'y':25}]

tower

tower: object

pos

pos: object[] = [{'x':24,'y':27}]

6

6: object

name

name: string = "commandCenter"

rcl

rcl: string = "6"

shard

shard: string = "shard0"

buildings

buildings: object

lab

lab: object

pos

pos: object[] = [{'x':23,'y':28},{'x':24,'y':28},{'x':24,'y':29}]

link

link: object

pos

pos: object[] = [{'x':24,'y':25}]

road

road: object

pos

pos: object[] = [{'x':21,'y':24},{'x':22,'y':24},{'x':23,'y':24},{'x':24,'y':24},{'x':25,'y':24},{'x':26,'y':24},{'x':21,'y':25},{'x':26,'y':25},{'x':21,'y':26},{'x':23,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':25,'y':27},{'x':26,'y':27},{'x':21,'y':28},{'x':22,'y':28},{'x':25,'y':28},{'x':26,'y':28},{'x':21,'y':29},{'x':26,'y':29},{'x':21,'y':30},{'x':26,'y':30},{'x':21,'y':31},{'x':22,'y':31},{'x':23,'y':31},{'x':24,'y':31},{'x':25,'y':31},{'x':26,'y':31}]

storage

storage: object

pos

pos: object[] = [{'x':25,'y':25}]

terminal

terminal: object

pos

pos: object[] = [{'x':25,'y':26}]

tower

tower: object

pos

pos: object[] = [{'x':24,'y':27}]

7

7: object

name

name: string = "commandCenter"

rcl

rcl: string = "7"

shard

shard: string = "shard0"

buildings

buildings: object

lab

lab: object

pos

pos: object[] = [{'x':23,'y':28},{'x':24,'y':28},{'x':22,'y':29},{'x':23,'y':29},{'x':24,'y':29},{'x':25,'y':29}]

link

link: object

pos

pos: object[] = [{'x':24,'y':25}]

road

road: object

pos

pos: object[] = [{'x':21,'y':24},{'x':22,'y':24},{'x':23,'y':24},{'x':24,'y':24},{'x':25,'y':24},{'x':26,'y':24},{'x':21,'y':25},{'x':26,'y':25},{'x':21,'y':26},{'x':23,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':25,'y':27},{'x':26,'y':27},{'x':21,'y':28},{'x':22,'y':28},{'x':25,'y':28},{'x':26,'y':28},{'x':21,'y':29},{'x':26,'y':29},{'x':21,'y':30},{'x':26,'y':30},{'x':21,'y':31},{'x':22,'y':31},{'x':23,'y':31},{'x':24,'y':31},{'x':25,'y':31},{'x':26,'y':31}]

storage

storage: object

pos

pos: object[] = [{'x':25,'y':25}]

terminal

terminal: object

pos

pos: object[] = [{'x':25,'y':26}]

tower

tower: object

pos

pos: object[] = [{'x':23,'y':27},{'x':24,'y':27}]

8

8: object

name

name: string = "commandCenter"

rcl

rcl: string = "8"

shard

shard: string = "shard0"

buildings

buildings: object

lab

lab: object

pos

pos: object[] = [{'x':23,'y':28},{'x':24,'y':28},{'x':22,'y':29},{'x':23,'y':29},{'x':24,'y':29},{'x':25,'y':29},{'x':22,'y':30},{'x':23,'y':30},{'x':24,'y':30},{'x':25,'y':30}]

link

link: object

pos

pos: object[] = [{'x':24,'y':25}]

nuker

nuker: object

pos

pos: object[] = [{'x':22,'y':25}]

observer

observer: object

pos

pos: object[] = [{'x':22,'y':26}]

powerSpawn

powerSpawn: object

pos

pos: object[] = [{'x':23,'y':25}]

road

road: object

pos

pos: object[] = [{'x':21,'y':24},{'x':22,'y':24},{'x':23,'y':24},{'x':24,'y':24},{'x':25,'y':24},{'x':26,'y':24},{'x':21,'y':25},{'x':26,'y':25},{'x':21,'y':26},{'x':23,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':25,'y':27},{'x':26,'y':27},{'x':21,'y':28},{'x':22,'y':28},{'x':25,'y':28},{'x':26,'y':28},{'x':21,'y':29},{'x':26,'y':29},{'x':21,'y':30},{'x':26,'y':30},{'x':21,'y':31},{'x':22,'y':31},{'x':23,'y':31},{'x':24,'y':31},{'x':25,'y':31},{'x':26,'y':31}]

storage

storage: object

pos

pos: object[] = [{'x':25,'y':25}]

terminal

terminal: object

pos

pos: object[] = [{'x':25,'y':26}]

tower

tower: object

pos

pos: object[] = [{'x':23,'y':27},{'x':24,'y':27}]

data

data: object

anchor

anchor: object

x

x: number = 25

y

y: number = 25

hatcheryLayout

hatcheryLayout: object

1

1: object

name

name: string = "hatchery"

rcl

rcl: string = "1"

shard

shard: string = "shard0"

buildings

buildings: object

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24}]

2

2: object

name

name: string = "hatchery"

rcl

rcl: string = "2"

shard

shard: string = "shard0"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x':25,'y':25}]

extension

extension: object

pos

pos: object[] = [{'x':24,'y':23},{'x':26,'y':23},{'x':23,'y':24},{'x':27,'y':24},{'x':27,'y':26}]

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24}]

3

3: object

name

name: string = "hatchery"

rcl

rcl: string = "3"

shard

shard: string = "shard0"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x':25,'y':25}]

extension

extension: object

pos

pos: object[] = [{'x':24,'y':22},{'x':26,'y':22},{'x':24,'y':23},{'x':26,'y':23},{'x':23,'y':24},{'x':27,'y':24},{'x':23,'y':26},{'x':27,'y':26},{'x':24,'y':27},{'x':26,'y':27}]

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24}]

4

4: object

name

name: string = "hatchery"

rcl

rcl: string = "4"

shard

shard: string = "shard0"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x':25,'y':25}]

extension

extension: object

pos

pos: object[] = [{'x':23,'y':22},{'x':24,'y':22},{'x':26,'y':22},{'x':27,'y':22},{'x':24,'y':23},{'x':26,'y':23},{'x':22,'y':24},{'x':23,'y':24},{'x':27,'y':24},{'x':28,'y':24},{'x':22,'y':26},{'x':23,'y':26},{'x':27,'y':26},{'x':28,'y':26},{'x':24,'y':27},{'x':26,'y':27},{'x':23,'y':28},{'x':24,'y':28},{'x':26,'y':28},{'x':27,'y':28}]

road

road: object

pos

pos: object[] = [{'x':25,'y':25},{'x':25,'y':20},{'x':21,'y':21},{'x':24,'y':21},{'x':26,'y':21},{'x':29,'y':21},{'x':22,'y':22},{'x':25,'y':22},{'x':28,'y':22},{'x':23,'y':23},{'x':25,'y':23},{'x':27,'y':23},{'x':21,'y':24},{'x':24,'y':24},{'x':26,'y':24},{'x':29,'y':24},{'x':20,'y':25},{'x':22,'y':25},{'x':23,'y':25},{'x':27,'y':25},{'x':28,'y':25},{'x':30,'y':25},{'x':21,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':29,'y':26},{'x':23,'y':27},{'x':25,'y':27},{'x':27,'y':27},{'x':22,'y':28},{'x':25,'y':28},{'x':28,'y':28},{'x':21,'y':29},{'x':24,'y':29},{'x':26,'y':29},{'x':29,'y':29},{'x':25,'y':30}]

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24}]

5

5: object

name

name: string = "hatchery"

rcl

rcl: string = "5"

shard

shard: string = "shard0"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x':25,'y':25}]

extension

extension: object

pos

pos: object[] = [{'x':23,'y':21},{'x':27,'y':21},{'x':23,'y':22},{'x':24,'y':22},{'x':26,'y':22},{'x':27,'y':22},{'x':21,'y':23},{'x':22,'y':23},{'x':24,'y':23},{'x':26,'y':23},{'x':28,'y':23},{'x':29,'y':23},{'x':22,'y':24},{'x':23,'y':24},{'x':27,'y':24},{'x':28,'y':24},{'x':22,'y':26},{'x':23,'y':26},{'x':27,'y':26},{'x':28,'y':26},{'x':22,'y':27},{'x':24,'y':27},{'x':26,'y':27},{'x':28,'y':27},{'x':29,'y':27},{'x':23,'y':28},{'x':24,'y':28},{'x':26,'y':28},{'x':27,'y':28},{'x':27,'y':29}]

link

link: object

pos

pos: object[] = [{'x':25,'y':26}]

road

road: object

pos

pos: object[] = [{'x':25,'y':25},{'x':25,'y':20},{'x':21,'y':21},{'x':24,'y':21},{'x':26,'y':21},{'x':29,'y':21},{'x':22,'y':22},{'x':25,'y':22},{'x':28,'y':22},{'x':23,'y':23},{'x':25,'y':23},{'x':27,'y':23},{'x':21,'y':24},{'x':24,'y':24},{'x':26,'y':24},{'x':29,'y':24},{'x':20,'y':25},{'x':22,'y':25},{'x':23,'y':25},{'x':27,'y':25},{'x':28,'y':25},{'x':30,'y':25},{'x':21,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':29,'y':26},{'x':23,'y':27},{'x':25,'y':27},{'x':27,'y':27},{'x':22,'y':28},{'x':25,'y':28},{'x':28,'y':28},{'x':21,'y':29},{'x':24,'y':29},{'x':26,'y':29},{'x':29,'y':29},{'x':25,'y':30}]

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24}]

tower

tower: object

pos

pos: object[] = [{'x':29,'y':25}]

6

6: object

name

name: string = "hatchery"

rcl

rcl: string = "6"

shard

shard: string = "shard0"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x':25,'y':25}]

extension

extension: object

pos

pos: object[] = [{'x':22,'y':21},{'x':23,'y':21},{'x':27,'y':21},{'x':28,'y':21},{'x':21,'y':22},{'x':23,'y':22},{'x':24,'y':22},{'x':26,'y':22},{'x':27,'y':22},{'x':29,'y':22},{'x':21,'y':23},{'x':22,'y':23},{'x':24,'y':23},{'x':26,'y':23},{'x':28,'y':23},{'x':29,'y':23},{'x':22,'y':24},{'x':23,'y':24},{'x':27,'y':24},{'x':28,'y':24},{'x':22,'y':26},{'x':23,'y':26},{'x':27,'y':26},{'x':28,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':24,'y':27},{'x':26,'y':27},{'x':28,'y':27},{'x':29,'y':27},{'x':21,'y':28},{'x':23,'y':28},{'x':24,'y':28},{'x':26,'y':28},{'x':27,'y':28},{'x':29,'y':28},{'x':22,'y':29},{'x':23,'y':29},{'x':27,'y':29},{'x':28,'y':29}]

link

link: object

pos

pos: object[] = [{'x':25,'y':26}]

road

road: object

pos

pos: object[] = [{'x':25,'y':25},{'x':25,'y':20},{'x':21,'y':21},{'x':24,'y':21},{'x':26,'y':21},{'x':29,'y':21},{'x':22,'y':22},{'x':25,'y':22},{'x':28,'y':22},{'x':23,'y':23},{'x':25,'y':23},{'x':27,'y':23},{'x':21,'y':24},{'x':24,'y':24},{'x':26,'y':24},{'x':29,'y':24},{'x':20,'y':25},{'x':22,'y':25},{'x':23,'y':25},{'x':27,'y':25},{'x':28,'y':25},{'x':30,'y':25},{'x':21,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':29,'y':26},{'x':23,'y':27},{'x':25,'y':27},{'x':27,'y':27},{'x':22,'y':28},{'x':25,'y':28},{'x':28,'y':28},{'x':21,'y':29},{'x':24,'y':29},{'x':26,'y':29},{'x':29,'y':29},{'x':25,'y':30}]

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24}]

tower

tower: object

pos

pos: object[] = [{'x':29,'y':25}]

7

7: object

name

name: string = "hatchery"

rcl

rcl: string = "7"

shard

shard: string = "shard0"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x':25,'y':25}]

extension

extension: object

pos

pos: object[] = [{'x':21,'y':20},{'x':22,'y':20},{'x':28,'y':20},{'x':29,'y':20},{'x':20,'y':21},{'x':22,'y':21},{'x':23,'y':21},{'x':27,'y':21},{'x':28,'y':21},{'x':30,'y':21},{'x':20,'y':22},{'x':21,'y':22},{'x':23,'y':22},{'x':24,'y':22},{'x':26,'y':22},{'x':27,'y':22},{'x':29,'y':22},{'x':30,'y':22},{'x':21,'y':23},{'x':22,'y':23},{'x':24,'y':23},{'x':26,'y':23},{'x':28,'y':23},{'x':29,'y':23},{'x':22,'y':24},{'x':23,'y':24},{'x':27,'y':24},{'x':28,'y':24},{'x':22,'y':26},{'x':23,'y':26},{'x':27,'y':26},{'x':28,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':24,'y':27},{'x':26,'y':27},{'x':28,'y':27},{'x':29,'y':27},{'x':21,'y':28},{'x':23,'y':28},{'x':24,'y':28},{'x':26,'y':28},{'x':27,'y':28},{'x':29,'y':28},{'x':20,'y':29},{'x':22,'y':29},{'x':23,'y':29},{'x':27,'y':29},{'x':28,'y':29},{'x':30,'y':29}]

link

link: object

pos

pos: object[] = [{'x':25,'y':26}]

road

road: object

pos

pos: object[] = [{'x':25,'y':25},{'x':25,'y':20},{'x':21,'y':21},{'x':24,'y':21},{'x':26,'y':21},{'x':29,'y':21},{'x':22,'y':22},{'x':25,'y':22},{'x':28,'y':22},{'x':23,'y':23},{'x':25,'y':23},{'x':27,'y':23},{'x':21,'y':24},{'x':24,'y':24},{'x':26,'y':24},{'x':29,'y':24},{'x':20,'y':25},{'x':22,'y':25},{'x':23,'y':25},{'x':27,'y':25},{'x':28,'y':25},{'x':30,'y':25},{'x':21,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':29,'y':26},{'x':23,'y':27},{'x':25,'y':27},{'x':27,'y':27},{'x':22,'y':28},{'x':25,'y':28},{'x':28,'y':28},{'x':21,'y':29},{'x':24,'y':29},{'x':26,'y':29},{'x':29,'y':29},{'x':25,'y':30}]

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24},{'x':24,'y':25}]

tower

tower: object

pos

pos: object[] = [{'x':29,'y':25}]

8

8: object

name

name: string = "hatchery"

rcl

rcl: string = "8"

shard

shard: string = "shard0"

buildings

buildings: object

container

container: object

pos

pos: object[] = [{'x':25,'y':25}]

extension

extension: object

pos

pos: object[] = [{'x':20,'y':20},{'x':21,'y':20},{'x':22,'y':20},{'x':28,'y':20},{'x':29,'y':20},{'x':30,'y':20},{'x':20,'y':21},{'x':22,'y':21},{'x':23,'y':21},{'x':27,'y':21},{'x':28,'y':21},{'x':30,'y':21},{'x':20,'y':22},{'x':21,'y':22},{'x':23,'y':22},{'x':24,'y':22},{'x':26,'y':22},{'x':27,'y':22},{'x':29,'y':22},{'x':30,'y':22},{'x':21,'y':23},{'x':22,'y':23},{'x':24,'y':23},{'x':26,'y':23},{'x':28,'y':23},{'x':29,'y':23},{'x':22,'y':24},{'x':23,'y':24},{'x':27,'y':24},{'x':28,'y':24},{'x':22,'y':26},{'x':23,'y':26},{'x':27,'y':26},{'x':28,'y':26},{'x':21,'y':27},{'x':22,'y':27},{'x':24,'y':27},{'x':26,'y':27},{'x':28,'y':27},{'x':29,'y':27},{'x':20,'y':28},{'x':21,'y':28},{'x':23,'y':28},{'x':24,'y':28},{'x':26,'y':28},{'x':27,'y':28},{'x':29,'y':28},{'x':30,'y':28},{'x':20,'y':29},{'x':22,'y':29},{'x':23,'y':29},{'x':27,'y':29},{'x':28,'y':29},{'x':30,'y':29},{'x':20,'y':30},{'x':21,'y':30},{'x':22,'y':30},{'x':28,'y':30},{'x':29,'y':30},{'x':30,'y':30}]

link

link: object

pos

pos: object[] = [{'x':25,'y':26}]

road

road: object

pos

pos: object[] = [{'x':25,'y':25},{'x':25,'y':20},{'x':21,'y':21},{'x':24,'y':21},{'x':26,'y':21},{'x':29,'y':21},{'x':22,'y':22},{'x':25,'y':22},{'x':28,'y':22},{'x':23,'y':23},{'x':25,'y':23},{'x':27,'y':23},{'x':21,'y':24},{'x':24,'y':24},{'x':26,'y':24},{'x':29,'y':24},{'x':20,'y':25},{'x':22,'y':25},{'x':23,'y':25},{'x':27,'y':25},{'x':28,'y':25},{'x':30,'y':25},{'x':21,'y':26},{'x':24,'y':26},{'x':26,'y':26},{'x':29,'y':26},{'x':23,'y':27},{'x':25,'y':27},{'x':27,'y':27},{'x':22,'y':28},{'x':25,'y':28},{'x':28,'y':28},{'x':21,'y':29},{'x':24,'y':29},{'x':26,'y':29},{'x':29,'y':29},{'x':25,'y':30}]

spawn

spawn: object

pos

pos: object[] = [{'x':25,'y':24},{'x':24,'y':25},{'x':26,'y':25}]

tower

tower: object

pos

pos: object[] = [{'x':25,'y':21},{'x':21,'y':25},{'x':29,'y':25},{'x':25,'y':29}]

data

data: object

anchor

anchor: object

x

x: number = 25

y

y: number = 24

Const maxMarketPrices

maxMarketPrices: object

__computed

__computed: number = 0.5

default

default: number = 5

Const priorityStockAmounts

priorityStockAmounts: object

G

G: number = 2000

GHO2

GHO2: number = 1000

GO

GO: number = 1000

KHO2

KHO2: number = 1000

KO

KO: number = 1000

LHO2

LHO2: number = 1000

LO

LO: number = 1000

UH

UH: number = 1000

UH2O

UH2O: number = 1000

XGHO2

XGHO2: number = 1000

XKHO2

XKHO2: number = 1000

XLHO2

XLHO2: number = 1000

XUH2O

XUH2O: number = 1000

XZH2O

XZH2O: number = 1000

XZHO2

XZHO2: number = 1000

ZH

ZH: number = 1000

ZH2O

ZH2O: number = 1000

ZHO2

ZHO2: number = 1000

ZO

ZO: number = 1000

Const quadrantFillOrder

quadrantFillOrder: object

lowerLeft

lowerLeft: object[] = [{'x': 22, 'y': 26}, {'x': 22, 'y': 27}, {'x': 23, 'y': 27}, {'x': 23, 'y': 28}, {'x': 24,'y': 28}, {'x': 25, 'y': 27}, {'x': 24, 'y': 29}, {'x': 25, 'y': 29}, {'x': 25, 'y': 30}, {'x': 26, 'y': 30}, {'x': 24,'y': 30}, {'x': 23, 'y': 30}, {'x': 23, 'y': 29}, {'x': 22, 'y': 29}, {'x': 22, 'y': 28}, {'x': 21, 'y': 28}, {'x': 21,'y': 27}]

lowerRight

lowerRight: object[] = [{'x': 30, 'y': 24}, {'x': 30, 'y': 25}, {'x': 29, 'y': 25}, {'x': 29, 'y': 26}, {'x': 28, 'y': 26}, {'x': 27,'y': 25}, {'x': 28, 'y': 27}, {'x': 27, 'y': 27}, {'x': 27, 'y': 28}, {'x': 26, 'y': 28}, {'x': 27, 'y': 29}, {'x': 28,'y': 29}, {'x': 28, 'y': 28}, {'x': 29, 'y': 28}, {'x': 29, 'y': 27}, {'x': 30, 'y': 27}, {'x': 30, 'y': 26}]

upperLeft

upperLeft: object[] = [{'x': 23, 'y': 21}, {'x': 23, 'y': 22}, {'x': 24, 'y': 22}, {'x': 23, 'y': 23}, {'x': 22,'y': 23}, {'x': 22, 'y': 24}, {'x': 23, 'y': 25}, {'x': 21, 'y': 24}, {'x': 21, 'y': 25}, {'x': 20, 'y': 25}, {'x': 20,'y': 26}, {'x': 22, 'y': 21}, {'x': 22, 'y': 22}, {'x': 21, 'y': 22}, {'x': 21, 'y': 23}, {'x': 20, 'y': 23}, {'x': 20,'y': 24}]

upperRight

upperRight: object[] = [{'x': 24, 'y': 20}, {'x': 25, 'y': 20}, {'x': 25, 'y': 21}, {'x': 26, 'y': 21}, {'x': 26,'y': 22}, {'x': 27, 'y': 22}, {'x': 27, 'y': 23}, {'x': 25, 'y': 23}, {'x': 28, 'y': 23}, {'x': 28, 'y': 24}, {'x': 29,'y': 23}, {'x': 29, 'y': 22}, {'x': 28, 'y': 22}, {'x': 28, 'y': 21}, {'x': 27, 'y': 21}, {'x': 27, 'y': 20}, {'x': 26,'y': 20}]

Const wantedStockAmounts

wantedStockAmounts: object

G

G: number = 5000

KO

KO: number = 3000

LH

LH: number = 3000

UH

UH: number = 3000

XGH2O

XGH2O: number = 12000

XGHO2

XGHO2: number = 10000

XKH2O

XKH2O: number = 3000

XKHO2

XKHO2: number = 8000

XLH2O

XLH2O: number = 3000

XLHO2

XLHO2: number = 10000

XUH2O

XUH2O: number = 8000

XUHO2

XUHO2: number = 3000

XZH2O

XZH2O: number = 6000

XZHO2

XZHO2: number = 6000

Generated using TypeDoc