@shipload/sdk 2.0.0-rc2 → 2.0.0-rc20

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "2.0.0-rc2",
+    "version": "2.0.0-rc20",
     "homepage": "https://github.com/shipload/sdk",
     "license": "MIT",
     "main": "lib/shipload.js",
@@ -16,7 +16,7 @@
         "prepare": "make"
     },
     "dependencies": {
-        "@wharfkit/antelope": "^1.1.1",
+        "@wharfkit/antelope": "1.2.0",
         "@wharfkit/contract": "^1.2.1",
         "@wharfkit/session": "^1.3.1",
         "tslib": "^2.1.0"
@@ -56,8 +56,10 @@
         "tsconfig-paths": "^4.1.1",
         "typedoc": "^0.23.14",
         "typedoc-plugin-mermaid": "^1.10.0",
-        "typescript": "^4.1.2",
-        "yarn-deduplicate": "^6.0.2"
+        "typescript": "^4.1.2"
+    },
+    "overrides": {
+        "@wharfkit/antelope": "1.2.0"
     },
     "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/src/capabilities/crafting.ts

@@ -0,0 +1,22 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import {CRAFT_ENERGY_DIVISOR} from '../types'
+import type {EntityCapabilities} from '../types/capabilities'
+import {ServerContract} from '../contracts'
+
+export interface CrafterCapability {
+    crafter: ServerContract.Types.crafter_stats
+}
+
+export function capsHasCrafter(caps: EntityCapabilities): boolean {
+    return caps.crafter !== undefined
+}
+
+export function calc_craft_duration(speed: number, totalInputMass: number): UInt32 {
+    const duration = Math.floor(totalInputMass / speed)
+    return UInt32.from(Math.max(duration, 1))
+}
+
+export function calc_craft_energy(drain: number, totalInputMass: number): UInt16 {
+    const raw = Math.floor((totalInputMass * drain) / CRAFT_ENERGY_DIVISOR)
+    return UInt16.from(Math.min(raw, 65535))
+}

package/src/capabilities/gathering.ts

@@ -0,0 +1,36 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {PRECISION} from '../types'
+
+const GATHER_TIME_SCALE = 100
+const DEPTH_PENALTY_DIVISOR = 5000
+const SPEED_TIME_SCALE = 300
+
+export function calc_gather_duration(
+    gatherer: ServerContract.Types.gatherer_stats,
+    itemMass: number,
+    quantity: number,
+    stratum: number,
+    richness: number
+): UInt32 {
+    const yieldValue = gatherer.yield.toNumber()
+    const speed = gatherer.speed.toNumber()
+
+    if (yieldValue === 0 || speed === 0 || richness === 0) return UInt32.from(0)
+
+    const massFactor = Math.sqrt(itemMass)
+    const depthPenalty = 1 + stratum / DEPTH_PENALTY_DIVISOR
+    const richnessMul = richness / 1000
+    const gatherTime =
+        (quantity * massFactor * GATHER_TIME_SCALE * depthPenalty) / (yieldValue * richnessMul)
+    const speedTime = SPEED_TIME_SCALE * Math.log(1 + stratum / speed)
+    return UInt32.from(Math.floor(gatherTime + speedTime))
+}
+
+export function calc_gather_energy(
+    gatherer: ServerContract.Types.gatherer_stats,
+    duration: number
+): UInt16 {
+    const energy = Math.floor((duration * gatherer.drain.toNumber()) / PRECISION)
+    return UInt16.from(energy)
+}

package/src/capabilities/guards.ts

@@ -1,12 +1,11 @@
 import {
     EnergyCapability,
-    ExtractorCapability,
+    GathererCapability,
     LoaderCapability,
     MassCapability,
     MovementCapability,
     ScheduleCapability,
     StorageCapability,
-    TradeCapability,
 } from '../types/capabilities'
 import {Entity} from '../types/entity'
 
@@ -26,10 +25,6 @@ export function hasLoaders(e: Entity): e is Entity & LoaderCapability {
     return 'loaders' in e && e.loaders !== undefined
 }
 
-export function hasTrade(e: Entity): e is Entity & TradeCapability {
-    return 'trade' in e && e.trade !== undefined
-}
-
 export function hasMass(e: Entity): e is Entity & MassCapability {
     return 'hullmass' in e
 }
