@shipload/sdk 2.0.0-rc1 → 2.0.0-rc11

package/src/types/entity-traits.ts

@@ -0,0 +1,69 @@
+import {Name} from '@wharfkit/antelope'
+
+export const ENTITY_SHIP = Name.from('ship')
+export const ENTITY_WAREHOUSE = Name.from('warehouse')
+export const ENTITY_CONTAINER = Name.from('container')
+
+export type EntityTypeName = 'ship' | 'warehouse' | 'container'
+
+export interface EntityTraits {
+    typeName: Name
+    isMovable: boolean
+    hasEnergy: boolean
+    hasLoaders: boolean
+    notFoundError: string
+}
+
+export const shipTraits: EntityTraits = {
+    typeName: ENTITY_SHIP,
+    isMovable: true,
+    hasEnergy: true,
+    hasLoaders: true,
+
+    notFoundError: 'ship not found',
+}
+
+export const warehouseTraits: EntityTraits = {
+    typeName: ENTITY_WAREHOUSE,
+    isMovable: false,
+    hasEnergy: false,
+    hasLoaders: true,
+
+    notFoundError: 'warehouse not found',
+}
+
+export const containerTraits: EntityTraits = {
+    typeName: ENTITY_CONTAINER,
+    isMovable: true,
+    hasEnergy: false,
+    hasLoaders: false,
+
+    notFoundError: 'container not found',
+}
+
+export function getEntityTraits(entityType: Name | EntityTypeName): EntityTraits {
+    const typeName = typeof entityType === 'string' ? entityType : entityType.toString()
+
+    switch (typeName) {
+        case 'ship':
+            return shipTraits
+        case 'warehouse':
+            return warehouseTraits
+        case 'container':
+            return containerTraits
+        default:
+            throw new Error(`Unknown entity type: ${typeName}`)
+    }
+}
+
+export function isShip(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_SHIP) ?? false
+}
+
+export function isWarehouse(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_WAREHOUSE) ?? false
+}
+
+export function isContainer(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_CONTAINER) ?? false
+}

package/src/types/entity.ts

@@ -0,0 +1,39 @@
+import {Name, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates} from '../types'
+import {
+    EnergyCapability,
+    LoaderCapability,
+    MassCapability,
+    MovementCapability,
+    ScheduleCapability,
+    StorageCapability,
+} from './capabilities'
+
+export interface Entity {
+    id: UInt64
+    type: Name
+    owner: Name
+    entity_name: string
+    location: Coordinates | ServerContract.Types.coordinates
+}
+
+export type ShipEntity = Entity &
+    Partial<MovementCapability> &
+    Partial<EnergyCapability> &
+    StorageCapability &
+    Partial<LoaderCapability> &
+    MassCapability &
+    ScheduleCapability & {
+        gatherer?: ServerContract.Types.gatherer_stats
+    }
+
+export type WarehouseEntity = Entity &
+    StorageCapability &
+    Partial<LoaderCapability> &
+    MassCapability &
+    ScheduleCapability
+
+export type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability
+
+export type AnyEntity = ShipEntity | WarehouseEntity | ContainerEntity

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './capabilities'
+export * from './entity'
+export * from './entity-traits'

package/src/types.ts

@@ -1,43 +1,78 @@
-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 CRAFT_ENERGY_DIVISOR = 150000
+
+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 INITIAL_SHIP_MASS = 500000
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
+export const BASE_ORBITAL_MASS = 100000
+
 export interface ShipLike {
-    location: ServerContract.Types.coordinates
-    mass: UInt32
-    energy: UInt16
-    engines: ServerContract.Types.movement_stats
-    generator: ServerContract.Types.energy_stats
-    loaders: ServerContract.Types.loader_stats
-    capacity: UInt32
+    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 {
-    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,
+    GATHER = 5,
+    WARP = 6,
+    CRAFT = 7,
+    DEPLOY = 8,
+    DEPLOY_SHIP = 9,
+}
+
+export enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3,
 }
 
 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
+    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]
@@ -56,6 +91,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 +112,11 @@ 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')
@@ -73,19 +124,11 @@ export class Good extends Struct {
     @Struct.field('string')
     description!: string
     @Struct.field(UInt32)
-    base_price!: UInt32
-    @Struct.field(UInt32)
     mass!: UInt32
-}
-
-@Struct.type('GoodPrice')
-export class GoodPrice extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field(Good)
-    good!: Good
-    @Struct.field(UInt32)
-    price!: UInt32
-    @Struct.field(UInt16)
-    supply!: UInt16
+    @Struct.field('string')
+    category!: ResourceCategory
+    @Struct.field('string')
+    tier!: ResourceTier
+    @Struct.field('string')
+    color!: string
 }

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,27 +1,164 @@
-import {Checksum256, Checksum256Type} from '@wharfkit/antelope'
+import {Checksum256, Checksum256Type, Checksum512, UInt8} from '@wharfkit/antelope'
 import {hash512} from './hash'
-import {CoordinatesType} from '../types'
+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'
 
