References

C Application

F applyLanguage(languageCode: *): boolean

F autoDetectLanguageId(): string

F matchOverwriteRecursive(dest: *, src: *)

F updateApplicationLanguage(id: *)

V CHANGELOG: Array<{version: string, date: string, entries: Array<String>}>

V LANGUAGES: Object<string, {name: string, data: any, code: string, region: string}>

V T: *

C AnimationFrame

C BackgroundResourcesLoader

C BufferMaintainer

C DrawParameters

C ExplainedResult

C Factory

C GameState

C InputDistributor

C InputReceiver

C LoaderImpl

C Dialog

C DialogLoading

C DialogOptionChooser

C DialogWithForm

C FormElement

C FormElementCheckbox

C FormElementInput

C FormElementItemChooser

C ReadWriteProxy

C Rectangle

C RequestChannel

C RestrictionManager

C RandomNumberGenerator

C Signal

C SingletonFactory

C AtlasSprite

C BaseSprite

C RegularSprite

C SpriteAtlasLink

C StaleAreaDetector

C StateManager

C TextualGameState

C TrackedState

C Vector

F cachebust(path: string): *

F getDeviceDPI(): number

F prepareHighDPIContext(context: CanvasRenderingContext2D)

F resizeCanvas(canvas: HTMLCanvasElement, w: number, h: number)

F resizeCanvasAndClear(canvas: HTMLCanvasElement, context: CanvasRenderingContext2D, w: number, h: number)

F resizeHighDPICanvas(canvas: HTMLCanvasElement, w: number, h: number)

F smoothenDpi(dpi: number): number

F drawRotatedSprite(param0: object)

F drawSpriteClipped(param0: object)

F initDrawUtils()

F initBuildingsByCategory(buildings: Object<string, Array<Class<import("../game/meta_building").MetaBuilding>>>)

F setGlobalApp(app: Application)

F createLogger(context: *): *

F globalDebug(context: *, args: ...*)

F globalError(context: *, args: ...*)

F globalLog(context: *, args: ...*)

F globalWarn(context: *, args: ...*)

F logSection(name: *, color: *)

F serializeError(err: Error | ErrorEvent): *

F stringifyObjectContainingErrors(payload: any): *

F compressU8(uncompressed: *): *

F compressU8WHeader(uncompressed: string, header: number): *

F compressX64(input: *): *

F decompressU8WHeader(compressed: Uint8Array): *

F decompressX64(input: *): *

F computeCrc(str: string): *

F getNameOfProvider(): *

F sha1(str: *): *

F accessNestedPropertyReverse(obj: any, keys: Array<string>): *

F arrayDelete(array: Array<any>, index: number)

F arrayDeleteValue(array: Array<any>, value: any): *

F clamp(v: number, minimum: number=, maximum: number=): *

F epsilonCompare(a: number, b: number): boolean

F fastArrayDelete(array: Array<any>, index: number)

F fastArrayDeleteValue(array: Array<any>, value: any): *

F fastArrayDeleteValueIfContained(array: Array<any>, value: any): *

F fillInLinkIntoTranslation(translation: string, link: string): *

F findNiceIntegerValue(num: number): *

F findNiceValue(num: number): *

F formatBigNumber(num: number, separator: string=): string

F formatBigNumberFull(num: number, divider: string=): string

F formatItemsPerSecond(speed: number, double: boolean=, separator: string=): *

F formatSeconds(secs: number): string

F formatSecondsToTimeAgo(secs: number): string

F generateFileDownload(filename: string, text: string)

F generateMatrixRotations(originalMatrix: Array<number>): Object<number, Array<number>>

F getIPCRenderer(): *

F getPlatformName(): "android" | "browser" | "ios" | "standalone" | "unknown"

F getRomanNumber(number: number): string

F isAndroid(): boolean

F isIos(): boolean

F isSupportedBrowser(): boolean

F lerp(a: number, b: number, x: number): *

F make2DUndefinedArray(w: number, h: number): Array<Array<any>>

F makeButton(parent: Element, classes: Array<string>=, innerHTML: string=): *

F makeButtonElement(classes: Array<string>=, innerHTML: string=): *

F makeDiv(parent: Element, id: string=, classes: Array<string>=, innerHTML: string=): *

F newEmptyMap(): *

F randomChoice(arr: T[]): T

F randomInt(start: number, end: number): *

