@shipload/sdk 2.0.0-rc1 → 2.0.0-rc10

package/package.json

@@ -1,13 +1,12 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "2.0.0-rc1",
+    "version": "2.0.0-rc10",
     "homepage": "https://github.com/shipload/sdk",
     "license": "MIT",
     "main": "lib/shipload.js",
     "module": "lib/shipload.m.js",
     "types": "lib/shipload.d.ts",
-    "unpkg": "lib/shipload.bundle.js",
     "sideEffects": false,
     "files": [
         "lib/*",
@@ -17,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"
@@ -57,8 +56,9 @@
         "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"
     },
-    "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+    "overrides": {
+        "@wharfkit/antelope": "1.2.0"
+    }
 }

package/src/capabilities/crafting.ts

@@ -0,0 +1,26 @@
+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,
+    quantity: number
+): UInt32 {
+    const duration = Math.floor((totalInputMass * quantity) / 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/extraction.ts

@@ -0,0 +1,36 @@
+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)
+}

package/src/capabilities/guards.ts

@@ -0,0 +1,38 @@
+import {
+    EnergyCapability,
+    ExtractorCapability,
+    LoaderCapability,
+    MassCapability,
+    MovementCapability,
+    ScheduleCapability,
+    StorageCapability,
+} from '../types/capabilities'
+import {Entity} from '../types/entity'
+
+export function canMove(e: Entity): e is Entity & MovementCapability & EnergyCapability {
+    return 'engines' in e && 'generator' in e && 'energy' in e
+}
+
+export function hasEnergy(e: Entity): e is Entity & EnergyCapability {
+    return 'energy' in e
+}
+
+export function hasStorage(e: Entity): e is Entity & StorageCapability {
+    return 'capacity' in e && 'cargo' in e
+}
+
+export function hasLoaders(e: Entity): e is Entity & LoaderCapability {
+    return 'loaders' in e && e.loaders !== undefined
+}
+
+export function hasMass(e: Entity): e is Entity & MassCapability {
+    return 'hullmass' in e
+}
+
+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
+}

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

@@ -0,0 +1,8 @@
+export * from './guards'
+export * from './movement'
+export * from './storage'
+export * from './loading'
+export * from './extraction'
+export * from './crafting'
+export * from './modules'
+export * from './hauling'

package/src/capabilities/loading.ts

@@ -0,0 +1,8 @@
+import {UInt32, UInt64} from '@wharfkit/antelope'
+import {LoaderCapability} from '../types/capabilities'
+
+export function calcLoadDuration(entity: LoaderCapability, cargoMass: UInt64): UInt32 {
+    const totalThrust = entity.loaders.thrust.toNumber() * entity.loaders.quantity.toNumber()
+    if (totalThrust === 0) return UInt32.from(0)
+    return UInt32.from(Math.ceil(Number(cargoMass) / totalThrust))
+}

package/src/capabilities/modules.ts

@@ -0,0 +1,57 @@
+export const ITEM_ENGINE_T1 = 10100
+export const ITEM_GENERATOR_T1 = 10101
+export const ITEM_EXTRACTOR_T1 = 10102
+export const ITEM_LOADER_T1 = 10103
+export const ITEM_MANUFACTURING_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_EXTRACTOR = 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 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
+        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/movement.ts

@@ -0,0 +1,29 @@
+import {UInt32, UInt64} from '@wharfkit/antelope'
+import {EnergyCapability, MovementCapability} from '../types/capabilities'
+import {PRECISION} from '../types'
+
+export function maxTravelDistance(entity: MovementCapability): UInt32 {
+    return UInt32.from(entity.generator.capacity)
+        .dividing(entity.engines.drain)
+        .multiplying(PRECISION)
+}
+
+export function calcEnergyUsage(entity: MovementCapability, distance: UInt64): UInt64 {
+    return distance.dividing(PRECISION).multiplying(entity.engines.drain)
+}
+
+export function hasEnergyForDistance(
+    entity: MovementCapability & EnergyCapability,
+    distance: UInt64
+): boolean {
+    const usage = calcEnergyUsage(entity, distance)
+    return UInt64.from(entity.energy).gte(usage)
+}
+
+export function energyPercent(entity: MovementCapability & EnergyCapability): number {
+    return (Number(entity.energy) / Number(entity.generator.capacity)) * 100
+}
+
+export function needsRecharge(entity: MovementCapability & EnergyCapability): boolean {
+    return UInt64.from(entity.energy).lt(entity.generator.capacity)
+}

package/src/capabilities/storage.ts

@@ -0,0 +1,72 @@
+import {UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {StorageCapability} from '../types/capabilities'
+import {getItem} from '../market/items'
+
+export interface HasCargo {
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export interface HasCapacity {
+    capacity: UInt32
+}
+
+export interface HasCargomass {
+    cargomass: UInt32
+}
+
+export function calcCargoItemMass(item: ServerContract.Types.cargo_item): 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) {
+        mass = mass.adding(calcCargoItemMass(item))
+    }
+    return mass
+}
+
+export function availableCapacity(entity: StorageCapability): UInt64 {
+    const cargoMass = calcCargoMass(entity)
+    return entity.capacity.gt(cargoMass)
+        ? UInt64.from(entity.capacity).subtracting(cargoMass)
+        : UInt64.from(0)
+}
+
+export function availableCapacityFromMass(capacity: UInt64Type, cargoMass: UInt64Type): UInt64 {
+    const cap = UInt64.from(capacity)
+    const mass = UInt64.from(cargoMass)
+    return cap.gt(mass) ? cap.subtracting(mass) : UInt64.from(0)
+}
+
+export function hasSpace(entity: StorageCapability, goodMass: UInt64, quantity: number): boolean {
+    const additional = goodMass.multiplying(quantity)
+    return availableCapacity(entity).gte(additional)
+}
+
+export function hasSpaceForMass(
+    capacity: UInt64Type,
+    currentMass: UInt64Type,
+    additionalMass: UInt64Type
+): boolean {
+    return UInt64.from(currentMass).adding(additionalMass).lte(capacity)
+}
+
+export function isFull(entity: HasCapacity & HasCargomass): boolean {
+    return UInt64.from(entity.cargomass).gte(entity.capacity)
+}
+
+export function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean {
+    return UInt64.from(cargoMass).gte(capacity)
+}