@shipload/sdk 2.0.0-rc1 → 2.0.0-rc3

package/package.json

@@ -1,13 +1,12 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "2.0.0-rc1",
+    "version": "2.0.0-rc3",
     "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/*",

package/src/capabilities/extraction.ts

@@ -0,0 +1,30 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {PRECISION} from '../types'
+
+export function calc_extraction_duration(
+    extractor: ServerContract.Types.extractor_stats,
+    cargoMass: 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)
+
+    return UInt32.from(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,43 @@
+import {
+    EnergyCapability,
+    ExtractorCapability,
+    LoaderCapability,
+    MassCapability,
+    MovementCapability,
+    ScheduleCapability,
+    StorageCapability,
+    TradeCapability,
+} 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 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
+}
+
+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/index.ts

@@ -0,0 +1,5 @@
+export * from './guards'
+export * from './movement'
+export * from './storage'
+export * from './loading'
+export * from './extraction'

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/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,67 @@
+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 calcCargoMass(entity: HasCargo): UInt64 {
+    let mass = UInt64.from(0)
+    for (const item of entity.cargo) {
+        const good = getItem(item.item_id)
+        mass = mass.adding(good.mass.multiplying(item.quantity))
+    }
+    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)
+        ? 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)
+}