F removeAllChildren(elem: Element)

F rotateDirectionalObject(obj: DirectionalObject): DirectionalObject

F rotateFlatMatrix3x3(flatMatrix: Array<number>): undefined[]

F round1Digit(n: number): number

F round1DigitLocalized(speed: number, separator: string=): *

F round2Digits(n: number): number

F round3Digits(n: number): number

F round4Digits(n: number): number

F safeModulo(n: number, m: number): *

F smoothPulse(time: number): number

F startFileChoose(acceptedType: string): *

F waitNextFrame(): Promise<void>

F mixVector(v1: Vector, v2: Vector, a: number): *

V asyncCompressor: *

V compressionPrefix: *

V atlasFiles: AtlasDefinition[]

V MAX_MOVE_DISTANCE_PX: *

V clickDetectorGlobals: {"lastTouchTime": *}

V A_B_TESTING_LINK_TYPE: string

V IS_DEBUG: *

V IS_MAC: *

V IS_MOBILE: *

V SUPPORT_TOUCH: boolean

V THIRDPARTY_URLS: {"discord": string, "github": string, "reddit": string, "shapeViewer": string, "standaloneStorePage": string, "levelTutorialVideos": *}

V globalConfig: {"tileSize": number, "halfTileSize": number, "assetsDpi": *, "assetsSharpness": number, "shapesSharpness": number, "statisticsGraphDpi": number, "statisticsGraphSlices": number, "analyticsSliceDurationSeconds": *, "minimumTickRate": number, "maximumTickRate": number, "mapChunkSize": number, "mapChunkOverviewMinZoom": number, "mapChunkWorldSize": *, "beltSpeedItemsPerSecond": number, "minerSpeedItemsPerSecond": *, "defaultItemDiameter": number, "itemSpacingOnBelts": number, "wiresSpeedItemsPerSecond": number, "undergroundBeltMaxTilesByTier": *, "readerAnalyzeIntervalSeconds": number, "buildingSpeeds": *, "initialZoom": number, "minZoomLevel": number, "maxZoomLevel": number, "gameSpeed": number, "warmupTimeSecondsFast": number, "warmupTimeSecondsRegular": number, "smoothing": *, "rendering": *, "debug": *, "info": *}

V APPLICATION_ERROR_OCCURED: boolean

V gBuildingsByCategory: Object<string, Array<Class<import("../game/meta_building").MetaBuilding>>>

V gComponentRegistry: FactoryTemplate<import("../game/component").Component>

V gGameModeRegistry: FactoryTemplate<GameMode>

V gGameSpeedRegistry: FactoryTemplate<import("../game/time/base_game_speed").BaseGameSpeed>

V gItemRegistry: FactoryTemplate<import("../game/base_item").BaseItem>

V gMetaBuildingRegistry: SingletonFactoryTemplate<import("../game/meta_building").MetaBuilding>

V GLOBAL_APP: Application

V Loader: LoaderImpl

V queryParamOptions: {"embedProvider": *, "fullVersion": *, "sandboxMode": *}

V PROMISE_ABORTED: string

V CRC_PREFIX: *

V STOP_PROPAGATION: string

V FULL_CLIP_RECT: Rectangle

V ORIGINAL_SPRITE_SCALE: string

V arrayAllDirections: Array<enumDirection>

V enumAngleToDirection: {"0": *, "90": *, "180": *, "270": *}

V enumDirection: {"top": string, "right": string, "bottom": string, "left": string}

V enumDirectionToAngle: {"undefined": number}

V enumDirectionToVector: {"top": *, "right": *, "bottom": *, "left": *}

V enumInvertedDirections: {"undefined": *}

T JobEntry: function(message: any): void,

T SourceData: { frames: Object.<string, SpriteDefinition>, meta: AtlasMeta }

T CacheEntry: { canvas: HTMLCanvasElement, context: CanvasRenderingContext2D, lastUse: number, }

T ClickDetectorConstructorArgs: { consumeEvents?: boolean, preventDefault?: boolean, applyCssClass?: string, captureTouchmove?: boolean, targetOnly?: boolean, maxDistance?: number, clickSound?: string, preventClick?: boolean, }

T DirectionalObject: { top: any, right: any, bottom: any, left: any }

C AutomaticSave

C BaseItem

C BeltPath

C Blueprint

C Camera

C Component

C GameCore

