@shipload/sdk 2.0.0-rc10 → 2.0.0-rc11

package/src/data/recipes.ts

@@ -1,6 +1,6 @@
 import {
     ITEM_ENGINE_T1,
-    ITEM_EXTRACTOR_T1,
+    ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
     ITEM_HAULER_T1,
     ITEM_LOADER_T1,
@@ -9,7 +9,7 @@ import {
     MODULE_ANY,
     MODULE_CRAFTER,
     MODULE_ENGINE,
-    MODULE_EXTRACTOR,
+    MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
     MODULE_LOADER,
@@ -20,15 +20,15 @@ import type {ResourceCategory} from '../types'
 export {
     ITEM_ENGINE_T1,
     ITEM_GENERATOR_T1,
-    ITEM_EXTRACTOR_T1,
+    ITEM_GATHERER_T1,
     ITEM_LOADER_T1,
     ITEM_MANUFACTURING_T1,
     ITEM_STORAGE_T1,
     ITEM_HAULER_T1,
 }
 
-export const ITEM_DRILL_SHAFT = 10005
-export const ITEM_EXTRACTION_PROBE = 10006
+export const ITEM_MATTER_CONDUIT = 10005
+export const ITEM_SURVEY_PROBE = 10006
 export const ITEM_CARGO_ARM = 10007
 export const ITEM_TOOL_BIT = 10008
 export const ITEM_REACTION_CHAMBER = 10009
@@ -158,9 +158,9 @@ export const components: ComponentDefinition[] = [
         usedIn: [{type: 'module', name: 'Generator'}],
     },
     {
-        id: ITEM_DRILL_SHAFT,
-        name: 'Drill Shaft',
-        description: 'Heavy-duty metal shaft used in extraction equipment.',
+        id: ITEM_MATTER_CONDUIT,
+        name: 'Matter Conduit',
+        description: 'Heavy-duty metal shaft used in gathering equipment.',
         color: '#7B8D9E',
         mass: 50000,
         stats: [
@@ -168,11 +168,11 @@ export const components: ComponentDefinition[] = [
             {key: 'tolerance', source: 'metal'},
         ],
         recipe: [{category: 'metal' as ResourceCategory, quantity: 15}],
-        usedIn: [{type: 'module', name: 'Extractor'}],
+        usedIn: [{type: 'module', name: 'Gatherer'}],
     },
     {
-        id: ITEM_EXTRACTION_PROBE,
-        name: 'Extraction Probe',
+        id: ITEM_SURVEY_PROBE,
+        name: 'Survey Probe',
         description: 'Precious metal sensor array for deep resource detection.',
         color: '#D4A843',
         mass: 30000,
@@ -181,7 +181,7 @@ export const components: ComponentDefinition[] = [
             {key: 'reflectivity', source: 'precious'},
         ],
         recipe: [{category: 'precious' as ResourceCategory, quantity: 10}],
-        usedIn: [{type: 'module', name: 'Extractor'}],
+        usedIn: [{type: 'module', name: 'Gatherer'}],
     },
     {
         id: ITEM_CARGO_ARM,
@@ -395,32 +395,32 @@ export const moduleRecipes: ModuleRecipe[] = [
         ],
     },
     {
-        id: 'extractor-t1',
-        name: 'Extractor',
-        description: 'Basic extraction system. Drills and probes for raw resources.',
+        id: 'gatherer-t1',
+        name: 'Gatherer',
+        description: 'Basic gathering system. Probes and conduits for raw resources.',
         color: '#7B8D9E',
-        itemId: ITEM_EXTRACTOR_T1,
-        moduleType: MODULE_EXTRACTOR,
+        itemId: ITEM_GATHERER_T1,
+        moduleType: MODULE_GATHERER,
         recipe: [
-            {itemId: ITEM_DRILL_SHAFT, quantity: 4},
-            {itemId: ITEM_EXTRACTION_PROBE, quantity: 3},
+            {itemId: ITEM_MATTER_CONDUIT, quantity: 4},
+            {itemId: ITEM_SURVEY_PROBE, quantity: 3},
         ],
         stats: [
-            {key: 'strength', sourceComponentId: ITEM_DRILL_SHAFT, sourceStatKey: 'strength'},
-            {key: 'tolerance', sourceComponentId: ITEM_DRILL_SHAFT, sourceStatKey: 'tolerance'},
+            {key: 'strength', sourceComponentId: ITEM_MATTER_CONDUIT, sourceStatKey: 'strength'},
+            {key: 'tolerance', sourceComponentId: ITEM_MATTER_CONDUIT, sourceStatKey: 'tolerance'},
             {
                 key: 'reflectivity',
-                sourceComponentId: ITEM_EXTRACTION_PROBE,
+                sourceComponentId: ITEM_SURVEY_PROBE,
                 sourceStatKey: 'reflectivity',
             },
             {
                 key: 'conductivity',
-                sourceComponentId: ITEM_EXTRACTION_PROBE,
+                sourceComponentId: ITEM_SURVEY_PROBE,
                 sourceStatKey: 'conductivity',
             },
             {
-                key: 'reflectivity_drill',
-                sourceComponentId: ITEM_EXTRACTION_PROBE,
+                key: 'reflectivity_speed',
+                sourceComponentId: ITEM_SURVEY_PROBE,
                 sourceStatKey: 'reflectivity',
             },
         ],

package/src/derivation/stratum.ts

@@ -94,25 +94,31 @@ export function deriveStratum(
 
 export function deriveResourceStats(seed: bigint): ResourceStats {
     const seedBytes = new Uint8Array(8)
-    for (let i = 7; i >= 0; i--) {
+    for (let i = 0; i < 8; i++) {
         seedBytes[i] = Number(seed & 0xffn)
         seed >>= 8n
     }
     const hashResult = Checksum256.hash(Bytes.from(seedBytes))
     const hashBytes = hashResult.array
 
-    const extractU16 = (offset: number): number => (hashBytes[offset] << 8) | hashBytes[offset + 1]
+    const extractU32 = (offset: number): number =>
+        (hashBytes[offset] * 0x1000000 +
+            (hashBytes[offset + 1] << 16) +
+            (hashBytes[offset + 2] << 8) +
+            hashBytes[offset + 3]) >>> 0
 
     const weibull = (raw: number): number => {
-        const u = raw / 65536
+        const u = raw / 4294967296
         let x = 0.27 * Math.sqrt(-Math.log(1 - u))
         if (x > 1) x = 1
-        return Math.floor(x * 999) + 1
+        let val = Math.floor(x * 999) + 1
+        if (val > 999) val = 999
+        return val
     }
 
     return {
-        stat1: weibull(extractU16(0)),
-        stat2: weibull(extractU16(2)),
-        stat3: weibull(extractU16(4)),
+        stat1: weibull(extractU32(0)),
+        stat2: weibull(extractU32(4)),
+        stat3: weibull(extractU32(8)),
     }
 }

package/src/entities/location.ts

@@ -1,6 +1,6 @@
 import {Checksum256, Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
 import {Coordinates, CoordinatesType, Distance, LocationType} from '../types'
-import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
+import {getLocationType, hasSystem, isGatherableLocation} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 
 export class Location {
@@ -30,8 +30,8 @@ export class Location {
         return getLocationType(gameSeed, this.coordinates)
     }
 
-    isExtractableAt(gameSeed: Checksum256Type): boolean {
-        return isExtractableLocation(this.getLocationTypeAt(gameSeed))
+    isGatherableAt(gameSeed: Checksum256Type): boolean {
+        return isGatherableLocation(this.getLocationTypeAt(gameSeed))
     }
 
     findNearby(gameSeed: Checksum256Type, maxDistance: UInt16Type = 20): Distance[] {

package/src/entities/ship-deploy.ts

@@ -3,7 +3,7 @@ import {
     getModuleCapabilityType,
     MODULE_CRAFTER,
     MODULE_ENGINE,
-    MODULE_EXTRACTOR,
+    MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
     MODULE_LOADER,
@@ -52,11 +52,11 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
     }
 }
 
-export function computeExtractorCapabilities(stats: Record<string, number>): {
-    rate: number
+export function computeGathererCapabilities(stats: Record<string, number>): {
+    yield: number
     drain: number
     depth: number
-    drill: number
+    speed: number
 } {
     const str = stats.strength ?? 500
     const con = stats.conductivity ?? 500
@@ -64,10 +64,10 @@ export function computeExtractorCapabilities(stats: Record<string, number>): {
     const tol = stats.tolerance ?? 500
 
     return {
-        rate: 200 + str,
+        yield: 200 + str,
         drain: Math.max(10, 50 - Math.floor(con / 20)),
         depth: 200 + Math.floor((tol * 3) / 2),
-        drill: 100 + Math.floor((ref * 4) / 5),
+        speed: 100 + Math.floor((ref * 4) / 5),
     }
 }
 
@@ -153,7 +153,7 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
 export interface ShipCapabilities {
     engines?: {thrust: number; drain: number}
     generator?: {capacity: number; recharge: number}
-    extractor?: {rate: number; drain: number; depth: number; drill: number}
+    gatherer?: {yield: number; drain: number; depth: number; speed: number}
     hauler?: {capacity: number; efficiency: number; drain: number}
     loaders?: {mass: number; thrust: number; quantity: number}
     crafter?: {speed: number; drain: number}
@@ -190,22 +190,22 @@ export function computeShipCapabilities(
         ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
     }
 
-    const extractorModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_EXTRACTOR
+    const gathererModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER
     )
-    if (extractorModules.length > 0) {
-        let totalRate = 0
+    if (gathererModules.length > 0) {
+        let totalYield = 0
         let totalDrain = 0
         let totalDepth = 0
-        let totalDrill = 0
-        for (const m of extractorModules) {
-            const caps = computeExtractorCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
-            totalRate += caps.rate
+        let totalSpeed = 0
+        for (const m of gathererModules) {
+            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalYield += caps.yield
             totalDrain += caps.drain
             totalDepth += caps.depth
-            totalDrill += caps.drill
+            totalSpeed += caps.speed
         }
-        ship.extractor = {rate: totalRate, drain: totalDrain, depth: totalDepth, drill: totalDrill}
+        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: totalDepth, speed: totalSpeed}
     }
 
     const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)

package/src/entities/ship.ts

@@ -104,8 +104,8 @@ export class Ship extends ServerContract.Types.entity_info {
         return schedule.isUnloading(this, now)
     }
 
-    isExtracting(now: Date): boolean {
-        return schedule.isExtracting(this, now)
+    isGathering(now: Date): boolean {
+        return schedule.isGathering(this, now)
     }
 
     get hasEngines(): boolean {
@@ -116,8 +116,8 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.generator !== undefined
     }
 
-    get hasExtractor(): boolean {
-        return this.extractor !== undefined
+    get hasGatherer(): boolean {
+        return this.gatherer !== undefined
     }
 
     get hasWarp(): boolean {

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,
@@ -192,12 +193,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,
@@ -238,7 +239,7 @@ export {
     computeShipHullCapabilities,
     computeEngineCapabilities,
     computeGeneratorCapabilities,
-    computeExtractorCapabilities,
+    computeGathererCapabilities,
     computeHaulerCapabilities,
     computeLoaderCapabilities,
     computeManufacturingCapabilities,
@@ -285,10 +286,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/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

@@ -185,7 +185,7 @@ function applyEnergyCost(projected: ProjectedEntity, task: ServerContract.Types.
         : UInt16.from(0)
 }
 
-function applyExtractTask(
+function applyGatherTask(
     projected: ProjectedEntity,
     task: ServerContract.Types.task,
     options: {complete: boolean}
@@ -246,8 +246,8 @@ export function projectEntity(entity: Projectable): ProjectedEntity {
             case TaskType.UNLOAD:
                 applyUnloadTask(projected, task)
                 break
-            case TaskType.EXTRACT:
-                applyExtractTask(projected, task, {complete: true})
+            case TaskType.GATHER:
+                applyGatherTask(projected, task, {complete: true})
                 break
             case TaskType.CRAFT:
                 applyCraftTask(projected, task)
@@ -299,9 +299,9 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                     applyUnloadTask(projected, task)
                 }
                 break
-            case TaskType.EXTRACT:
+            case TaskType.GATHER:
                 if (taskComplete) {
-                    applyExtractTask(projected, task, {complete: true})
+                    applyGatherTask(projected, task, {complete: true})
                 }
                 break
             case TaskType.CRAFT:

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,7 +49,7 @@ export enum TaskType {
     RECHARGE = 2,
     LOAD = 3,
     UNLOAD = 4,
-    EXTRACT = 5,
+    GATHER = 5,
     WARP = 6,
     CRAFT = 7,
     DEPLOY = 8,

package/src/utils/system.ts

@@ -30,10 +30,19 @@ 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]
 }

package/src/capabilities/extraction.ts

@@ -1,36 +0,0 @@
-import {UInt16, UInt32} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import {PRECISION} from '../types'
-
-const EXTRACTION_TIME_SCALE = 100
-const DEPTH_PENALTY_DIVISOR = 5000
-const DRILL_TIME_SCALE = 300
-
-export function calc_extraction_duration(
-    extractor: ServerContract.Types.extractor_stats,
-    itemMass: number,
-    quantity: number,
-    stratum: number,
-    richness: number
-): UInt32 {
-    const rate = extractor.rate.toNumber()
-    const drill = extractor.drill.toNumber()
-
-    if (rate === 0 || drill === 0 || richness === 0) return UInt32.from(0)
-
-    const massFactor = Math.sqrt(itemMass)
-    const depthPenalty = 1 + stratum / DEPTH_PENALTY_DIVISOR
-    const richnessMul = richness / 1000
-    const extractionTime =
-        (quantity * massFactor * EXTRACTION_TIME_SCALE * depthPenalty) / (rate * richnessMul)
-    const drillTime = DRILL_TIME_SCALE * Math.log(1 + stratum / drill)
-    return UInt32.from(Math.floor(extractionTime + drillTime))
-}
-
-export function calc_extraction_energy(
-    extractor: ServerContract.Types.extractor_stats,
-    duration: number
-): UInt16 {
-    const energy = Math.floor((duration * extractor.drain.toNumber()) / PRECISION)
-    return UInt16.from(energy)
-}