@shipload/sdk 0.7.1 → 2.0.0-rc10

package/src/types.ts

@@ -1,16 +1,109 @@
-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 const CRAFT_ENERGY_DIVISOR = 150000
 
-export interface CameraPosition extends ServerContract.ActionParams.Type.coordinates {
-    z: number
+export const WAREHOUSE_Z = 500
+export const INITIAL_WAREHOUSE_CAPACITY = 10000000
+
+export const CONTAINER_Z = 300
+export const INITIAL_CONTAINER_HULLMASS = 50000
+export const INITIAL_CONTAINER_CAPACITY = 2000000
+
+export const TRAVEL_MAX_DURATION = 86400
+
+export const MIN_ORBITAL_ALTITUDE = 800
+export const MAX_ORBITAL_ALTITUDE = 3000
+
+export const BASE_ORBITAL_MASS = 100000
+
+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
+    hauler?: ServerContract.Types.hauler_stats
+    capacity?: UInt32
+}
+
+export interface CargoMassInfo {
+    item_id: UInt16Type
+    quantity: UInt32Type
+}
+
+export enum TaskType {
+    IDLE = 0,
+    TRAVEL = 1,
+    RECHARGE = 2,
+    LOAD = 3,
+    UNLOAD = 4,
+    EXTRACT = 5,
+    WARP = 6,
+    CRAFT = 7,
+    DEPLOY = 8,
+    DEPLOY_SHIP = 9,
+}
+
+export enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3,
 }
 