C DynamicTickrate

C Entity

C EntityComponentStorage

C EntityManager

C GameLoadingOverlay

C GameSystem

C GameSystemManager

C GameSystemWithFilter

C HubGoals

C KeyActionMapper

C Keybinding

C BaseMap

C MapChunk

C MapChunkView

C MapView

C MetaBuilding

C ProductionAnalytics

C GameRoot

C ShapeDefinition

C ShapeDefinitionManager

C SoundProxy

F getBuildingDataFromCode(code: String): BuildingVariantIdentifier

F getCodeFromBuildingData(metaBuilding: MetaBuilding, variant: string, rotationVariant: number): String

F registerBuildingVariant(meta: typeof MetaBuilding, variant: string, rotationVariant: number)

F addVanillaComponentsToAPI()

F initComponentRegistry()

F addVanillaGameModesToAPI()

F initGameModeRegistry()

F addVanillaGameSpeedToAPI()

F initGameSpeedRegistry()

F addVanillaSystemsToAPI()

F getRandomHint(): *

F addVanillaItemsToAPI()

F initItemRegistry()

F itemResolverSingleton(root: import("./root").GameRoot, data: {$: string, data: any}): *

F getStringForKeyCode(code: number): string

F addVanillaBuildingsToAPI()

F initBuildingCodesAfterResourcesLoaded()

F initMetaBuildingRegistry()

F createSimpleShape(layers: *): Array<import("./shape_definition").ShapeLayer>

F applyGameTheme(id: *)

V enumSavePriority: {"regular": number, "asap": number}

V gBuildingVariants: Object<number, BuildingVariantIdentifier>

V USER_INTERACT_MOVE: string

V USER_INTERACT_TOUCHEND: string

V USER_INTERACT_ZOOM: string

V enumMouseButton: {"left": string, "middle": string, "right": string}

V enumColorMixingResults: {"undefined": *}

V enumColorToShortcode: {"undefined": string}

V enumColors: {"red": string, "green": string, "blue": string, "yellow": string, "purple": string, "cyan": string, "white": string, "uncolored": string}

V enumColorsToHexCode: {"undefined": string}

V enumShortcodeToColor: {}

V typeItemSingleton: *

V KEYCODE_LMB: number

V KEYCODE_MMB: number

V KEYCODE_RMB: number

V KEYMAPPINGS: {"general": *, "ingame": *, "navigation": *, "buildings": *, "placement": *, "massSelect": *, "placementModifiers": *}

V CHUNK_OVERLAY_RES: number

V defaultBuildingVariant: string

V enumAnalyticsDataSource: {"produced": string, "stored": string, "delivered": string}

V layers: Array<Layer>

V enumShortcodeToSubShape: {}

V enumSubShape: {"rect": string, "circle": string, "star": string, "windmill": string}

V enumSubShapeToShortcode: {"undefined": string}

V THEME: *

V VANILLA_THEMES: {"dark": *, "light": *}

V enumHubGoalRewards: {"reward_cutter_and_trash": string, "reward_rotater": string, "reward_painter": string, "reward_mixer": string, "reward_stacker": string, "reward_balancer": string, "reward_tunnel": string, "reward_rotater_ccw": string, "reward_rotater_180": string, "reward_miner_chainable": string, "reward_underground_belt_tier_2": string, "reward_belt_reader": string, "reward_splitter": string, "reward_cutter_quad": string, "reward_painter_double": string, "reward_storage": string, "reward_merger": string, "reward_wires_painter_and_levers": string, "reward_display": string, "reward_constant_signal": string, "reward_logic_gates": string, "reward_virtual_processing": string, "reward_filter": string, "reward_demo_end": string, "reward_blueprints": string, "reward_freeplay": string, "no_reward": string, "no_reward_freeplay": string}

V enumHubGoalRewardsToContentUnlocked: {"undefined": *}

T BuildingVariantIdentifier: { metaClass: typeof MetaBuilding, metaInstance?: MetaBuilding, variant?: string, rotationVariant?: number, tileSize?: Vector, sprite?: AtlasSprite, blueprintSprite?: AtlasSprite, silhouetteColor?: string }

T StaticComponent: typeof Component

T null: typeof Component[]

T LevelDefinition: { shape: string, required: number, reward: enumHubGoalRewards, throughputOnly?: boolean }

