@shipload/sdk 1.0.0-next.6 → 1.0.0-next.8

package/src/managers/actions.ts

@@ -90,18 +90,15 @@ export class ActionsManager extends BaseManager {
         sourceId: UInt64Type,
         destType: EntityTypeName,
         destId: UInt64Type,
-        itemId: UInt64Type,
-        stats: UInt64Type,
-        quantity: UInt64Type
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
+        const cargoItems = items.map((i) => ServerContract.Types.cargo_item.from(i))
         return this.server.action('transfer', {
             source_type: sourceType,
             source_id: UInt64.from(sourceId),
             dest_type: destType,
             dest_id: UInt64.from(destId),
-            item_id: UInt16.from(itemId),
-            stats: UInt64.from(stats),
-            quantity: UInt32.from(quantity),
+            items: cargoItems,
         })
     }
 
@@ -187,14 +184,12 @@ export class ActionsManager extends BaseManager {
     deploy(
         entityType: EntityTypeName,
         entityId: UInt64Type,
-        packedItemId: number,
-        stats: bigint
+        ref: ServerContract.ActionParams.Type.cargo_ref
     ): Action {
         return this.server.action('deploy', {
             entity_type: entityType,
             id: UInt64.from(entityId),
-            packed_item_id: UInt16.from(packedItemId),
-            stats: UInt64.from(stats),
+            ref: ServerContract.Types.cargo_ref.from(ref),
         })
     }
 
@@ -202,15 +197,15 @@ export class ActionsManager extends BaseManager {
         entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        moduleCargoId: UInt64Type,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        moduleRef: ServerContract.ActionParams.Type.cargo_ref,
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('addmodule', {
             entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            module_cargo_id: UInt64.from(moduleCargoId),
-            target_cargo_id: UInt64.from(targetCargoId),
+            module_ref: ServerContract.Types.cargo_ref.from(moduleRef),
+            target_ref: targetRef ? ServerContract.Types.cargo_ref.from(targetRef) : null,
         })
     }
 
@@ -218,13 +213,13 @@ export class ActionsManager extends BaseManager {
         entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('rmmodule', {
             entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            target_cargo_id: UInt64.from(targetCargoId),
+            target_ref: targetRef ? ServerContract.Types.cargo_ref.from(targetRef) : null,
         })
     }
 
@@ -232,15 +227,14 @@ export class ActionsManager extends BaseManager {
         owner: NameType,
         entityType: EntityTypeName,
         entityId: UInt64Type,
-        cargoId: UInt64Type,
-        quantity: UInt64Type
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
+        const cargoItems = items.map((i) => ServerContract.Types.cargo_item.from(i))
         return this.server.action('wrap', {
             owner: Name.from(owner),
             entity_type: entityType,
             entity_id: UInt64.from(entityId),
-            cargo_id: UInt64.from(cargoId),
-            quantity: UInt64.from(quantity),
+            items: cargoItems,
         })
     }
 

package/src/scheduling/predict-cargo.ts

@@ -0,0 +1,151 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+export type PredictedCargoTarget = {kind: 'existing'; rowId: bigint} | {kind: 'new'; label: string}
+
+export interface PredictedCargoAddition {
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+    target: PredictedCargoTarget
+}
+
+export interface TaskCargoEffect {
+    additions: PredictedCargoAddition[]
+}
+
+interface StackState {
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+    target: PredictedCargoTarget
+}
+
+function modulesEqual(
+    a: ServerContract.Types.module_entry[],
+    b: ServerContract.Types.module_entry[]
+): boolean {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i]
+        const bi = b[i]
+        if (Number(ai.type) !== Number(bi.type)) return false
+        const aInst = ai.installed
+        const bInst = bi.installed
+        if (!aInst && !bInst) continue
+        if (!aInst || !bInst) return false
+        if (Number(aInst.item_id) !== Number(bInst.item_id)) return false
+        if (BigInt(aInst.stats.toString()) !== BigInt(bInst.stats.toString())) return false
+    }
+    return true
+}
+
+function findStack(
+    state: StackState[],
+    item_id: number,
+    stats: bigint,
+    modules: ServerContract.Types.module_entry[]
+): number {
+    for (let i = 0; i < state.length; i++) {
+        const s = state[i]
+        if (s.item_id !== item_id) continue
+        if (s.stats !== stats) continue
+        if (!modulesEqual(s.modules, modules)) continue
+        return i
+    }
+    return -1
+}
+
+function applyAddition(
+    state: StackState[],
+    item: ServerContract.Types.cargo_item,
+    nextNewLabel: () => string
+): PredictedCargoAddition {
+    const item_id = Number(item.item_id)
+    const stats = BigInt(item.stats.toString())
+    const modules = item.modules ?? []
+    const quantity = Number(item.quantity)
+
+    const idx = findStack(state, item_id, stats, modules)
+    if (idx === -1) {
+        const target: PredictedCargoTarget = {kind: 'new', label: nextNewLabel()}
+        state.push({item_id, stats, modules, quantity, target})
+        return {item_id, stats, modules, quantity, target}
+    }
+    state[idx].quantity += quantity
+    return {item_id, stats, modules, quantity, target: state[idx].target}
+}
+
+function applyRemoval(state: StackState[], item: ServerContract.Types.cargo_item): void {
+    const item_id = Number(item.item_id)
+    const stats = BigInt(item.stats.toString())
+    const modules = item.modules ?? []
+    const quantity = Number(item.quantity)
+
+    const idx = findStack(state, item_id, stats, modules)
+    if (idx === -1) return
+    state[idx].quantity -= quantity
+    if (state[idx].quantity <= 0) state.splice(idx, 1)
+}
+
+export function predictTaskCargoEffects(
+    cargo: readonly ServerContract.Types.cargo_view[],
+    tasks: readonly ServerContract.Types.task[]
+): TaskCargoEffect[] {
+    const state: StackState[] = cargo.map((c) => ({
+        item_id: Number(c.item_id),
+        stats: BigInt(c.stats.toString()),
+        modules: c.modules ?? [],
+        quantity: Number(c.quantity),
+        target: {kind: 'existing', rowId: BigInt(c.id.toString())},
+    }))
+
+    let newCounter = 0
+    const nextNewLabel = () => {
+        newCounter += 1
+        return `new#${newCounter}`
+    }
+
+    const effects: TaskCargoEffect[] = []
+
+    for (const task of tasks) {
+        const type = Number(task.type)
+        const items = task.cargo ?? []
+        const additions: PredictedCargoAddition[] = []
+
+        switch (type) {
+            case TaskType.LOAD:
+            case TaskType.UNWRAP: {
+                for (const item of items) additions.push(applyAddition(state, item, nextNewLabel))
+                break
+            }
+            case TaskType.GATHER: {
+                if (!task.entitytarget) {
+                    for (const item of items)
+                        additions.push(applyAddition(state, item, nextNewLabel))
+                }
+                break
+            }
+            case TaskType.UNLOAD:
+            case TaskType.WRAP: {
+                for (const item of items) applyRemoval(state, item)
+                break
+            }
+            case TaskType.CRAFT: {
+                if (items.length > 0) {
+                    for (let i = 0; i < items.length - 1; i++) applyRemoval(state, items[i])
+                    additions.push(applyAddition(state, items[items.length - 1], nextNewLabel))
+                }
+                break
+            }
+            default:
+                break
+        }
+
+        effects.push({additions})
+    }
+
+    return effects
+}