@@ -38,6 +33,6 @@ export function hasSchedule(e: Entity): e is Entity & ScheduleCapability {
     return 'schedule' in e
 }
 
-export function hasExtractor(e: Entity): e is Entity & ExtractorCapability {
-    return 'extractor' in e && e.extractor !== undefined
+export function hasGatherer(e: Entity): e is Entity & GathererCapability {
+    return 'gatherer' in e && e.gatherer !== undefined
 }

package/src/capabilities/hauling.ts

@@ -0,0 +1,22 @@
+const BASE_HAUL_PENALTY_MILLI = 300
+const HAULER_EFFICIENCY_DENOM = 10000
+const PRECISION = 10000
+
+export function computeHaulPenalty(
+    totalThrust: number,
+    haulCount: number,
+    avgEfficiency: number
+): number {
+    if (haulCount === 0) return totalThrust
+    const penaltyMilli =
+        1000 +
+        Math.floor(
+            (haulCount * BASE_HAUL_PENALTY_MILLI * (HAULER_EFFICIENCY_DENOM - avgEfficiency)) /
+                HAULER_EFFICIENCY_DENOM
+        )
+    return Math.floor((totalThrust * 1000) / penaltyMilli)
+}
+
+export function computeHaulerDrain(distance: number, drain: number, haulCount: number): number {
+    return Math.floor(distance / PRECISION) * drain * haulCount
+}

package/src/capabilities/index.ts

@@ -2,4 +2,7 @@ export * from './guards'
 export * from './movement'
 export * from './storage'
 export * from './loading'
-export * from './extraction'
+export * from './gathering'
+export * from './crafting'
+export * from './modules'
+export * from './hauling'

package/src/capabilities/modules.ts

@@ -0,0 +1,57 @@
+export const ITEM_ENGINE_T1 = 10100
+export const ITEM_GENERATOR_T1 = 10101
+export const ITEM_GATHERER_T1 = 10102
+export const ITEM_LOADER_T1 = 10103
+export const ITEM_CRAFTER_T1 = 10104
+export const ITEM_STORAGE_T1 = 10105
+export const ITEM_HAULER_T1 = 10106
+
+export const MODULE_ANY = 0
+export const MODULE_ENGINE = 1
+export const MODULE_GENERATOR = 2
+export const MODULE_GATHERER = 3
+export const MODULE_LOADER = 4
+export const MODULE_WARP = 5
+export const MODULE_CRAFTER = 6
+export const MODULE_LAUNCHER = 7
+export const MODULE_STORAGE = 8
+export const MODULE_HAULER = 9
+
+export interface PackedModule {
+    itemId: number
+    stats: bigint
+}
+
+export interface ModuleEntry {
+    type: number
+    installed?: PackedModule
+}
+
+export function moduleAccepts(slotType: number, moduleType: number): boolean {
+    return slotType === MODULE_ANY || slotType === moduleType
+}
+
+export function getModuleCapabilityType(itemId: number): number {
+    switch (itemId) {
+        case ITEM_ENGINE_T1:
+            return MODULE_ENGINE
+        case ITEM_GENERATOR_T1:
+            return MODULE_GENERATOR
+        case ITEM_GATHERER_T1:
+            return MODULE_GATHERER
+        case ITEM_LOADER_T1:
+            return MODULE_LOADER
+        case ITEM_CRAFTER_T1:
+            return MODULE_CRAFTER
+        case ITEM_STORAGE_T1:
+            return MODULE_STORAGE
+        case ITEM_HAULER_T1:
+            return MODULE_HAULER
+        default:
+            return 0xff
+    }
+}
+
+export function isModuleItem(itemId: number): boolean {
+    return getModuleCapabilityType(itemId) !== 0xff
+}

package/src/capabilities/storage.ts

@@ -1,7 +1,8 @@
-import {UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {StorageCapability} from '../types/capabilities'
-import {getGood} from '../market/goods'
+import {getItem} from '../market/items'
+import {INSUFFICIENT_ITEM_QUANTITY} from '../errors'
 
 export interface HasCargo {
     cargo: ServerContract.Types.cargo_item[]
@@ -15,21 +16,40 @@ export interface HasCargomass {
     cargomass: UInt32
 }
 
+interface MassInput {
+    item_id: UInt16
+    quantity: UInt32
+    modules: ServerContract.Types.module_entry[]
+}
+
+export function calcCargoItemMass(item: MassInput): UInt64 {
+    const itemDef = getItem(item.item_id)
+    let mass = UInt64.from(itemDef.mass).multiplying(item.quantity)
+
+    for (const mod of item.modules) {
+        if (mod.installed) {
+            const modDef = getItem(mod.installed.item_id)
+            mass = mass.adding(modDef.mass)
+        }
+    }
+
+    return mass
+}
+
 export function calcCargoMass(entity: HasCargo): UInt64 {
     let mass = UInt64.from(0)
     for (const item of entity.cargo) {
-        const good = getGood(item.good_id)
-        mass = mass.adding(good.mass.multiplying(item.quantity))
+        mass = mass.adding(calcCargoItemMass(item))
     }
     return mass
 }
 
-export function calcCargoValue(entity: HasCargo): UInt64 {
-    let value = UInt64.from(0)
-    for (const item of entity.cargo) {
-        value = value.adding(item.unit_cost.multiplying(item.quantity))
+export function calcStacksMass(stacks: CargoStack[]): UInt64 {
+    let mass = UInt64.from(0)
+    for (const s of stacks) {
+        mass = mass.adding(calcCargoItemMass(s))
     }
-    return value
+    return mass
 }
 
 export function availableCapacity(entity: StorageCapability): UInt64 {
@@ -65,3 +85,75 @@ export function isFull(entity: HasCapacity & HasCargomass): boolean {
 export function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean {
     return UInt64.from(cargoMass).gte(capacity)
 }
+
+export interface CargoStack {
+    item_id: UInt16
+    quantity: UInt32
+    stats: UInt64
+    modules: ServerContract.Types.module_entry[]
+}
+
+export function cargoItemToStack(item: ServerContract.Types.cargo_item): CargoStack {
+    return {
+        item_id: UInt16.from(item.item_id),
+        quantity: UInt32.from(item.quantity),
+        stats: item.stats,
+        modules: item.modules ?? [],
+    }
+}
+
+export function stackToCargoItem(stack: CargoStack): ServerContract.Types.cargo_item {
+    return ServerContract.Types.cargo_item.from({
+        item_id: stack.item_id,
+        quantity: stack.quantity,
+        stats: stack.stats,
+        modules: stack.modules,
+    })
+}
+
+function statsEquals(a: UInt64, b: UInt64): boolean {
+    return a.equals(b)
+}
+
+function stackIdentityEqual(a: CargoStack, b: CargoStack): boolean {
+    return a.item_id.equals(b.item_id) && statsEquals(a.stats, b.stats)
+}
+
+export function stackKey(s: CargoStack): string {
+    return `${s.item_id.toNumber()}:${s.stats.toString()}`
+}
+
+export function stacksEqual(a: CargoStack, b: CargoStack): boolean {
+    return stackIdentityEqual(a, b) && a.quantity.equals(b.quantity)
+}
+
+export function mergeStacks(stacks: CargoStack[], add: CargoStack): CargoStack[] {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, add))
+    if (idx === -1) {
+        return [...stacks, {...add}]
+    }
+    const result = stacks.slice()
+    result[idx] = {
+        ...result[idx],
+        quantity: UInt32.from(result[idx].quantity.adding(add.quantity)),
+    }
+    return result
+}
+
+export function removeFromStacks(stacks: CargoStack[], remove: CargoStack): CargoStack[] {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, remove))
+    if (idx === -1) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY)
+    }
+    const target = stacks[idx]
+    if (target.quantity.lt(remove.quantity)) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY)
+    }
+    const remaining = UInt32.from(target.quantity.subtracting(remove.quantity))
+    if (remaining.equals(UInt32.from(0))) {
+        return [...stacks.slice(0, idx), ...stacks.slice(idx + 1)]
+    }
+    const result = stacks.slice()
+    result[idx] = {...target, quantity: remaining}
+    return result
+}