T TierRequirement: { required: Array<UpgradeRequirement> improvement?: number, excludePrevious?: boolean }

T UpgradeRequirement: { shape: string, amount: number }

T UpgradeTiers: Array<TierRequirement>

T AcceptorsAffectingTile: Array<{ entity: Entity, slot: import("./components/item_acceptor").ItemAcceptorSlot, toTile: Vector, fromDirection: enumDirection }>

T AcceptorsAndEjectorsAffectingTile: { acceptors: AcceptorsAffectingTile, ejectors: EjectorsAffectingTile }

T EjectorsAffectingTile: Array<{ entity: Entity, slot: import("./components/item_ejector").ItemEjectorSlot, fromTile: Vector, toDirection: enumDirection }>

T ShapeLayer: [ShapeLayerItem?, ShapeLayerItem?, ShapeLayerItem?, ShapeLayerItem?]

T ShapeLayerItem: { subShape: enumSubShape, color: enumColors, }

T TutorialGoalReward: Array<[typeof MetaBuilding, string]>

C MetaAnalyzerBuilding

C MetaBalancerBuilding

C MetaBeltBuilding

C MetaComparatorBuilding

C MetaConstantSignalBuilding

C MetaCutterBuilding

C MetaDisplayBuilding

C MetaFilterBuilding

C MetaHubBuilding

C MetaItemProducerBuilding

C MetaLeverBuilding

C MetaLogicGateBuilding

C MetaMinerBuilding

C MetaMixerBuilding

C MetaPainterBuilding

C MetaReaderBuilding

C MetaRotaterBuilding

C MetaStackerBuilding

C MetaStorageBuilding

C MetaTransistorBuilding

C MetaTrashBuilding

C MetaUndergroundBeltBuilding

C MetaVirtualProcessorBuilding

C MetaWireBuilding

C MetaWireTunnelBuilding

C BeltComponent

C BeltReaderComponent

C ConstantSignalComponent

C DisplayComponent

C HubComponent

C ItemProducerComponent

C LeverComponent

C LogicGateComponent

C MinerComponent

C StaticMapEntityComponent

C StorageComponent

C WireComponent

C WireTunnelComponent

V enumClippedBeltUnderlayType: {"full": string, "bottomOnly": string, "topOnly": string, "none": string}

V enumItemProcessorRequirements: {"painterQuad": string}

V enumItemProcessorTypes: {"balancer": string, "cutter": string, "cutterQuad": string, "rotater": string, "rotaterCCW": string, "rotater180": string, "stacker": string, "trash": string, "mixer": string, "painter": string, "painterDouble": string, "painterQuad": string, "hub": string, "filter": string, "reader": string}

V enumLogicGateType: {"and": string, "not": string, "xor": string, "or": string, "transistor": string, "analyzer": string, "rotater": string, "unstacker": string, "cutter": string, "compare": string, "stacker": string, "painter": string}

V enumUndergroundBeltMode: {"sender": string, "receiver": string}

V enumWireType: {"forward": string, "turn": string, "split": string, "cross": string}

V enumPinSlotType: {"logicalEjector": string, "logicalAcceptor": string}

T BeltUnderlayTile: { pos: Vector, direction: enumDirection, cachedType?: enumClippedBeltUnderlayType }

T PendingFilterItem: { item: BaseItem, progress: number }

T ItemAcceptorLocatedSlot: { slot: ItemAcceptorSlot, index: number, acceptedDirection: enumDirection }

T ItemAcceptorSlot: { pos: Vector, directions: enumDirection[], filter?: ItemType }

T ItemAcceptorSlotConfig: { pos: Vector, directions: enumDirection[], filter?: ItemType }

T ItemEjectorSlot: { pos: Vector, direction: enumDirection, item: BaseItem, progress: number?, cachedDestSlot?: import("./item_acceptor").ItemAcceptorLocatedSlot, cachedBeltPath?: BeltPath, cachedTargetEntity?: Entity }

T EjectorCharge: { remainingTime: number, items: Array<EjectorItemToEject>, }

T EjectorItemToEject: { item: BaseItem, requiredSlot?: number, preferredSlot?: number }

T LinkedUndergroundBelt: { entity: Entity, distance: number }

T WirePinSlot: { pos: Vector, type: enumPinSlotType, direction: enumDirection, value: BaseItem, linkedNetwork: import("../systems/wire").WireNetwork }

