@shipload/sdk 2.0.0-rc5 → 2.0.0-rc7

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "2.0.0-rc5",
+    "version": "2.0.0-rc7",
     "homepage": "https://github.com/shipload/sdk",
     "license": "MIT",
     "main": "lib/shipload.js",

package/src/capabilities/crafting.ts

@@ -0,0 +1,28 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import {PRECISION} 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,
+    quantity: number
+): UInt32 {
+    const duration = Math.floor((totalInputMass * quantity) / speed)
+    return UInt32.from(Math.max(duration, 1))
+}
+
+export function calc_craft_energy(
+    drain: number,
+    duration: number
+): UInt16 {
+    return UInt16.from(Math.floor((duration * drain) / PRECISION))
+}

package/src/capabilities/extraction.ts

@@ -2,23 +2,29 @@ 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,
-    cargoMass: number,
+    itemMass: number,
+    quantity: number,
     stratum: number,
     richness: number
 ): UInt32 {
     const rate = extractor.rate.toNumber()
-    const efficiency = extractor.efficiency.toNumber()
     const drill = extractor.drill.toNumber()
 
-    const rateProduct = Math.floor((rate * richness * efficiency) / PRECISION)
-    if (rateProduct === 0) return UInt32.from(0)
-
-    const extractionTime = Math.floor((cargoMass * PRECISION) / rateProduct)
-    const drillTime = Math.floor(stratum / drill)
+    if (rate === 0 || drill === 0 || richness === 0) return UInt32.from(0)
 
-    return UInt32.from(extractionTime + drillTime)
+    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(

package/src/capabilities/guards.ts

@@ -6,7 +6,6 @@ import {
     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
 }

package/src/capabilities/index.ts

@@ -3,3 +3,5 @@ export * from './movement'
 export * from './storage'
 export * from './loading'
 export * from './extraction'
+export * from './crafting'
+export * from './modules'

package/src/capabilities/modules.ts

@@ -0,0 +1,49 @@
+export const ITEM_ENGINE_T1 = 10006
+export const ITEM_GENERATOR_T1 = 10007
+export const ITEM_EXTRACTOR_T1 = 10014
+export const ITEM_LOADER_T1 = 10015
+export const ITEM_MANUFACTURING_T1 = 10016
+
+export const MODULE_ANY = 0
+export const MODULE_ENGINE = 1
+export const MODULE_GENERATOR = 2
+export const MODULE_EXTRACTOR = 3
+export const MODULE_LOADER = 4
+export const MODULE_WARP = 5
+export const MODULE_CRAFTER = 6
+export const MODULE_LAUNCHER = 7
+
+export interface CargoSeed {
+    itemId: number
+    seed: bigint
+}
+
+export interface ModuleEntry {
+    type: number
+    installed?: CargoSeed
+}
+
+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_EXTRACTOR_T1:
+            return MODULE_EXTRACTOR
+        case ITEM_LOADER_T1:
+            return MODULE_LOADER
+        case ITEM_MANUFACTURING_T1:
+            return MODULE_CRAFTER
+        default:
+            return 0xff
+    }
+}
+
+export function isModuleItem(itemId: number): boolean {
+    return getModuleCapabilityType(itemId) !== 0xff
+}

package/src/capabilities/storage.ts

@@ -24,14 +24,6 @@ export function calcCargoMass(entity: HasCargo): UInt64 {
     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))
-    }
-    return value
-}
-
 export function availableCapacity(entity: StorageCapability): UInt64 {
     const cargoMass = calcCargoMass(entity)
     return entity.capacity.gt(cargoMass)