package/src/travel/travel.ts

@@ -28,6 +28,7 @@ import {
     type Distance,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
+    MIN_TRANSFER_DISTANCE,
     PRECISION,
     type ShipLike,
     TaskType,
@@ -547,7 +548,8 @@ export function calc_transfer_duration(
             : (source.location.z?.toNumber() ?? 0)
     const destZ =
         typeof dest.location.z === 'number' ? dest.location.z : (dest.location.z?.toNumber() ?? 0)
-    const distance = Math.abs(sourceZ - destZ)
+    const rawDistance = Math.abs(sourceZ - destZ)
+    const distance = rawDistance < MIN_TRANSFER_DISTANCE ? MIN_TRANSFER_DISTANCE : rawDistance
 
     const totalMass = cargoMass + totalLoaderMass
     const acceleration = calc_acceleration(totalThrust, totalMass)

package/src/types/entity-traits.ts

@@ -1,9 +1,47 @@
 import {Name} from '@wharfkit/antelope'
+import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/item-ids'
 
 export const ENTITY_SHIP = Name.from('ship')
 export const ENTITY_WAREHOUSE = Name.from('warehouse')
 export const ENTITY_CONTAINER = Name.from('container')
 
+export enum EntityClass {
+    OrbitalVessel = 0,
+    PlanetaryStructure = 1,
+}
+
+export function getEntityClass(entityType: Name | EntityTypeName): EntityClass {
+    const typeName = typeof entityType === 'string' ? entityType : entityType.toString()
+    switch (typeName) {
+        case 'ship':
+        case 'container':
+            return EntityClass.OrbitalVessel
+        case 'warehouse':
+            return EntityClass.PlanetaryStructure
+        default:
+            throw new Error(`Entity type has no class: ${typeName}`)
+    }
+}
+
+export function getPackedEntityType(itemId: number): Name | null {
+    switch (itemId) {
+        case ITEM_SHIP_T1_PACKED:
+            return ENTITY_SHIP
+        case ITEM_CONTAINER_T1_PACKED:
+        case ITEM_CONTAINER_T2_PACKED:
+            return ENTITY_CONTAINER
+        case ITEM_WAREHOUSE_T1_PACKED:
+            return ENTITY_WAREHOUSE
+        default:
+            return null
+    }
+}
+
 export type EntityTypeName = 'ship' | 'warehouse' | 'container'
 
 export interface EntityTraits {

package/src/types.ts

@@ -23,6 +23,8 @@ export const MAX_ORBITAL_ALTITUDE = 3000
 
 export const BASE_ORBITAL_MASS = 100000
 
+export const MIN_TRANSFER_DISTANCE = 100
+
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
     hullmass?: UInt32
@@ -163,3 +165,7 @@ export interface Item {
 export function formatTier(tier: number): string {
     return 'T' + tier
 }
+
+export function tierAdjective(tier: number): string {
+    return TIER_ADJECTIVES[tier] ?? `T${tier}`
+}

package/src/utils/cargo.ts

@@ -0,0 +1,27 @@
+import type {ServerContract} from '../contracts'
+
+export function cargoRef(src: {
+    item_id: number
+    stats: bigint | number
+    modules?: ServerContract.Types.module_entry[]
+}): ServerContract.ActionParams.Type.cargo_ref {
+    return {
+        item_id: src.item_id,
+        stats: src.stats,
+        modules: src.modules ?? [],
+    }
+}
+
+export function cargoItem(
+    src: {
+        item_id: number
+        stats: bigint | number
+        modules?: ServerContract.Types.module_entry[]
+    },
+    quantity: bigint | number
+): ServerContract.ActionParams.Type.cargo_item {
+    return {
+        ...cargoRef(src),
+        quantity,
+    }
+}

package/src/utils/system.ts

@@ -8,7 +8,6 @@ import nebulaAdjectives from '../data/nebula-adjectives.json'
 import nebulaNouns from '../data/nebula-nouns.json'
 
 const LOCATION_EXISTS_THRESHOLD = 0x10
-const LOCATION_ACTIVE_THRESHOLD = 0x80
 
 export function getLocationType(
     gameSeed: Checksum256Type,
@@ -151,31 +150,20 @@ export function deriveLocationStatic(
     return loc
 }
 
-export function deriveLocationEpoch(
-    epochSeed: Checksum256Type,
+export function isLocationBuildable(
+    gameSeed: Checksum256Type,
     coordinates: CoordinatesType
-): ServerContract.Types.location_epoch {
-    const seed = Checksum256.from(epochSeed)
-    const coords = Coordinates.from(coordinates)
-    const str = `system-epoch-${coords.x}-${coords.y}`
-    const hashResult = hash512(seed, str)
-
-    return ServerContract.Types.location_epoch.from({
-        active: hashResult.array[0] < LOCATION_ACTIVE_THRESHOLD,
-        seed0: hashResult.array[1],
-        seed1: hashResult.array[2],
-    })
+): boolean {
+    return getLocationType(gameSeed, coordinates) === LocationType.PLANET
 }
 
 export function deriveLocation(
     gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type,
     coordinates: CoordinatesType
 ): ServerContract.Types.location_derived {
     const staticProps = deriveLocationStatic(gameSeed, coordinates)
     return ServerContract.Types.location_derived.from({
         static_props: staticProps,
-        epoch_props: deriveLocationEpoch(epochSeed, coordinates),
         size: deriveLocationSize(staticProps),
     })
 }