@shipload/sdk 2.0.0-rc1 → 2.0.0-rc3

package/src/data/items.json

@@ -0,0 +1,16 @@
+[
+    {"id": 1, "name": "Hydrogen", "description": "A lightweight gas used for fuel cells and propulsion.", "base_price": 50, "mass": 15000, "category": "gas", "rarity": "common", "color": "#7EC8E3"},
+    {"id": 2, "name": "Helium", "description": "An inert noble gas used in energy systems.", "base_price": 75, "mass": 2000, "category": "gas", "rarity": "uncommon", "color": "#F5E6CC"},
+    {"id": 6, "name": "Carbon", "description": "A versatile element for life support and coatings.", "base_price": 100, "mass": 12000, "category": "organic", "rarity": "common", "color": "#4A4A4A"},
+    {"id": 14, "name": "Silicon", "description": "A semiconductor used in sensors and computing.", "base_price": 150, "mass": 28000, "category": "mineral", "rarity": "common", "color": "#B8A9C9"},
+    {"id": 18, "name": "Argon", "description": "A noble gas used in industrial and energy applications.", "base_price": 60, "mass": 8000, "category": "gas", "rarity": "rare", "color": "#9B59B6"},
+    {"id": 22, "name": "Titanium", "description": "A strong, lightweight metal for ship construction.", "base_price": 300, "mass": 48000, "category": "metal", "rarity": "rare", "color": "#C0C0C0"},
+    {"id": 26, "name": "Iron", "description": "A versatile metal used in hulls and structures.", "base_price": 125, "mass": 40000, "category": "metal", "rarity": "common", "color": "#B7410E"},
+    {"id": 29, "name": "Copper", "description": "A conductive metal for electronics and wiring.", "base_price": 200, "mass": 60000, "category": "metal", "rarity": "uncommon", "color": "#B87333"},
+    {"id": 54, "name": "Xenon", "description": "A rare noble gas for advanced propulsion systems.", "base_price": 175, "mass": 20000, "category": "gas", "rarity": "epic", "color": "#5B2C6F"},
+    {"id": 74, "name": "Tungsten", "description": "An extremely dense metal for heavy-duty applications.", "base_price": 500, "mass": 80000, "category": "metal", "rarity": "epic", "color": "#708090"},
+    {"id": 1000, "name": "Quartz", "description": "A crystalline mineral for sensors and optics.", "base_price": 200, "mass": 35000, "category": "mineral", "rarity": "uncommon", "color": "#E8D5B7"},
+    {"id": 1001, "name": "Sapphire", "description": "A precious crystal for precision instruments.", "base_price": 400, "mass": 45000, "category": "mineral", "rarity": "rare", "color": "#0F52BA"},
+    {"id": 1002, "name": "Polymers", "description": "Synthetic materials for coatings and consumables.", "base_price": 150, "mass": 25000, "category": "organic", "rarity": "rare", "color": "#2ECC71"},
+    {"id": 1003, "name": "Biomass", "description": "Organic matter for life support systems.", "base_price": 100, "mass": 30000, "category": "organic", "rarity": "uncommon", "color": "#8B4513"}
+]

package/src/derivation/index.ts

@@ -0,0 +1,25 @@
+export {deriveStratum, deriveResourceStats} from './stratum'
+export type {StratumInfo, ResourceStats} from './stratum'
+export {deriveLocationSize} from './location-size'
+export {
+    getEligibleResources,
+    getResourceWeight,
+    getLocationCandidates,
+    getDepthThreshold,
+    getResourceRarity,
+    depthScaleFactor,
+    DEPTH_THRESHOLD_COMMON,
+    DEPTH_THRESHOLD_UNCOMMON,
+    DEPTH_THRESHOLD_RARE,
+    DEPTH_THRESHOLD_EPIC,
+    DEPTH_THRESHOLD_LEGENDARY,
+    LOCATION_MIN_DEPTH,
+    LOCATION_MAX_DEPTH,
+    YIELD_THRESHOLD,
+    PLANET_SUBTYPE_GAS_GIANT,
+    PLANET_SUBTYPE_ROCKY,
+    PLANET_SUBTYPE_TERRESTRIAL,
+    PLANET_SUBTYPE_ICY,
+    PLANET_SUBTYPE_OCEAN,
+    PLANET_SUBTYPE_INDUSTRIAL,
+} from './resources'