-export function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string {
+const LOCATION_EXISTS_THRESHOLD = 0x10
+const LOCATION_ACTIVE_THRESHOLD = 0x80
+
+export function getLocationType(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): LocationType {
     const seed = Checksum256.from(gameSeed)
-    if (!hasSystem(seed, location)) {
-        throw new Error("System doesn't exist at location")
+    const str = ['system', coordinates.x, coordinates.y].join('-')
+    const hashResult = hash512(seed, str)
+
+    if (hashResult.array[0] >= LOCATION_EXISTS_THRESHOLD) {
+        return LocationType.EMPTY
     }
-    const seedStr = `${location.x}${location.y}systemName`
-    const hashResult = hash512(seed, seedStr)
-    const syllableCount = 1 + (hashResult.array[0] % 3)
+
+    if (hashResult.array[1] < 96) {
+        return LocationType.PLANET
+    } else if (hashResult.array[1] < 176) {
+        return LocationType.ASTEROID
+    }
+    return LocationType.NEBULA
+}
+
+export function isGatherableLocation(locationType: LocationType): boolean {
+    return locationType !== LocationType.EMPTY
+}
+
+export function getLocationTypeName(type: LocationType): string {
+    switch (type) {
+        case LocationType.EMPTY: return 'Empty'
+        case LocationType.PLANET: return 'Planet'
+        case LocationType.ASTEROID: return 'Asteroid'
+        case LocationType.NEBULA: return 'Nebula'
+    }
+}
+
+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 = hashResult.array[i] % syllables.length
+        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 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 {
+    const staticProps = deriveLocationStatic(gameSeed, coordinates)
+    return ServerContract.Types.location_derived.from({
+        static_props: staticProps,
+        epoch_props: deriveLocationEpoch(epochSeed, coordinates),
+        size: deriveLocationSize(staticProps),
+    })
 }

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/managers/trades.ts

@@ -1,119 +0,0 @@
-import {UInt64} from '@wharfkit/antelope'
-import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
-import {Deal, findDealsForShip, FindDealsOptions} from '../trading/deal'
-import {
-    analyzeCollectOptions,
-    CollectAnalysis,
-    CollectAnalysisCallbacks,
-    CollectAnalysisOptions,
-} from '../trading/collect'
-import {Coordinates, GoodPrice} from '../types'
-import {Location, toLocation} from '../entities/location'
-import {findNearbyPlanets} from '../travel/travel'
-import {getCurrentEpoch} from '../scheduling/epoch'
-
-export class TradesManager extends BaseManager {
-    private priceCache = new Map<string, GoodPrice[]>()
-    private priceCacheEpoch: UInt64 | undefined
-
-    private makePriceCacheKey(location: Coordinates): string {
-        return `${location.x},${location.y}`
-    }
-
-    private async createCallbacks(): Promise<CollectAnalysisCallbacks> {
-        const game = await this.getGame()
-        const serverState = await this.getState()
-        const currentEpoch = getCurrentEpoch(game)
-
-        if (!this.priceCacheEpoch || !this.priceCacheEpoch.equals(currentEpoch)) {
-            this.priceCache.clear()
-            this.priceCacheEpoch = currentEpoch
-        }
-
-        const getNearbyLocations = async (
-            origin: Coordinates,
-            maxDistance: number
-        ): Promise<Location[]> => {
-            const nearby = findNearbyPlanets(game.config.seed, origin, maxDistance)
-            return nearby.map((d) => toLocation(d.destination))
-        }
-
-        const getMarketPrices = async (location: Coordinates): Promise<GoodPrice[]> => {
-            const cacheKey = this.makePriceCacheKey(location)
-            const cached = this.priceCache.get(cacheKey)
-            if (cached) {
-                return cached
-            }
-
-            const locationWithSupply = await this.context.locations.getLocationComplete(location)
-            const prices = locationWithSupply.marketPrices || []
-
-            const result = prices.map((price) => {
-                const actualSupply = locationWithSupply.getSupply(price.id)
-
-                if (actualSupply !== undefined) {
-                    return GoodPrice.from({
-                        id: price.id,
-                        good: price.good,
-                        price: price.price,
-                        supply: actualSupply,
-                    })
-                }
-                return price
-            })
-
-            this.priceCache.set(cacheKey, result)
-            return result
-        }
-
-        const getGameSeed = () => game.config.seed
-        const getState = () => serverState
-
-        return {getNearbyLocations, getMarketPrices, getGameSeed, getState}
-    }
-
-    clearPriceCache(): void {
-        this.priceCache.clear()
-        this.priceCacheEpoch = undefined
-    }
-
-    async findDeals(
-        ship: Ship,
-        originLocation?: Coordinates,
-        options: FindDealsOptions = {}
-    ): Promise<Deal[]> {
-        const origin = originLocation || ship.currentLocation
-        const callbacks = await this.createCallbacks()
-
-        const deals = await findDealsForShip(
-            ship,
-            origin,
-            callbacks.getNearbyLocations,
-            callbacks.getMarketPrices,
-            options
-        )
-
-        return deals
-    }
-
-    async findBestDeal(
-        ship: Ship,
-        originLocation?: Coordinates,
-        options: FindDealsOptions = {}
-    ): Promise<Deal | undefined> {
-        const deals = await this.findDeals(ship, originLocation, {...options, maxDeals: 1})
-        return deals[0]
-    }
-
-    async getCollectOptions(
-        ship: Ship,
-        arrivedAt?: Coordinates,
-        options: CollectAnalysisOptions = {}
-    ): Promise<CollectAnalysis> {
-        const location = arrivedAt || ship.currentLocation
-        const callbacks = await this.createCallbacks()
-
-        return analyzeCollectOptions(ship, location, callbacks, options)
-    }
-}

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))
-}