@shipload/sdk 0.7.1 → 2.0.0-rc2

package/src/types.ts

@@ -1,16 +1,128 @@
-import {Struct, UInt16, UInt16Type, UInt64, UInt64Type} 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 TRAVEL_MAXMASS_PENALTY = 5 // Penalty (in seconds) for exceeding the maximum mass per 1000 unit
 
-export interface CameraPosition extends ServerContract.ActionParams.Type.coordinates {
-    z: number
+// 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 {
+    coordinates: ServerContract.Types.coordinates
+    hullmass: UInt32
+    energy: UInt16
+    engines: ServerContract.Types.movement_stats
+    generator: ServerContract.Types.energy_stats
+    loaders: ServerContract.Types.loader_stats
+    capacity: UInt32
+}
+
+export interface CargoMassInfo {
+    good_id: UInt16Type
+    quantity: UInt32Type
+}
+
+export enum TaskType {
+    IDLE = 0,
+    TRAVEL = 1,
+    RECHARGE = 2,
+    LOAD = 3,
+    UNLOAD = 4,
+    EXTRACT = 5,
+}
+
+export enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3,
 }
 
-export interface Dimensions {
-    width: number
-    height: number
+export enum TaskCancelable {
+    NEVER = 0, // Task cannot be cancelled
+    BEFORE_START = 1, // Task can only be cancelled before it starts
+    ALWAYS = 2, // Task can always be cancelled
+}
+
+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]
+
+export type CoordinatesType =
+    | Coordinates
+    | ServerContract.Types.coordinates
+    | {x: Int64Type; y: Int64Type}
+
+export class Coordinates extends ServerContract.Types.coordinates {
+    static from(value: CoordinatesType): Coordinates {
+        return super.from(value) as Coordinates
+    }
+
+    equals(other: CoordinatesType): boolean {
+        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 {
@@ -27,18 +139,10 @@ export class Good extends Struct {
     name!: string
     @Struct.field('string')
     description!: string
-    @Struct.field(UInt64)
-    base_price!: UInt64
-    @Struct.field(UInt64)
-    mass!: UInt64
-}
-
-export interface GoodType {
-    id: UInt16Type
-    name: string
-    description: string
-    base_price: UInt64Type
-    mass: UInt64Type
+    @Struct.field(UInt32)
+    base_price!: UInt32
+    @Struct.field(UInt32)
+    mass!: UInt32
 }
 
 @Struct.type('GoodPrice')
@@ -47,10 +151,8 @@ export class GoodPrice extends Struct {
     id!: UInt16
     @Struct.field(Good)
     good!: Good
-    @Struct.field(UInt64)
-    price!: UInt64
-    @Struct.field(UInt64)
-    supply!: UInt64
+    @Struct.field(UInt32)
+    price!: UInt32
+    @Struct.field(UInt16)
+    supply!: UInt16
 }
-
-export interface Coordinates extends ServerContract.ActionParams.Type.coordinates {}

package/src/{hash.ts → 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

@@ -0,0 +1,155 @@
+import {Checksum256, Checksum256Type, UInt8} from '@wharfkit/antelope'
+import {hash512} from './hash'
+import {Coordinates, CoordinatesType, LocationType, PRECISION} 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.ASTEROID || locationType === LocationType.NEBULA
+}
+
+export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
+    const seed = Checksum256.from(gameSeed)
+    if (!hasSystem(seed, location)) {
+        throw new Error("System doesn't exist at location")
+    }
+    const seedStr = `${location.x}${location.y}systemName`
+    const hashResult = hash512(seed, seedStr)
+    const syllableCount = 1 + (hashResult.array[0] % 3)
+    const name: string[] = []
+    for (let i = 0; i < syllableCount; i++) {
+        const index = hashResult.array[i] % syllables.length
+        const syllable = syllables[index]
+        name.push(i > 0 ? syllable.toLowerCase() : syllable)
+    }
+    return name.join('')
+}
+
+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 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(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),
+    })
+}
+
+export function deriveLocationMixture(
+    location: ServerContract.Types.location_derived,
+    epochSeed: Checksum256Type
+): ServerContract.Types.mixture_info {
+    const locationType = location.static_props.type.toNumber()
+
+    if (locationType === LocationType.NEBULA) {
+        return ServerContract.Types.mixture_info.from({
+            components: [{good_id: 1, purity: PRECISION}],
+        })
+    }
+
+    if (locationType === LocationType.ASTEROID) {
+        const seed = Checksum256.from(epochSeed)
+        const coords = location.static_props.coords
+        const str = `mixture-${coords.x}-${coords.y}`
+        const hashResult = hash512(seed, str)
+
+        const ironPrimary = location.static_props.subtype.toNumber() % 2 === 0
+        const purityRange = 0.3
+        const purityRoll = hashResult.array[0] / 255
+        const primaryPurity = 0.5 + purityRoll * purityRange
+
+        const primaryId = ironPrimary ? 26 : 29
+        const secondaryId = ironPrimary ? 29 : 26
+        const primaryAmt = Math.floor(primaryPurity * PRECISION)
+        const secondaryAmt = PRECISION - primaryAmt
+
+        return ServerContract.Types.mixture_info.from({
+            components: [
+                {good_id: primaryId, purity: primaryAmt},
+                {good_id: secondaryId, purity: secondaryAmt},
+            ],
+        })
+    }
+
+    return ServerContract.Types.mixture_info.from({components: []})
+}