package/src/derivation/location-size.ts

@@ -0,0 +1,15 @@
+import {ServerContract} from '../contracts'
+import {LocationType} from '../types'
+import {LOCATION_MAX_DEPTH, LOCATION_MIN_DEPTH} from './resources'
+
+export function deriveLocationSize(loc: ServerContract.Types.location_static): number {
+    if (loc.type.toNumber() === LocationType.EMPTY) return 0
+
+    const raw = (loc.seed0.toNumber() << 8) | loc.seed1.toNumber()
+    const normalized = raw / 65535
+
+    const curved = Math.pow(normalized, 3.0)
+
+    const range = LOCATION_MAX_DEPTH - LOCATION_MIN_DEPTH
+    return Math.floor(LOCATION_MIN_DEPTH + curved * range)
+}

package/src/derivation/resources.ts

@@ -0,0 +1,141 @@
+import {ResourceRarity} from '../types'
+
+export const DEPTH_THRESHOLD_COMMON = 0
+export const DEPTH_THRESHOLD_UNCOMMON = 2000
+export const DEPTH_THRESHOLD_RARE = 10000
+export const DEPTH_THRESHOLD_EPIC = 30000
+export const DEPTH_THRESHOLD_LEGENDARY = 55000
+
+export const LOCATION_MIN_DEPTH = 500
+export const LOCATION_MAX_DEPTH = 65535
+
+export const YIELD_THRESHOLD = Math.floor(0.003 * 0xffffffff)
+
+export const PLANET_SUBTYPE_GAS_GIANT = 0
+export const PLANET_SUBTYPE_ROCKY = 1
+export const PLANET_SUBTYPE_TERRESTRIAL = 2
+export const PLANET_SUBTYPE_ICY = 3
+export const PLANET_SUBTYPE_OCEAN = 4
+export const PLANET_SUBTYPE_INDUSTRIAL = 5
+
+interface ResourceEntry {
+    id: number
+    rarity: ResourceRarity
+}
+
+const RESOURCE_CATALOG: ResourceEntry[] = [
+    {id: 26, rarity: 'common'},
+    {id: 1, rarity: 'common'},
+    {id: 14, rarity: 'common'},
+    {id: 6, rarity: 'common'},
+    {id: 29, rarity: 'uncommon'},
+    {id: 2, rarity: 'uncommon'},
+    {id: 1000, rarity: 'uncommon'},
+    {id: 1003, rarity: 'uncommon'},
+    {id: 22, rarity: 'rare'},
+    {id: 18, rarity: 'rare'},
+    {id: 1001, rarity: 'rare'},
+    {id: 1002, rarity: 'rare'},
+    {id: 74, rarity: 'epic'},
+    {id: 54, rarity: 'epic'},
+]
+
+export function getDepthThreshold(rarity: ResourceRarity): number {
+    switch (rarity) {
+        case 'common':
+            return DEPTH_THRESHOLD_COMMON
+        case 'uncommon':
+            return DEPTH_THRESHOLD_UNCOMMON
+        case 'rare':
+            return DEPTH_THRESHOLD_RARE
+        case 'epic':
+            return DEPTH_THRESHOLD_EPIC
+        case 'legendary':
+            return DEPTH_THRESHOLD_LEGENDARY
+    }
+}
+
+export function getResourceRarity(itemId: number): ResourceRarity {
+    const entry = RESOURCE_CATALOG.find((r) => r.id === itemId)
+    return entry ? entry.rarity : 'legendary'
+}
+
+export function getResourceWeight(itemId: number, stratum: number): number {
+    const rarity = getResourceRarity(itemId)
+    const threshold = getDepthThreshold(rarity)
+    if (stratum < threshold) return 0
+
+    const depthAbove = stratum - threshold
+
+    switch (rarity) {
+        case 'common':
+            if (stratum < 2000) return 100
+            if (stratum < 10000) return 80
+            if (stratum < 30000) return 50
+            return 30
+        case 'uncommon':
+            if (depthAbove < 3000) return 40
+            if (depthAbove < 8000) return 60
+            return 50
+        case 'rare':
+            if (depthAbove < 5000) return 20
+            if (depthAbove < 15000) return 35
+            return 40
+        case 'epic':
+            if (depthAbove < 10000) return 10
+            if (depthAbove < 25000) return 20
+            return 30
+        case 'legendary':
+            return 10
+    }
+}
+
+const ASTEROID_RESOURCES = [26, 29, 22, 74, 14, 1000, 1001]
+const NEBULA_RESOURCES = [1, 2, 18, 54]
+const GAS_GIANT_RESOURCES = [1, 2, 18, 54]
+const ROCKY_RESOURCES = [26, 29, 22, 74, 6, 1003, 1002]
+const TERRESTRIAL_RESOURCES = [6, 1003, 1002, 1001]
+const ICY_RESOURCES = [6, 14, 1000, 1001, 18]
+const OCEAN_RESOURCES = [1, 2, 1003, 1002]
+const INDUSTRIAL_RESOURCES = [26, 29, 22, 74, 14, 1000, 54]
+
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    if (locationType === 2) return ASTEROID_RESOURCES
+    if (locationType === 3) return NEBULA_RESOURCES
+    if (locationType === 1) {
+        switch (subtype) {
+            case PLANET_SUBTYPE_GAS_GIANT:
+                return GAS_GIANT_RESOURCES
+            case PLANET_SUBTYPE_ROCKY:
+                return ROCKY_RESOURCES
+            case PLANET_SUBTYPE_TERRESTRIAL:
+                return TERRESTRIAL_RESOURCES
+            case PLANET_SUBTYPE_ICY:
+                return ICY_RESOURCES
+            case PLANET_SUBTYPE_OCEAN:
+                return OCEAN_RESOURCES
+            case PLANET_SUBTYPE_INDUSTRIAL:
+                return INDUSTRIAL_RESOURCES
+        }
+    }
+    return []
+}
+
+export function getEligibleResources(
+    locationType: number,
+    subtype: number,
+    stratum: number
+): number[] {
+    const candidates = getLocationCandidates(locationType, subtype)
+    return candidates.filter((itemId) => {
+        const rarity = getResourceRarity(itemId)
+        const threshold = getDepthThreshold(rarity)
+        return stratum >= threshold
+    })
+}
+
+export function depthScaleFactor(stratum: number): number {
+    if (stratum <= 1) return 1.0
+    const logScale = Math.log(stratum) / Math.log(65535)
+    return 1.0 + logScale * 2.0
+}