T WirePinSlotDefinition: { pos: Vector, type: enumPinSlotType, direction: enumDirection }

C BaseHUDPart

C DynamicDomAttach

C GameHUD

C TrailerMaker

C HUDBaseToolbar

C HUDBetaOverlay

C HUDBlueprintPlacer

C HUDBuildingPlacer

C HUDBuildingPlacerLogic

C HUDBuildingsToolbar

C HUDCatMemes

C HUDColorBlindHelper

C HUDConstantSignalEdit

C HUDDebugInfo

C HUDEntityDebugger

C HUDGameMenu

C HUDInteractiveTutorial

C HUDLayerPreview

C HUDLeverToggle

C HUDMassSelector

C HUDMinerHighlight

C HUDModalDialogs

C HUDNotifications

C HUDPinnedShapes

C HUDSandboxController

C HUDScreenshotExporter

C HUDSettingsMenu

C HUDShapeViewer

C HUDShop

C HUDStandaloneAdvantages

C HUDStatistics

C HUDShapeStatisticsHandle

C HUDPartTutorialHints

C HUDTutorialVideoOffer

C HUDUnlockNotification

C HUDVignetteOverlay

C HUDWatermark

C HUDWaypoints

C HUDWireInfo

C HUDWiresOverlay

C HUDWiresToolbar

V enumNotificationType: {"saved": string, "upgrade": string, "success": string}

V enumDisplayMode: {"icons": string, "detailed": string}

V statisticsUnitsSeconds: Object<string, number>

T DebugChange: { label: string, area: Rectangle, hideAt: number, fillColor: string }

T KeyBinding: number

T KeyCode: {keyCode: number}

T Waypoint: { label: string | null, center: { x: number, y: number }, zoomLevel: number, layer: Layer, }

C BooleanItem

C ColorItem

C ShapeItem

F isTrueItem(item: BaseItem): boolean

F isTruthyItem(item: BaseItem): boolean

V BOOL_FALSE_SINGLETON: BooleanItem

V BOOL_TRUE_SINGLETON: BooleanItem

C RegularGameMode

F generateLevelDefinitions(limitedVersion: boolean): *

C BeltSystem

C BeltReaderSystem

C BeltUnderlaysSystem

C ConstantSignalSystem

C DisplaySystem

C FilterSystem

C HubSystem

C ItemAcceptorSystem

C ItemEjectorSystem

C ItemProcessorOverlaysSystem

C ItemProducerSystem

C LeverSystem

C LogicGateSystem

C MapResourcesSystem

C MinerSystem

C StaticMapEntitySystem

C StorageSystem

C UndergroundBeltSystem

C WireNetwork

C WireSystem

C WiredPinsSystem

V BELT_ANIM_COUNT: number

T ProcessorImplementationPayload: { entity: Entity, items: Array<{ item: BaseItem, sourceSlot: number }>, itemsBySlot: Object<number, BaseItem>, outItems: Array<ProducedItem> }

T ProducedItem: { item: BaseItem, preferredSlot?: number, requiredSlot?: number, doNotTrack?: boolean }

C BaseGameSpeed

C FastForwardGameSpeed

C GameTime

C PausedGameSpeed

C RegularGameSpeed

C ShapezAPI

C ModManager

F matchOverwriteRecursiveSettings(dest: *, src: *)

T ModInfo: { title: String, id: String, description: String, authors: Array<String>, version: String, gameVersion: number, dependencies: Array<String>, incompatible: Array<String>, translations: {}, settings: {}, updateStaticSettings: Function, updateStaticTranslations: Function, gameInitializedRootClasses: Function, gameInitializedRootManagers: Function, gameBeforeFirstUpdate: Function, main: Function, }

T null: string[]

T ModPack: { mods: [ { url: string, id: string, config: {}, settings: {}, }, ], modOrder?: [], }

C AdProviderInterface

C AnalyticsInterface

C GameAnalyticsInterface

C MusicInstanceInterface

C SoundInstanceInterface

C SoundInterface

C StorageInterface

C PlatformWrapperInterface

V MUSIC: {"theme": *, "menu": string}

V SOUNDS: {"uiClick": string, "uiError": string, "dialogError": string, "dialogOk": string, "swishHide": string, "swishShow": string, "badgeNotification": string, "levelComplete": string, "destroyBuilding": string, "placeBuilding": string, "placeBelt": string, "copy": string}