package/src/goods.ts

@@ -1,124 +0,0 @@
-import {UInt16, UInt16Type, UInt64} from '@wharfkit/antelope'
-import {Coordinates, Good, GoodType, PRECISION} from './types'
-
-// List of goods with titles and descriptions
-const goods: GoodType[] = [
-    {
-        id: 1,
-        name: 'FizzGlo',
-        description: 'Pops with flavor! A neon drink that makes your burps glow.',
-        base_price: 50,
-        mass: 35_000,
-    },
-    // {
-    //     id: 2,
-    //     name: 'ZapSnacks',
-    //     description: 'Electric taste! Spicy edible energy sparks for a tongue-tingling experience.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 3,
-        name: 'Blob Buddies',
-        description: 'Squishy friends! Clingy, cute and mood-matching pet blobs for every home!',
-        base_price: 95,
-        mass: 60_000,
-    },
-    {
-        id: 4,
-        name: 'TuneTooth',
-        description: 'Whistle while you eat! Edible instrument treats that play tunes when chewed.',
-        base_price: 145,
-        mass: 75_000,
-    },
-    {
-        id: 5,
-        name: 'SunPods',
-        description: 'Miniature suns in your pocket providing on-demand light & warmth.',
-        base_price: 295,
-        mass: 135_000,
-    },
-    // {
-    //     id: 6,
-    //     name: 'Fuzzix',
-    //     description: 'Pocket-sized quantum fluff generator for instant comfy.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 7,
-        name: 'GlowGo',
-        description: 'Ingestible bioluminescent jelly, your inside glows in the dark!',
-        base_price: 650,
-        mass: 255_000,
-    },
-    // {
-    //     id: 8,
-    //     name: 'KrackleKaps',
-    //     description: 'Capsules packed with tiny firecrackers, spice up meals and parties.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 9,
-        name: 'PlasmaMints',
-        description: 'Hypercharged candy giving plasma breath capable of cutting through steel.',
-        base_price: 3450,
-        mass: 1_100_000,
-    },
-    {
-        id: 10,
-        name: 'TimeTreats',
-        description: 'Confectionery morsels releasing slow-mo effect over a limited period.',
-        base_price: 8500,
-        mass: 2_100_000,
-    },
-    {
-        id: 11,
-        name: 'QuantumQuencher',
-        description:
-            'Bottled hyper-fluid quenching thirst across multiple parallel realities simultaneously.',
-        base_price: 20_500,
-        mass: 4_100_000,
-    },
-    // {
-    //     id: 12,
-    //     name: 'TransmatterTruffles',
-    //     description: 'Delectable chocolates instantly teleporting consumers short distances.',
-    //     base_price: 0,
-    //     mass: 0,
-    // },
-    {
-        id: 13,
-        name: 'MemoryGum',
-        description: 'Chewable gum storing or replaying memories while being chewed.',
-        base_price: 52_500,
-        mass: 9_500_000,
-    },
-    {
-        id: 14,
-        name: 'SymbioSnack',
-        description: 'Edible alien larvae adopting owner’s taste preference upon consumption.',
-        base_price: 115_000,
-        mass: 16_000_000,
-    },
-]
-
-export const goodIds = goods.map((g) => g.id)
-
-export function getGood(good_id: UInt16Type): Good {
-    const good = goods.find((g) => UInt16.from(good_id).equals(g.id))
-    if (!good) {
-        throw new Error('Good does not exist')
-    }
-    return Good.from({
-        ...good,
-        id: UInt16.from(good.id),
-        base_price: UInt64.from(good.base_price),
-        mass: UInt64.from(good.mass).multiplying(PRECISION),
-    })
-}
-
-export function getGoods(): Good[] {
-    return goods.map((g) => getGood(g.id))
-}

package/src/ship.ts

@@ -1,36 +0,0 @@
-import {UInt32} from '@wharfkit/antelope'
-import {ServerContract} from './contracts'
-import {PRECISION} from './types'
-import {travelplanDuration} from './travel'
-
-export class Ship extends ServerContract.Types.ship_row {
-    get maxDistance(): UInt32 {
-        return this.stats.capacity.dividing(this.stats.drain).multiplying(PRECISION)
-    }
-
-    get traveling(): boolean {
-        return !!this.travelplan
-    }
-
-    get arrived(): boolean {
-        if (!this.travelplan) {
-            throw new Error('Ship is not traveling')
-        }
-        const depart = this.travelplan.departure.toDate()
-        const arrive = new Date(
-            depart.getTime() + Number(travelplanDuration(this.travelplan)) * 1000
-        )
-        return new Date() >= arrive
-    }
-
-    get eta(): number {
-        if (!this.travelplan) {
-            throw new Error('Ship is not traveling')
-        }
-        const depart = this.travelplan.departure.toDate()
-        const arrive = new Date(
-            depart.getTime() + Number(travelplanDuration(this.travelplan)) * 1000
-        )
-        return arrive.getTime() - new Date().getTime()
-    }
-}