-export interface Dimensions {
-    width: number
-    height: number
+export enum TaskCancelable {
+    NEVER = 0,
+    BEFORE_START = 1,
+    ALWAYS = 2,
+}
+
+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 {
@@ -19,38 +112,23 @@ export interface Distance {
     distance: UInt16
 }
 
-@Struct.type('good')
-export class Good extends Struct {
+export type ResourceCategory = 'metal' | 'precious' | 'gas' | 'mineral' | 'organic'
+export type ResourceTier = 't1' | 't2' | 't3' | 't4' | 't5'
+
+@Struct.type('item')
+export class Item extends Struct {
     @Struct.field(UInt16)
     id!: UInt16
     @Struct.field('string')
     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.type('GoodPrice')
-export class GoodPrice extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field(Good)
-    good!: Good
-    @Struct.field(UInt64)
-    price!: UInt64
-    @Struct.field(UInt64)
-    supply!: UInt64
+    @Struct.field(UInt32)
+    mass!: UInt32
+    @Struct.field('string')
+    category!: ResourceCategory
+    @Struct.field('string')
+    tier!: ResourceTier
+    @Struct.field('string')
+    color!: string
 }
-
-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, Checksum512, UInt8} from '@wharfkit/antelope'
+import {hash512} from './hash'
+import {Coordinates, CoordinatesType, LocationType} from '../types'
+import {ServerContract} from '../contracts'
+import {deriveLocationSize} from '../derivation/location-size'
+import syllables from '../data/syllables.json'
+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,
+    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
+}
+
+function uint16(hash: Checksum512, offset: number): number {
+    return (hash.array[offset] << 8) | hash.array[offset + 1]
+}
+
+function generatePlanetName(hashResult: Checksum512): string {
+    const syllableCount = 2 + (hashResult.array[0] % 2)
+    const name: string[] = []
+    for (let i = 0; i < syllableCount; i++) {
+        const index = uint16(hashResult, 1 + i * 2) % syllables.length
+        const syllable = syllables[index]
+        name.push(i > 0 ? syllable.toLowerCase() : syllable)
+    }
+    return name.join('')
+}
+
+function generateAsteroidName(hashResult: Checksum512): string {
+    const A = 65
+    const letter1 = String.fromCharCode(A + (hashResult.array[0] % 26))
+    const letter2 = String.fromCharCode(A + (hashResult.array[1] % 26))
+    const num = (uint16(hashResult, 2) % 9000) + 1000
+    return `${letter1}${letter2}-${num}`
+}
+
+function generateNebulaName(hashResult: Checksum512): string {
+    const adjIdx = uint16(hashResult, 0) % nebulaAdjectives.length
+    const nounIdx = uint16(hashResult, 2) % nebulaNouns.length
+    return `${nebulaAdjectives[adjIdx]} ${nebulaNouns[nounIdx]}`
+}
+
+export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
+    const seed = Checksum256.from(gameSeed)
+    const locationType = getLocationType(seed, location)
+    if (locationType === LocationType.EMPTY) {
+        throw new Error("System doesn't exist at location")
+    }
+    const seedStr = `${location.x}-${location.y}-${locationType}-name`
+    const hashResult = hash512(seed, seedStr)
+    switch (locationType) {
+        case LocationType.PLANET:
+            return generatePlanetName(hashResult)
+        case LocationType.ASTEROID:
+            return generateAsteroidName(hashResult)
+        case LocationType.NEBULA:
+            return generateNebulaName(hashResult)
+        default:
+            return generatePlanetName(hashResult)
+    }
+}
+
+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(
+        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 {
+    const staticProps = deriveLocationStatic(gameSeed, coordinates)
+    return ServerContract.Types.location_derived.from({
+        static_props: staticProps,
+        epoch_props: deriveLocationEpoch(epochSeed, coordinates),
+        size: deriveLocationSize(staticProps),
+    })
+}

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/market.ts

@@ -1,214 +0,0 @@
-import {Coordinates, GoodPrice} from './types'
-import {getGood, getGoods} from './goods'
-import {Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
-import {roll} from './rolls'
-import {ServerContract} from './contracts'
-
-export enum Rarities {
-    legendary = 'LEGENDARY',
-    epic = 'EPIC',
-    rare = 'RARE',
-    uncommon = 'UNCOMMON',
-    common = 'COMMON',
-    trash = 'TRASH',
-}
-
-export interface Rarity {
-    rarity: Rarities // The rarity description of this price
-    minMultiplier: number // The minimum multiplier for this rarity
-    maxMultiplier: number // The maximum multiplier for this rarity
-}
-
-export function generateLocationSeed(
-    epochSeed: Checksum256Type,
-    location: Coordinates,
-    entitySalt: string
-) {
-    return `${epochSeed}${location.x}${location.y}${entitySalt}`
-}
-
-export function getRarity(
-    gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type,
-    location: Coordinates,
-    good_id: UInt16Type
-): Rarity {
-    const seed = `${epochSeed}${location.x}${location.y}${good_id}rarity`
-    const rarityRoll = roll(gameSeed, seed)
-
-    if (rarityRoll < 13) {
-        // (Orange) ~0.02% chance = incredibly high value
-        return {
-            rarity: Rarities.legendary,
-            minMultiplier: 2.25,
-            maxMultiplier: 3.0,
-        }
-    } else if (rarityRoll < 176) {
-        // (Purple) ~0.25% chance = super high value
-        return {
-            rarity: Rarities.epic,
-            minMultiplier: 1.75,
-            maxMultiplier: 2.25,
-        }
-    } else if (rarityRoll < 996) {
-        // (Blue) ~1.25% chance = very high value
-        return {
-            rarity: Rarities.rare,
-            minMultiplier: 1.4,
-            maxMultiplier: 1.75,
-        }
-    } else if (rarityRoll < 2966) {
-        // (Green) ~3.00% chance = high value
-        return {
-            rarity: Rarities.uncommon,
-            minMultiplier: 1.225,
-            maxMultiplier: 1.4,
-        }
-    } else if (rarityRoll < 19568) {
-        // (White) ~25.33% chance = slightly higher value
-        return {
-            rarity: Rarities.common,
-            minMultiplier: 1.07,
-            maxMultiplier: 1.225,
-        }
-    } else if (rarityRoll < 45988) {
-        // ~40.30% chance = no value change
-        return {
-            rarity: Rarities.trash,
-            minMultiplier: 1,
-            maxMultiplier: 1.07,
-        } // Product is not available
-    } else if (rarityRoll < 62508) {
-        // (White) ~25.33% chance = slightly lower value
-        return {
-            rarity: Rarities.common,
-            minMultiplier: 0.925,
-            maxMultiplier: 1,
-        }
-    } else if (rarityRoll < 64518) {
-        // (Green) ~3.00% chance = low value
-        return {
-            rarity: Rarities.uncommon,
-            minMultiplier: 0.77,
-            maxMultiplier: 0.925,
-        }
-    } else if (rarityRoll < 65437) {
-        // (Blue) ~1.25% chance = very low value
-        return {
-            rarity: Rarities.rare,
-            minMultiplier: 0.595,
-            maxMultiplier: 0.77,
-        }
-    } else if (rarityRoll < 65523) {
-        // (Purple) ~0.25% chance = super low value
-        return {
-            rarity: Rarities.epic,
-            minMultiplier: 0.41,
-            maxMultiplier: 0.595,
-        }
-    } else {
-        // (Orange) ~0.02% chance = incredibly low value
-        return {
-            rarity: Rarities.legendary,
-            minMultiplier: 0.285,
-            maxMultiplier: 0.41,
-        }
-    }
-}
-
-export function getRarityMultiplier(
-    gameSeed: Checksum256Type,
-    epochSeed: Checksum256Type,
-    location: Coordinates,
-    good_id: UInt16Type
-): number {
-    const rarity = getRarity(gameSeed, epochSeed, location, good_id)
-    const range = rarity.maxMultiplier - rarity.minMultiplier
-    const seed = `${epochSeed}${location.x}${location.y}${good_id}raritymultiplier`
-    const r = roll(gameSeed, seed)
-    return rarity.minMultiplier + (r / 65535) * range
-}
-
-export function getLocationMultiplier(
-    gameSeed: Checksum256Type,
-    location: Coordinates,
-    good_id: UInt16Type
-): number {
-    const seed = `${location.x}${location.y}${good_id}locationmultiplier`
-    const r = roll(gameSeed, seed)
-    if (r < 13) {
-        return 0.75
-    } else if (r < 176) {
-        return 0.8
-    } else if (r < 996) {
-        return 0.85
-    } else if (r < 2966) {
-        return 0.9
-    } else if (r < 19568) {
-        return 0.95
-    } else if (r < 45988) {
-        return 1
-    } else if (r < 62508) {
-        return 1.05
-    } else if (r < 64518) {
-        return 1.1
-    } else if (r < 65437) {
-        return 1.15
-    } else if (r < 65523) {
-        return 1.2
-    } else {
-        return 1.25
-    }
-}
-
-export function getSupply(
-    gameSeed: Checksum256Type,
-    state: ServerContract.Types.state_row,
-    location: Coordinates,
-    good_id: UInt16Type
-): number {
-    const seed = `${state.seed}${location.x}${location.y}${good_id}supply`
-    const r = roll(gameSeed, seed)
-    const percent = r / 65535
-    const epoch = 1 + Number(state.epoch) / 90
-    const ship = Math.pow(Number(state.ships), 1 / 3)
-    return UInt64.from((128 / good_id) * percent * ship * epoch).toNumber()
-}
-
-export function marketprice(
-    location: ServerContract.ActionParams.Type.coordinates,
-    good_id: UInt16Type,
-    gameSeed: Checksum256Type,
-    state: ServerContract.Types.state_row
-): GoodPrice {
-    const good = getGood(good_id)
-    let price = Number(good.base_price)
-
-    // Rarity multiplier of the deal (changes with epoch)
-    // Large impact range on price, from 0.285x to 3.0x
-    const rarityMultiplier = getRarityMultiplier(gameSeed, state.seed, location, good_id)
-    price *= rarityMultiplier
-
-    // Location multiplier of the deal (static, based on game seed)
-    // Small impact range on price, from 1.0x to 1.5x
-    const locationMultiplier = getLocationMultiplier(gameSeed, location, good_id)
-    price *= locationMultiplier
-
-    // Determine the current supply of the good at the location
-    const supply = getSupply(gameSeed, state, location, good_id)
-
-    return GoodPrice.from({
-        id: good_id,
-        good,
-        price: UInt64.from(price),
-        supply: UInt64.from(supply),
-    })
-}
-
-export function marketprices(
-    location: ServerContract.ActionParams.Type.coordinates,
-    gameSeed: Checksum256Type,
-    state: ServerContract.Types.state_row
-): GoodPrice[] {
-    return getGoods().map((good) => marketprice(location, good.id, gameSeed, state))
-}

package/src/rolls.ts

@@ -1,8 +0,0 @@
-import {Checksum256Type} from '@wharfkit/antelope'
-import {hash512} from './hash'
-
-export function roll(game_seed: Checksum256Type, roll_seed: string): number {
-    const hash = hash512(game_seed, roll_seed)
-    // Combine the first two bytes to form a uint16_t value
-    return (hash.array[0] << 8) | hash.array[1]
-}