V FILE_NOT_FOUND: string

C AdinplayAdProvider

C GamedistributionAdProvider

C NoAdProvider

C ShapezGameAnalytics

C GoogleAnalyticsImpl

C NoGameAnalytics

C SoundImplBrowser

C StorageImplBrowser

C StorageImplBrowserIndexedDB

C PlatformWrapperImplBrowser

C StorageImplElectron

C PlatformWrapperImplElectron

C ApplicationSettings

C BaseSetting

C BoolSetting

C EnumSetting

C RangeSetting

F allApplicationSettings(): *

F getApplicationSettingById(id: *): *

V autosaveIntervals: undefined[]

V enumCategories: {"general": string, "userInterface": string, "performance": string, "advanced": string, "debug": string}

V movementSpeeds: undefined[]

V scrollWheelSensitivities: undefined[]

V uiScales: undefined[]

C Savegame

C BaseSavegameInterface

C SavegameManager

C SavegameSerializer

C BasicSerializableObject

C BaseDataType

C TypeArray

C TypeBoolean

C TypeClass

C TypeClassData

C TypeClassFromMetaclass

C TypeClassId

C TypeEntity

C TypeEntityWeakref

C TypeEnum

C TypeFixedClass

C TypeInteger

C TypeKeyValueMap

C TypeMetaClass

C TypeNullable

C TypeNumber

C TypePair

C TypePositiveInteger

C TypePositiveNumber

C TypeString

C TypeStructuredObject

C TypeTileVector

C TypeVector

C SerializerInternal

F compressObject(obj: object): {"keys": *, "values": *, "data": *}

F decompressObject(obj: object): *

F getSavegameInterface(savegame: any): BaseSavegameInterface | null

F deserializeSchema(obj: object, schema: Schema, data: object, baseclassErrorResult: string | void | null=, root: import("../game/root").GameRoot=): string | void

F extendSchema(base: Schema, newOne: Schema): Schema

F serializeSchema(obj: object, schema: Schema, mergeWith: object=): object

F verifySchema(schema: Schema, data: object): string | void

F schemaToJsonSchema(schema: import("./serialization").Schema): *

V savegameInterfaces: Object<any, typeof BaseSavegameInterface>

V enumLocalSavegameStatus: {"offline": string, "synced": string}

V types: {"int": *, "uint": *, "float": *, "ufloat": *, "string": *, "entity": *, "weakEntityRef": *, "vector": *, "tileVector": *, "bool": *, "nullable": function, "classId": function, "keyValueMap": function, "enum": function, "obj": function, "objData": function, "knownType": function, "array": function, "fixedSizeArray": function, "classRef": function, "structured": function, "pair": function, "classWithMetaclass": function}

V globalJsonSchemaDefs: {}

T SavegamesData: { version: number, savegames: Array<SavegameMetadata> }

T Schema: Object<string, BaseDataType>

C SavegameInterface_V1000

C SavegameInterface_V1001

C SavegameInterface_V1002

C SavegameInterface_V1003

C SavegameInterface_V1004

C SavegameInterface_V1005

C SavegameInterface_V1006

C SavegameInterface_V1007

C SavegameInterface_ML01

V codes: {"1": *, "2": *, "3": *, "4": *, "5": *, "6": *, "47": *, "48": *, "7": *, "8": *, "9": *, "10": *, "11": *, "12": *, "13": *, "14": *, "15": *, "16": *, "17": *, "18": *, "19": *, "20": *, "21": *, "22": *, "23": *, "24": *, "25": *, "26": *, "27": *, "28": *, "29": *, "30": *, "52": *, "53": *, "54": *, "55": *, "31": *, "32": *, "34": *, "35": *, "36": *, "38": *, "60": *, "33": *, "37": *, "39": *, "40": *, "42": *, "44": *, "45": *, "50": *, "51": *, "46": *, "43": *, "49": *, "61": *}

T OldStaticMapEntity: { origin: TypeVector, tileSize: TypeVector, rotation: TypeNumber, originalRotation: TypeNumber, spriteKey?: string, blueprintSpriteKey: string, silhouetteColor: string }

C AboutState

C ChangelogState

C GameCreationPayload

C InGameState

C KeybindingsState

C MainMenuState

C MobileWarningState

C PreloadState

C SettingsState

V gameCreationAction: {"new": string, "resume": string}