@shipload/sdk 0.7.1 → 2.0.0-rc2

package/package.json

@@ -1,13 +1,12 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "0.7.1",
+    "version": "2.0.0-rc2",
     "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,8 +16,8 @@
         "prepare": "make"
     },
     "dependencies": {
-        "@wharfkit/antelope": "^1.0.2",
-        "@wharfkit/contract": "^1.1.5",
+        "@wharfkit/antelope": "^1.1.1",
+        "@wharfkit/contract": "^1.2.1",
         "@wharfkit/session": "^1.3.1",
         "tslib": "^2.1.0"
     },
@@ -59,5 +58,6 @@
         "typedoc-plugin-mermaid": "^1.10.0",
         "typescript": "^4.1.2",
         "yarn-deduplicate": "^6.0.2"
-    }
+    },
+    "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/src/capabilities/extraction.ts

@@ -0,0 +1,37 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {PRECISION} from '../types'
+
+function calc_load_time_internal(
+    loaders: ServerContract.Types.loader_stats,
+    shipZ: number,
+    cargoMass: number
+): number {
+    if (cargoMass === 0 || loaders.quantity.toNumber() === 0 || loaders.thrust.toNumber() === 0) {
+        return 0
+    }
+
+    const totalMass = cargoMass + loaders.mass.toNumber()
+    const acceleration = (loaders.thrust.toNumber() / totalMass) * PRECISION
+    const flightTime = Math.floor(2 * Math.sqrt(shipZ / acceleration))
+    return Math.floor(flightTime / loaders.quantity.toNumber())
+}
+
+export function calc_extraction_duration(
+    extractor: ServerContract.Types.extractor_stats,
+    loaders: ServerContract.Types.loader_stats,
+    shipZ: number,
+    batchMass: number
+): UInt32 {
+    const extractionTime = Math.floor(batchMass / extractor.rate.toNumber())
+    const loadingTime = calc_load_time_internal(loaders, shipZ, batchMass)
+    return UInt32.from(Math.max(extractionTime, loadingTime))
+}
+
+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 {getGood} from '../market/goods'
+
+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 = getGood(item.good_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)
+}