package/src/derivation/stratum.ts

@@ -0,0 +1,116 @@
+import {Bytes, Checksum256, Checksum256Type} from '@wharfkit/antelope'
+import {hash512} from '../utils/hash'
+import {Coordinates, CoordinatesType} from '../types'
+import {
+    depthScaleFactor,
+    getEligibleResources,
+    getResourceWeight,
+    YIELD_THRESHOLD,
+} from './resources'
+
+export interface StratumInfo {
+    itemId: number
+    seed: bigint
+    richness: number
+    reserve: number
+}
+
+export interface ResourceStats {
+    purity: number
+    density: number
+    reactivity: number
+    resonance: number
+}
+
+export function deriveStratum(
+    epochSeed: Checksum256Type,
+    coords: CoordinatesType,
+    stratum: number,
+    locationType: number,
+    subtype: number,
+    _maxDepth: number
+): StratumInfo {
+    const seed = Checksum256.from(epochSeed)
+    const c = Coordinates.from(coords)
+    const input = `stratum-${c.x}-${c.y}-${stratum}`
+    const hashResult = hash512(seed, input)
+    const bytes = hashResult.array
+
+    const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
+
+    let reserve = 0
+    if (rawReserve <= YIELD_THRESHOLD) {
+        const baseReserve = (rawReserve % 333) + 1
+        const scale = depthScaleFactor(stratum)
+        reserve = Math.floor(baseReserve * scale)
+    }
+
+    if (reserve === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+
+    const eligible = getEligibleResources(locationType, subtype, stratum)
+    if (eligible.length === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+
+    const resourceRoll = ((bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7]) >>> 0
+
+    let totalWeight = 0
+    for (const id of eligible) {
+        totalWeight += getResourceWeight(id, stratum)
+    }
+
+    let selectedItemId = eligible[0]
+    if (totalWeight > 0) {
+        const roll = resourceRoll % totalWeight
+        let cumulative = 0
+        for (const id of eligible) {
+            cumulative += getResourceWeight(id, stratum)
+            if (roll < cumulative) {
+                selectedItemId = id
+                break
+            }
+        }
+    }
+
+    const seedBigInt =
+        (BigInt(bytes[8]) << 56n) |
+        (BigInt(bytes[9]) << 48n) |
+        (BigInt(bytes[10]) << 40n) |
+        (BigInt(bytes[11]) << 32n) |
+        (BigInt(bytes[12]) << 24n) |
+        (BigInt(bytes[13]) << 16n) |
+        (BigInt(bytes[14]) << 8n) |
+        BigInt(bytes[15])
+
+    const rawRichness = (bytes[16] << 8) | bytes[17]
+    const normalized = rawRichness / 65535
+    const baseRichness = Math.floor(normalized * normalized * 999) + 1
+
+    let depthBonus = 0
+    if (stratum > 1) {
+        depthBonus = 50 * Math.log(stratum) / Math.log(65535)
+    }
+    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
+
+    return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
+}
+
+export function deriveResourceStats(seed: bigint): ResourceStats {
+    const seedStr = seed.toString()
+    const encoder = new TextEncoder()
+    const data = encoder.encode(seedStr)
+    const hashResult = Checksum256.hash(Bytes.from(data))
+    const hashBytes = hashResult.array
+
+    const extractU32 = (offset: number): number =>
+        ((hashBytes[offset] << 24) |
+            (hashBytes[offset + 1] << 16) |
+            (hashBytes[offset + 2] << 8) |
+            hashBytes[offset + 3]) >>>
+        0
+
+    return {
+        purity: (extractU32(0) % 1000) + 1,
+        density: (extractU32(4) % 1000) + 1,
+        reactivity: (extractU32(8) % 1000) + 1,
+        resonance: (extractU32(12) % 1000) + 1,
+    }
+}

package/src/entities/cargo-utils.ts

@@ -1,5 +1,6 @@
-import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {EntityInventory} from './entity-inventory'
+import {ServerContract} from '../contracts'
 
 export interface CargoData {
     cargo: EntityInventory[]
@@ -17,11 +18,11 @@ export function cargoValue(cargo: EntityInventory[]): UInt64 {
     }, UInt64.from(0))
 }
 
-export function getCargoForGood(
+export function getCargoForItem(
     cargo: EntityInventory[],
     goodId: UInt64Type
 ): EntityInventory | undefined {
-    return cargo.find((c) => c.good_id.equals(goodId))
+    return cargo.find((c) => c.item_id.equals(goodId))
 }
 
 export function hasSpace(
@@ -45,3 +46,97 @@ export function availableCapacity(currentMass: UInt64, maxCapacity: UInt64): UIn
 export function isFull(currentMass: UInt64, maxCapacity: UInt64): boolean {
     return currentMass.gte(maxCapacity)
 }
+
+export interface SaleValue {
+    revenue: UInt64
+    profit: UInt64
+    cost: UInt64
+}
+
+export function calculateSaleValue(
+    cargo: ServerContract.Types.cargo_item[],
+    prices: Map<number, UInt64>
+): SaleValue {
+    if (cargo.length === 0) {
+        return {revenue: UInt64.from(0), profit: UInt64.from(0), cost: UInt64.from(0)}
+    }
+
+    let revenue = UInt64.from(0)
+    let cost = UInt64.from(0)
+
+    for (const item of cargo) {
+        if (UInt32.from(item.quantity).equals(UInt32.from(0))) continue
+
+        const goodId = Number(item.item_id)
+        const salePrice = prices.get(goodId)
+
+        if (salePrice) {
+            revenue = revenue.adding(salePrice.multiplying(item.quantity))
+        }
+
+        cost = cost.adding(item.unit_cost.multiplying(item.quantity))
+    }
+
+    const profit = revenue.gte(cost) ? revenue.subtracting(cost) : UInt64.from(0)
+
+    return {
+        revenue,
+        profit,
+        cost,
+    }
+}
+
+export function calculateSaleValueFromArray(
+    cargo: ServerContract.Types.cargo_item[],
+    prices: UInt64[]
+): SaleValue {
+    const priceMap = new Map<number, UInt64>()
+    prices.forEach((price, index) => {
+        priceMap.set(index, price)
+    })
+    return calculateSaleValue(cargo, priceMap)
+}
+
+export function afterSellItems(
+    cargo: ServerContract.Types.cargo_item[],
+    goodsToSell: Array<{goodId: number; quantity: number}>
+): EntityInventory[] {
+    if (cargo.length === 0) {
+        return []
+    }
+
+    return cargo.map((item) => {
+        const saleItem = goodsToSell.find((s) => Number(item.item_id) === s.goodId)
+        if (!saleItem) {
+            return new EntityInventory(item)
+        }
+
+        const currentQty = Number(item.quantity)
+        const newQty = Math.max(0, currentQty - saleItem.quantity)
+
+        return new EntityInventory(
+            ServerContract.Types.cargo_item.from({
+                item_id: item.item_id,
+                quantity: UInt32.from(newQty),
+                unit_cost: item.unit_cost,
+            })
+        )
+    })
+}
+
+export function afterSellAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
+    if (cargo.length === 0) {
+        return []
+    }
+
+    return cargo.map(
+        (item) =>
+            new EntityInventory(
+                ServerContract.Types.cargo_item.from({
+                    item_id: item.item_id,
+                    quantity: UInt32.from(0),
+                    unit_cost: item.unit_cost,
+                })
+            )
+    )
+}

package/src/entities/container.ts

@@ -0,0 +1,70 @@
+import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import * as schedule from '../scheduling/schedule'
+
+export interface ContainerStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass: number
+    capacity: number
+    cargomass?: number
+    schedule?: ServerContract.Types.schedule
+}
+
+export class Container extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get sched(): ScheduleAccessor {
+        return (this._sched ??= new ScheduleAccessor(this))
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    isLoading(now: Date): boolean {
+        return schedule.isLoading(this, now)
+    }
+
+    isUnloading(now: Date): boolean {
+        return schedule.isUnloading(this, now)
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalMass(): UInt64 {
+        return UInt64.from(this.hullmass ?? 0).adding(this.cargomass)
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = UInt64.from(this.cargomass)
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
+    }
+
+    hasSpace(additionalMass: UInt64): boolean {
+        return UInt64.from(this.cargomass).adding(additionalMass).lte(this.maxCapacity)
+    }
+
+    get isFull(): boolean {
+        return UInt64.from(this.cargomass).gte(this.maxCapacity)
+    }
+
+    get orbitalAltitude(): number {
+        return this.coordinates.z?.toNumber() || 0
+    }
+}

package/src/entities/entity-inventory.ts

@@ -1,24 +1,28 @@
 import {UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {getGood} from '../market/goods'
-import {Good} from '../types'
+import {getItem} from '../market/items'
+import {Item} from '../types'
 
 export class EntityInventory extends ServerContract.Types.cargo_item {
-    private _good?: Good
+    private _item?: Item
 
-    get good(): Good {
-        if (!this._good) {
-            this._good = getGood(this.good_id)
+    get item(): Item {
+        if (!this._item) {
+            this._item = getItem(this.item_id)
         }
-        return this._good
+        return this._item
+    }
+
+    get good(): Item {
+        return this.item
     }
 
     get name(): string {
-        return this.good.name
+        return this.item.name
     }
 
     get unitMass(): UInt32 {
-        return this.good.mass
+        return this.item.mass
     }
 
     get totalMass(): UInt64 {

package/src/entities/inventory-accessor.ts

@@ -0,0 +1,46 @@
+import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {EntityInventory} from './entity-inventory'
+import {HasCargo} from '../capabilities/storage'
+
+export type {HasCargo}
+
+export class InventoryAccessor {
+    private _items?: EntityInventory[]
+
+    constructor(private readonly entity: HasCargo) {}
+
+    get items(): EntityInventory[] {
+        if (!this._items) {
+            this._items = this.entity.cargo.map((item) => new EntityInventory(item))
+        }
+        return this._items
+    }
+
+    get totalMass(): UInt64 {
+        return this.items.reduce((sum, c) => sum.adding(c.totalMass), UInt64.from(0))
+    }
+
+    get totalValue(): UInt64 {
+        return this.items.reduce((sum, c) => sum.adding(c.totalCost), UInt64.from(0))
+    }
+
+    forItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.items.find((c) => c.item_id.equals(goodId))
+    }
+
+    get sellable(): EntityInventory[] {
+        return this.items.filter((c) => c.hasCargo)
+    }
+
+    get hasSellable(): boolean {
+        return this.items.some((c) => c.hasCargo)
+    }
+
+    get sellableCount(): number {
+        return this.items.filter((c) => c.hasCargo).length
+    }
+}
+
+export function createInventoryAccessor(entity: HasCargo): InventoryAccessor {
+    return new InventoryAccessor(entity)
+}