@shipload/sdk 2.0.0-rc1 → 2.0.0-rc3

package/src/types.ts

@@ -1,15 +1,59 @@
-import {Int64Type, Name, Struct, UInt16, UInt16Type, UInt32, UInt32Type} from '@wharfkit/antelope'
+import {
+    Int64Type,
+    Name,
+    Struct,
+    UInt16,
+    UInt16Type,
+    UInt32,
+    UInt32Type,
+    UInt64,
+} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
 
-export const INITIAL_SHIP_MASS = 500000
+// Ship constants
+export const INITIAL_SHIP_GENERATOR_CAPACITY = 350
+export const INITIAL_SHIP_DRAIN = 25
+export const INITIAL_SHIP_ENERGY = 350
+export const INITIAL_SHIP_HULLMASS = 100000
+export const INITIAL_SHIP_CAPACITY = 500000
+export const INITIAL_SHIP_Z = 800
+export const INITIAL_SHIP_RECHARGE = 10
+export const INITIAL_SHIP_THRUST = 250
+
+// Loader constants
+export const INITIAL_LOADER_MASS = 1000
+export const INITIAL_LOADER_QUANTITY = 1
+export const INITIAL_LOADER_THRUST = 1
+
+// Warehouse constants
+export const WAREHOUSE_Z = 500
+export const INITIAL_WAREHOUSE_CAPACITY = 10000000
+
+// Container constants
+export const CONTAINER_Z = 300
+export const INITIAL_CONTAINER_HULLMASS = 50000
+export const INITIAL_CONTAINER_CAPACITY = 2000000
+
+// Mechanics
+export const TRAVEL_MAX_DURATION = 86400
+
+// Altitude limits (for UI/calculations)
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
+// Legacy alias (deprecated, use INITIAL_SHIP_CAPACITY)
+export const INITIAL_SHIP_MASS = 500000
+
+// Extractor constants
+export const INITIAL_EXTRACTOR_RATE = 700
+export const INITIAL_EXTRACTOR_DRAIN = 2500
+export const INITIAL_EXTRACTOR_EFFICIENCY = 5000
+
 export interface ShipLike {
-    location: ServerContract.Types.coordinates
-    mass: UInt32
+    coordinates: ServerContract.Types.coordinates
+    hullmass: UInt32
     energy: UInt16
     engines: ServerContract.Types.movement_stats
     generator: ServerContract.Types.energy_stats
@@ -18,15 +62,25 @@ export interface ShipLike {
 }
 
 export interface CargoMassInfo {
-    good_id: UInt16Type
+    item_id: UInt16Type
     quantity: UInt32Type
 }
 
 export enum TaskType {
-    RECHARGE = 0,
-    LOAD = 1,
-    UNLOAD = 2,
-    FLIGHT = 3,
+    IDLE = 0,
+    TRAVEL = 1,
+    RECHARGE = 2,
+    LOAD = 3,
+    UNLOAD = 4,
+    EXTRACT = 5,
+    WARP = 6,
+}
+
+export enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3,
 }
 
 export enum TaskCancelable {
@@ -38,6 +92,7 @@ export enum TaskCancelable {
 export const EntityType = {
     SHIP: Name.from('ship'),
     WAREHOUSE: Name.from('warehouse'),
+    CONTAINER: Name.from('container'),
 } as const
 
 export type EntityTypeName = (typeof EntityType)[keyof typeof EntityType]
@@ -56,6 +111,19 @@ export class Coordinates extends ServerContract.Types.coordinates {
         const coords = Coordinates.from(other)
         return this.x.equals(coords.x) && this.y.equals(coords.y)
     }
+
+    toLocationId(): UInt64 {
+        return coordsToLocationId(this)
+    }
+}
+
+export function coordsToLocationId(coords: CoordinatesType): UInt64 {
+    const c = Coordinates.from(coords)
+    const mask = BigInt(0xffffffff)
+    const x = BigInt(c.x.toNumber()) & mask
+    const y = BigInt(c.y.toNumber()) & mask
+    const id = (x << BigInt(32)) | y
+    return UInt64.from(id)
 }
 
 export interface Distance {
@@ -64,8 +132,11 @@ export interface Distance {
     distance: UInt16
 }
 
-@Struct.type('good')
-export class Good extends Struct {
+export type ResourceCategory = 'metal' | 'gas' | 'mineral' | 'organic'
+export type ResourceRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary'
+
+@Struct.type('item')
+export class Item extends Struct {
     @Struct.field(UInt16)
     id!: UInt16
     @Struct.field('string')
@@ -76,14 +147,20 @@ export class Good extends Struct {
     base_price!: UInt32
     @Struct.field(UInt32)
     mass!: UInt32
+    @Struct.field('string')
+    category!: ResourceCategory
+    @Struct.field('string')
+    rarity!: ResourceRarity
+    @Struct.field('string')
+    color!: string
 }
 
-@Struct.type('GoodPrice')
-export class GoodPrice extends Struct {
+@Struct.type('ItemPrice')
+export class ItemPrice extends Struct {
     @Struct.field(UInt16)
     id!: UInt16
-    @Struct.field(Good)
-    good!: Good
+    @Struct.field(Item)
+    item!: Item
     @Struct.field(UInt32)
     price!: UInt32
     @Struct.field(UInt16)

package/src/utils/hash.ts

@@ -1,6 +1,6 @@
 import {Bytes, Checksum256, Checksum256Type, Checksum512} from '@wharfkit/antelope'
 
-export function hash(seed: Checksum256Type, string: string): Checksum512 {
+export function hash(seed: Checksum256Type, string: string): Checksum256 {
     const bytes = Bytes.from(`${seed}${string}`, 'utf8')
     return Checksum256.hash(bytes)
 }

package/src/utils/system.ts

@@ -1,8 +1,36 @@
-import {Checksum256, Checksum256Type} from '@wharfkit/antelope'
+import {Checksum256, Checksum256Type, UInt8} from '@wharfkit/antelope'
 import {hash512} from './hash'
-import {CoordinatesType} from '../types'
+import {Coordinates, CoordinatesType, LocationType} from '../types'
+import {ServerContract} from '../contracts'
 import syllables from '../data/syllables.json'
 
+const LOCATION_EXISTS_THRESHOLD = 0x10
+const LOCATION_ACTIVE_THRESHOLD = 0x80
+
+export function getLocationType(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): LocationType {
+    const seed = Checksum256.from(gameSeed)
+    const str = ['system', coordinates.x, coordinates.y].join('-')
+    const hashResult = hash512(seed, str)
+
+    if (hashResult.array[0] >= LOCATION_EXISTS_THRESHOLD) {
+        return LocationType.EMPTY
+    }
+
+    if (hashResult.array[1] < 96) {
+        return LocationType.PLANET
+    } else if (hashResult.array[1] < 176) {
+        return LocationType.ASTEROID
+    }
+    return LocationType.NEBULA
+}
+
+export function isExtractableLocation(locationType: LocationType): boolean {
+    return locationType !== LocationType.EMPTY
+}
+
 export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
     const seed = Checksum256.from(gameSeed)
     if (!hasSystem(seed, location)) {
@@ -21,7 +49,72 @@ export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesTy
 }
 
 export function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean {
+    return getLocationType(gameSeed, coordinates) !== LocationType.EMPTY
+}
+
+export function deriveLocationStatic(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): ServerContract.Types.location_static {
     const seed = Checksum256.from(gameSeed)
-    const str = ['system', coordinates.x, coordinates.y].join('-')
-    return String(hash512(seed, str)).slice(0, 2) === '00'
+    const coords = Coordinates.from(coordinates)
+    const str = `system-${coords.x}-${coords.y}`
+    const hashResult = hash512(seed, str)
+
+    const loc = ServerContract.Types.location_static.from({
+        coords: coords,
+        type: LocationType.EMPTY,
+        subtype: 0,
+        seed0: 0,
+        seed1: 0,
+    })
+
+    if (hashResult.array[0] >= LOCATION_EXISTS_THRESHOLD) {
+        return loc
+    }
+
+    if (hashResult.array[1] < 96) {
+        loc.type = UInt8.from(LocationType.PLANET)
+    } else if (hashResult.array[1] < 176) {
+        loc.type = UInt8.from(LocationType.ASTEROID)
+    } else {
+        loc.type = UInt8.from(LocationType.NEBULA)
+    }
+
+    loc.subtype = UInt8.from(
+        Number(loc.type) === LocationType.PLANET
+            ? hashResult.array[2] % 6
+            : hashResult.array[2]
+    )
+    loc.seed0 = UInt8.from(hashResult.array[3])
+    loc.seed1 = UInt8.from(hashResult.array[4])
+
+    return loc
+}
+
+export function deriveLocationEpoch(
+    epochSeed: 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],
+    })
+}
+
+export function deriveLocation(
+    gameSeed: Checksum256Type,
+    epochSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): ServerContract.Types.location_derived {
+    return ServerContract.Types.location_derived.from({
+        static_props: deriveLocationStatic(gameSeed, coordinates),
+        epoch_props: deriveLocationEpoch(epochSeed, coordinates),
+    })
 }

package/src/data/goods.json

@@ -1,23 +0,0 @@
-[
-    {
-        "id": 1,
-        "name": "Hydrogen",
-        "description": "A lightweight fuel source essential for interstellar travel.",
-        "base_price": 50,
-        "mass": 15000
-    },
-    {
-        "id": 2,
-        "name": "Iron",
-        "description": "A versatile metal used in construction and manufacturing.",
-        "base_price": 125,
-        "mass": 40000
-    },
-    {
-        "id": 3,
-        "name": "Copper",
-        "description": "A conductive metal vital for electronics and wiring.",
-        "base_price": 200,
-        "mass": 60000
-    }
-]

package/src/market/goods.ts

@@ -1,31 +0,0 @@
-import {UInt16, UInt16Type, UInt32} from '@wharfkit/antelope'
-import {Good} from '../types'
-import goodsData from '../data/goods.json'
-
-const goods = goodsData as Array<{
-    id: number
-    name: string
-    description: string
-    base_price: number
-    mass: number
-}>
-
-export const goodIds = goods.map((g) => g.id)
-
-export function getGood(goodId: UInt16Type): Good {
-    const good = goods.find((g) => UInt16.from(goodId).equals(g.id))
-    if (!good) {
-        throw new Error('Good does not exist')
-    }
-    return Good.from({
-        id: UInt16.from(good.id),
-        name: good.name,
-        description: good.description,
-        base_price: UInt32.from(good.base_price),
-        mass: UInt32.from(good.mass),
-    })
-}
-
-export function getGoods(): Good[] {
-    return goods.map((g) => getGood(g.id))
-}