@shipload/sdk 2.0.0-rc10 → 2.0.0-rc12

package/src/index-module.ts

@@ -21,7 +21,7 @@ export type task = ServerContract.Types.task
 export type cargo_item = ServerContract.Types.cargo_item
 export type warehouse_row = ServerContract.Types.warehouse_row
 export type container_row = ServerContract.Types.container_row
-export type extractor_stats = ServerContract.Types.extractor_stats
+export type gatherer_stats = ServerContract.Types.gatherer_stats
 
 export type location_static = ServerContract.Types.location_static
 export type location_epoch = ServerContract.Types.location_epoch
@@ -50,7 +50,8 @@ export {
     getSystemName,
     hasSystem,
     getLocationType,
-    isExtractableLocation,
+    getLocationTypeName,
+    isGatherableLocation,
     deriveLocationStatic,
     deriveLocationEpoch,
     deriveLocation,
@@ -65,7 +66,6 @@ export {
     getLocationCandidates,
     getDepthThreshold,
     getResourceTier,
-    depthScaleFactor,
     DEPTH_THRESHOLD_T1,
     DEPTH_THRESHOLD_T2,
     DEPTH_THRESHOLD_T3,
@@ -83,6 +83,9 @@ export {
 
 export type {StratumInfo, ResourceStats} from './derivation'
 
+export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './derivation'
+export type {ReserveTier, TierRange} from './derivation'
+
 export {getStatDefinitions, getStatName, resolveStats} from './derivation'
 export type {StatDefinition, NamedStats} from './derivation'
 
@@ -134,7 +137,12 @@ export type {HasCargo} from './entities/inventory-accessor'
 export * as cargoUtils from './entities/cargo-utils'
 export type {CargoData} from './entities/cargo-utils'
 
-export {projectEntity, projectEntityAt, createProjectedEntity} from './scheduling/projection'
+export {
+    createProjectedEntity,
+    projectEntity,
+    projectEntityAt,
+    validateSchedule,
+} from './scheduling/projection'
 export type {Projectable, ProjectedEntity} from './scheduling/projection'
 
 export * from './types/capabilities'
@@ -192,12 +200,12 @@ export {
     ITEM_GENERATOR_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
-    ITEM_DRILL_SHAFT,
-    ITEM_EXTRACTION_PROBE,
+    ITEM_MATTER_CONDUIT,
+    ITEM_SURVEY_PROBE,
     ITEM_CARGO_ARM,
     ITEM_TOOL_BIT,
     ITEM_REACTION_CHAMBER,
-    ITEM_EXTRACTOR_T1,
+    ITEM_GATHERER_T1,
     ITEM_LOADER_T1,
     ITEM_MANUFACTURING_T1,
     ITEM_STORAGE_T1,
@@ -229,8 +237,9 @@ export {
     blendCrossGroup,
     categoryItemMass,
     computeInputMass,
+    computeCraftedOutputSeed,
 } from './derivation/crafting'
-export type {StackInput, CategoryStacks} from './derivation/crafting'
+export type {StackInput, CategoryStacks, RecipeSlotInput} from './derivation/crafting'
 
 export {computeContainerCapabilities, computeContainerT2Capabilities} from './entities/container'
 
@@ -238,7 +247,7 @@ export {
     computeShipHullCapabilities,
     computeEngineCapabilities,
     computeGeneratorCapabilities,
-    computeExtractorCapabilities,
+    computeGathererCapabilities,
     computeHaulerCapabilities,
     computeLoaderCapabilities,
     computeManufacturingCapabilities,
@@ -285,10 +294,10 @@ export {
     computeEngineDrain,
     computeGeneratorCap,
     computeGeneratorRech,
-    computeExtractorRate,
-    computeExtractorDrain,
-    computeExtractorDepth,
-    computeExtractorDrill,
+    computeGathererYield,
+    computeGathererDrain,
+    computeGathererDepth,
+    computeGathererSpeed,
     computeLoaderMass,
     computeLoaderThrust,
     computeCrafterSpeed,

package/src/managers/actions.ts

@@ -97,9 +97,12 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    extract(shipId: UInt64Type): Action {
-        return this.server.action('extract', {
-            ship_id: UInt64.from(shipId),
+    gather(shipId: UInt64Type, stratum: number, quantity: number): Action {
+        return this.server.action('gather', {
+            entity_type: EntityType.SHIP,
+            id: UInt64.from(shipId),
+            stratum: UInt16.from(stratum),
+            quantity: UInt32.from(quantity),
         })
     }
 

package/src/market/items.ts

@@ -1,9 +1,14 @@
 import {UInt16, UInt16Type} from '@wharfkit/antelope'
 import {Item} from '../types'
 import itemsData from '../data/items.json'
+import {computeInputMass} from '../derivation/crafting'
+import {getComponentById, getEntityRecipeByItemId, getModuleRecipeByItemId} from '../data/recipes'
 
-const items: Item[] = itemsData.map((g) =>
-    Item.from({
+const itemsById: Map<number, Item> = new Map()
+const synthesizedCache: Map<number, Item> = new Map()
+
+for (const g of itemsData) {
+    const item = Item.from({
         id: g.id,
         name: g.name,
         description: g.description,
@@ -12,19 +17,73 @@ const items: Item[] = itemsData.map((g) =>
         tier: g.tier,
         color: g.color,
     })
-)
+    itemsById.set(item.id.toNumber(), item)
+}
+
+export const itemIds = Array.from(itemsById.values(), (i) => i.id)
+
+interface RecipeSource {
+    name: string
+    description: string
+    mass: number
+    color: string
+}
+
+function synthesizeItem(id: number, source: RecipeSource): Item {
+    return Item.from({
+        id,
+        name: source.name,
+        description: source.description,
+        mass: source.mass,
+        category: 'metal',
+        tier: 't1',
+        color: source.color,
+    })
+}
+
+function synthesizeFromRecipes(id: number): Item | undefined {
+    const component = getComponentById(id)
+    if (component) return synthesizeItem(id, component)
 
-export const itemIds = items.map((i) => i.id)
+    const entityRecipe = getEntityRecipeByItemId(id)
+    if (entityRecipe) {
+        return synthesizeItem(id, {
+            ...entityRecipe,
+            mass: computeInputMass(entityRecipe.id, 'entity'),
+        })
+    }
+
+    const moduleRecipe = getModuleRecipeByItemId(id)
+    if (moduleRecipe) {
+        return synthesizeItem(id, {
+            ...moduleRecipe,
+            mass: computeInputMass(moduleRecipe.id, 'module'),
+        })
+    }
+
+    return undefined
+}
 
 export function getItem(itemId: UInt16Type): Item {
-    const id = UInt16.from(itemId)
-    const item = items.find((i) => i.id.equals(id))
-    if (!item) {
-        throw new Error(`Item with id ${id} not found`)
+    const id = UInt16.from(itemId).toNumber()
+    const existing = itemsById.get(id) ?? synthesizedCache.get(id)
+    if (existing) return existing
+
+    const synthesized = synthesizeFromRecipes(id)
+    if (synthesized) {
+        synthesizedCache.set(id, synthesized)
+        return synthesized
     }
-    return item
+
+    throw new Error(`Item with id ${id} not found`)
 }
 
 export function getItems(): Item[] {
-    return items
+    return Array.from(itemsById.values())
+}
+
+export function registerItem(item: Item): void {
+    const id = item.id.toNumber()
+    itemsById.set(id, item)
+    synthesizedCache.delete(id)
 }

package/src/nft/description.ts

@@ -1,14 +1,14 @@
 import {
     getModuleCapabilityType,
     ITEM_ENGINE_T1,
-    ITEM_EXTRACTOR_T1,
+    ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
     ITEM_LOADER_T1,
     ITEM_MANUFACTURING_T1,
     ITEM_STORAGE_T1,
     MODULE_CRAFTER,
     MODULE_ENGINE,
-    MODULE_EXTRACTOR,
+    MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_LOADER,
     MODULE_STORAGE,
@@ -44,10 +44,10 @@ export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3,
 export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
 export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
 export const computeGeneratorRech = (clr: number): number => 5 + idiv(clr * 15, 1000)
-export const computeExtractorRate = (str: number): number => 200 + str
-export const computeExtractorDrain = (con: number): number => Math.max(10, 50 - idiv(con, 20))
-export const computeExtractorDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
-export const computeExtractorDrill = (ref: number): number => 100 + idiv(ref * 4, 5)
+export const computeGathererYield = (str: number): number => 200 + str
+export const computeGathererDrain = (con: number): number => Math.max(10, 50 - idiv(con, 20))
+export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
 export const computeLoaderMass = (duc: number): number => Math.max(200, 2000 - duc * 2)
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
@@ -74,8 +74,8 @@ export function moduleDisplayName(itemId: number): string {
             return 'Engine T1'
         case ITEM_GENERATOR_T1:
             return 'Generator T1'
-        case ITEM_EXTRACTOR_T1:
-            return 'Extractor T1'
+        case ITEM_GATHERER_T1:
+            return 'Gatherer T1'
         case ITEM_LOADER_T1:
             return 'Loader T1'
         case ITEM_MANUFACTURING_T1:
@@ -110,14 +110,14 @@ export function formatModuleLine(slot: number, itemId: number, seed: bigint): st
             out += `  Capacity ${computeGeneratorCap(res)}  Recharge ${computeGeneratorRech(clr)}`
             break
         }
-        case MODULE_EXTRACTOR: {
+        case MODULE_GATHERER: {
             const str = decodeStat(seed, 0)
             const tol = decodeStat(seed, 1)
             const con = decodeStat(seed, 3)
             const ref = decodeStat(seed, 4)
-            out += `  Rate ${computeExtractorRate(str)}  Depth ${computeExtractorDepth(
+            out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
                 tol
-            )}  Drill ${computeExtractorDrill(ref)}  Drain ${computeExtractorDrain(con)}`
+            )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
             break
         }
         case MODULE_LOADER: {

package/src/resolution/resolve-item.ts

@@ -8,7 +8,7 @@ import {
     isModuleItem,
     MODULE_CRAFTER,
     MODULE_ENGINE,
-    MODULE_EXTRACTOR,
+    MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_LOADER,
     MODULE_STORAGE,
@@ -18,7 +18,7 @@ import {deriveResourceStats} from '../derivation/stratum'
 import {getStatDefinitions} from '../derivation/stats'
 import {
     computeEngineCapabilities,
-    computeExtractorCapabilities,
+    computeGathererCapabilities,
     computeGeneratorCapabilities,
     computeLoaderCapabilities,
     computeManufacturingCapabilities,
@@ -163,15 +163,15 @@ function computeCapabilityGroup(
                 ],
             }
         }
-        case MODULE_EXTRACTOR: {
-            const caps = computeExtractorCapabilities(stats)
+        case MODULE_GATHERER: {
+            const caps = computeGathererCapabilities(stats)
             return {
-                capability: 'Extractor',
+                capability: 'Gatherer',
                 attributes: [
-                    {label: 'Rate', value: caps.rate},
+                    {label: 'Yield', value: caps.yield},
                     {label: 'Drain', value: caps.drain},
                     {label: 'Depth', value: caps.depth},
-                    {label: 'Drill', value: caps.drill},
+                    {label: 'Speed', value: caps.speed},
                 ],
             }
         }

package/src/scheduling/projection.ts

@@ -8,21 +8,30 @@ import {
     EntityCapabilities,
     EntityState,
 } from '../types/capabilities'
+import {ENTITY_CAPACITY_EXCEEDED} from '../errors'
 import {distanceBetweenCoordinates, lerp} from '../travel/travel'
-import {calcCargoItemMass, calcCargoMass} from '../capabilities/storage'
+import {
+    calcStacksMass,
+    cargoItemToStack,
+    CargoStack,
+    mergeStacks,
+    removeFromStacks,
+    stackToCargoItem,
+} from '../capabilities/storage'
 import * as schedule from './schedule'
 import {ScheduleData} from './schedule'
 
 export interface ProjectedEntity {
     location: Coordinates
     energy: UInt16
-    cargoMass: UInt64
+    cargo: CargoStack[]
     shipMass: UInt32
     capacity?: UInt64
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
     hauler?: ServerContract.Types.hauler_stats
+    readonly cargoMass: UInt64
     readonly totalMass: UInt64
 
     hasMovement(): boolean
@@ -52,7 +61,6 @@ function getHullMass(entity: Projectable): UInt32 {
 }
 
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
-    const cargoMass = calcCargoMass(entity)
     const shipMass = getHullMass(entity)
     const loaders = entity.loaders
     const engines = entity.engines
@@ -60,10 +68,12 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const hauler = entity.hauler
     const capacity = entity.capacity
 
+    const cargo: CargoStack[] = entity.cargo.map(cargoItemToStack)
+
     const projected: ProjectedEntity = {
         location: Coordinates.from(entity.coordinates),
         energy: UInt16.from(entity.energy ?? 0),
-        cargoMass,
+        cargo,
         shipMass,
         capacity: capacity ? UInt64.from(capacity) : undefined,
         engines,
@@ -71,6 +81,10 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         hauler,
         loaders,
 
+        get cargoMass() {
+            return calcStacksMass(this.cargo)
+        },
+
         get totalMass() {
             let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
             if (this.loaders) {
@@ -107,7 +121,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 location: ServerContract.Types.coordinates.from(this.location),
                 energy: this.energy,
                 cargomass: UInt32.from(this.cargoMass),
-                cargo: entity.cargo,
+                cargo: this.cargo.map(stackToCargoItem),
             }
         },
     }
@@ -162,18 +176,23 @@ function applyFlightTask(
     }
 }
 
-function applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+function addCargoItem(projected: ProjectedEntity, item: ServerContract.Types.cargo_item): void {
+    projected.cargo = mergeStacks(projected.cargo, cargoItemToStack(item))
+}
+
+function removeCargoItem(projected: ProjectedEntity, item: ServerContract.Types.cargo_item): void {
+    projected.cargo = removeFromStacks(projected.cargo, cargoItemToStack(item))
+}
+
+function applyAddCargoTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item))
+        addCargoItem(projected, item)
     }
 }
 
-function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+function applyRemoveCargoTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const cargoMass = calcCargoItemMass(item)
-        projected.cargoMass = projected.cargoMass.gt(cargoMass)
-            ? projected.cargoMass.subtracting(cargoMass)
-            : UInt64.from(0)
+        removeCargoItem(projected, item)
     }
 }
 
@@ -185,81 +204,80 @@ function applyEnergyCost(projected: ProjectedEntity, task: ServerContract.Types.
         : UInt16.from(0)
 }
 
-function applyExtractTask(
+function applyGatherTask(
     projected: ProjectedEntity,
     task: ServerContract.Types.task,
     options: {complete: boolean}
 ): void {
     if (!options.complete) return
-
     applyEnergyCost(projected, task)
-
-    for (const item of task.cargo) {
-        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item))
-    }
+    applyAddCargoTask(projected, task)
 }
 
 function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     applyEnergyCost(projected, task)
+    if (task.cargo.length === 0) return
 
-    if (task.cargo.length > 0) {
-        for (let i = 0; i < task.cargo.length - 1; i++) {
-            const inputMass = calcCargoItemMass(task.cargo[i])
-            projected.cargoMass = projected.cargoMass.gt(inputMass)
-                ? projected.cargoMass.subtracting(inputMass)
-                : UInt64.from(0)
-        }
-        const output = task.cargo[task.cargo.length - 1]
-        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(output))
+    for (let i = 0; i < task.cargo.length - 1; i++) {
+        removeCargoItem(projected, task.cargo[i])
     }
+    addCargoItem(projected, task.cargo[task.cargo.length - 1])
 }
 
 function applyDeployTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     applyEnergyCost(projected, task)
-
     if (task.cargo.length > 0) {
-        const mass = calcCargoItemMass(task.cargo[0])
-        projected.cargoMass = projected.cargoMass.gt(mass)
-            ? projected.cargoMass.subtracting(mass)
-            : UInt64.from(0)
+        removeCargoItem(projected, task.cargo[0])
+    }
+}
+
+function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    switch (task.type.toNumber()) {
+        case TaskType.RECHARGE:
+            applyRechargeTask(projected, task, {complete: true})
+            break
+        case TaskType.TRAVEL:
+            applyFlightTask(projected, task, {complete: true})
+            break
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+            applyAddCargoTask(projected, task)
+            break
+        case TaskType.UNLOAD:
+        case TaskType.WRAP:
+            applyRemoveCargoTask(projected, task)
+            break
+        case TaskType.GATHER:
+            applyGatherTask(projected, task, {complete: true})
+            break
+        case TaskType.CRAFT:
+            applyCraftTask(projected, task)
+            break
+        case TaskType.DEPLOY:
+            applyDeployTask(projected, task)
+            break
     }
 }
 
 export function projectEntity(entity: Projectable): ProjectedEntity {
     const projected = createProjectedEntity(entity)
-
-    if (!entity.schedule) {
-        return projected
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return projected
+    for (const task of entity.schedule.tasks) {
+        applyTask(projected, task)
     }
+    return projected
+}
 
+export function validateSchedule(entity: Projectable): void {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return
+
+    const projected = createProjectedEntity(entity)
     for (const task of entity.schedule.tasks) {
-        switch (task.type.toNumber()) {
-            case TaskType.RECHARGE:
-                applyRechargeTask(projected, task, {complete: true})
-                break
-            case TaskType.TRAVEL:
-                applyFlightTask(projected, task, {complete: true})
-                break
-            case TaskType.LOAD:
-                applyLoadTask(projected, task)
-                break
-            case TaskType.UNLOAD:
-                applyUnloadTask(projected, task)
-                break
-            case TaskType.EXTRACT:
-                applyExtractTask(projected, task, {complete: true})
-                break
-            case TaskType.CRAFT:
-                applyCraftTask(projected, task)
-                break
-            case TaskType.DEPLOY:
-            case TaskType.DEPLOY_SHIP:
-                applyDeployTask(projected, task)
-                break
+        applyTask(projected, task)
+        if (projected.capacity && projected.cargoMass.gt(projected.capacity)) {
+            throw new Error(ENTITY_CAPACITY_EXCEEDED)
         }
     }
-
-    return projected
 }
 
 export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
@@ -290,30 +308,21 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.LOAD:
-                if (taskComplete) {
-                    applyLoadTask(projected, task)
-                }
+            case TaskType.UNWRAP:
+                if (taskComplete) applyAddCargoTask(projected, task)
                 break
             case TaskType.UNLOAD:
-                if (taskComplete) {
-                    applyUnloadTask(projected, task)
-                }
+            case TaskType.WRAP:
+                if (taskComplete) applyRemoveCargoTask(projected, task)
                 break
-            case TaskType.EXTRACT:
-                if (taskComplete) {
-                    applyExtractTask(projected, task, {complete: true})
-                }
+            case TaskType.GATHER:
+                if (taskComplete) applyGatherTask(projected, task, {complete: true})
                 break
             case TaskType.CRAFT:
-                if (taskComplete) {
-                    applyCraftTask(projected, task)
-                }
+                if (taskComplete) applyCraftTask(projected, task)
                 break
             case TaskType.DEPLOY:
-            case TaskType.DEPLOY_SHIP:
-                if (taskComplete) {
-                    applyDeployTask(projected, task)
-                }
+                if (taskComplete) applyDeployTask(projected, task)
                 break
         }
     }

package/src/scheduling/schedule.ts

@@ -174,6 +174,6 @@ export function isUnloading(entity: ScheduleData, now: Date): boolean {
     return isTaskType(entity, TaskType.UNLOAD, now)
 }
 
-export function isExtracting(entity: ScheduleData, now: Date): boolean {
-    return isTaskType(entity, TaskType.EXTRACT, now)
+export function isGathering(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.GATHER, now)
 }

package/src/types/capabilities.ts

@@ -20,8 +20,8 @@ export interface LoaderCapability {
     loaders: ServerContract.Types.loader_stats
 }
 
-export interface ExtractorCapability {
-    extractor: ServerContract.Types.extractor_stats
+export interface GathererCapability {
+    gatherer: ServerContract.Types.gatherer_stats
 }
 
 export interface MassCapability {
@@ -38,7 +38,7 @@ export interface EntityCapabilities {
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
     loaders?: ServerContract.Types.loader_stats
-    extractor?: ServerContract.Types.extractor_stats
+    gatherer?: ServerContract.Types.gatherer_stats
     crafter?: ServerContract.Types.crafter_stats
 }
 
@@ -62,8 +62,8 @@ export function capsHasLoaders(caps: EntityCapabilities): boolean {
     return caps.loaders !== undefined
 }
 
-export function capsHasExtractor(caps: EntityCapabilities): boolean {
-    return caps.extractor !== undefined
+export function capsHasGatherer(caps: EntityCapabilities): boolean {
+    return caps.gatherer !== undefined
 }
 
 export function capsHasMass(caps: EntityCapabilities): boolean {

package/src/types/entity.ts

@@ -25,7 +25,7 @@ export type ShipEntity = Entity &
     Partial<LoaderCapability> &
     MassCapability &
     ScheduleCapability & {
-        extractor?: ServerContract.Types.extractor_stats
+        gatherer?: ServerContract.Types.gatherer_stats
     }
 
 export type WarehouseEntity = Entity &

package/src/types.ts

@@ -49,11 +49,12 @@ export enum TaskType {
     RECHARGE = 2,
     LOAD = 3,
     UNLOAD = 4,
-    EXTRACT = 5,
+    GATHER = 5,
     WARP = 6,
     CRAFT = 7,
     DEPLOY = 8,
-    DEPLOY_SHIP = 9,
+    WRAP = 9,
+    UNWRAP = 10,
 }
 
 export enum LocationType {

package/src/utils/system.ts

@@ -30,10 +30,23 @@ export function getLocationType(
     return LocationType.NEBULA
 }
 
-export function isExtractableLocation(locationType: LocationType): boolean {
+export function isGatherableLocation(locationType: LocationType): boolean {
     return locationType !== LocationType.EMPTY
 }
 
+export function getLocationTypeName(type: LocationType): string {
+    switch (type) {
+        case LocationType.EMPTY:
+            return 'Empty'
+        case LocationType.PLANET:
+            return 'Planet'
+        case LocationType.ASTEROID:
+            return 'Asteroid'
+        case LocationType.NEBULA:
+            return 'Nebula'
+    }
+}
+
 function uint16(hash: Checksum512, offset: number): number {
     return (hash.array[offset] << 8) | hash.array[offset + 1]
 }