@shipload/sdk 0.7.1 → 2.0.0-rc10

package/src/managers/entities.ts

@@ -0,0 +1,103 @@
+import {Name, NameType, UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {Ship} from '../entities/ship'
+import {Warehouse} from '../entities/warehouse'
+import {Container} from '../entities/container'
+import {ServerContract} from '../contracts'
+
+export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
+
+export class EntitiesManager extends BaseManager {
+    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container> {
+        const result = await this.server.readonly('getentity', {
+            entity_type: Name.from(type),
+            entity_id: id,
+        })
+        const entityInfo = result as ServerContract.Types.entity_info
+        return this.wrapEntity(entityInfo)
+    }
+
+    async getEntities(
+        owner: NameType | ServerContract.Types.player_row,
+        type?: EntityType
+    ): Promise<(Ship | Warehouse | Container)[]> {
+        const ownerName = this.resolveOwner(owner)
+        const result = await this.server.readonly('getentities', {
+            owner: ownerName,
+            entity_type: type ? Name.from(type) : null,
+        })
+        const entities = result as ServerContract.Types.entity_info[]
+        return entities.map((entity) => this.wrapEntity(entity))
+    }
+
+    async getSummaries(
+        owner: NameType | ServerContract.Types.player_row,
+        type?: EntityType
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        const ownerName = this.resolveOwner(owner)
+        const result = await this.server.readonly('getsummaries', {
+            owner: ownerName,
+            entity_type: type ? Name.from(type) : null,
+        })
+        return result as ServerContract.Types.entity_summary[]
+    }
+
+    async getShip(id: UInt64Type): Promise<Ship> {
+        return (await this.getEntity('ship', id)) as Ship
+    }
+
+    async getWarehouse(id: UInt64Type): Promise<Warehouse> {
+        return (await this.getEntity('warehouse', id)) as Warehouse
+    }
+
+    async getContainer(id: UInt64Type): Promise<Container> {
+        return (await this.getEntity('container', id)) as Container
+    }
+
+    async getShips(owner: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
+        return (await this.getEntities(owner, 'ship')) as Ship[]
+    }
+
+    async getWarehouses(owner: NameType | ServerContract.Types.player_row): Promise<Warehouse[]> {
+        return (await this.getEntities(owner, 'warehouse')) as Warehouse[]
+    }
+
+    async getContainers(owner: NameType | ServerContract.Types.player_row): Promise<Container[]> {
+        return (await this.getEntities(owner, 'container')) as Container[]
+    }
+
+    async getShipSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'ship')
+    }
+
+    async getWarehouseSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'warehouse')
+    }
+
+    async getContainerSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'container')
+    }
+
+    private wrapEntity(entity: ServerContract.Types.entity_info): Ship | Warehouse | Container {
+        if (entity.type.equals('ship')) {
+            return new Ship(entity)
+        } else if (entity.type.equals('warehouse')) {
+            return new Warehouse(entity)
+        } else {
+            return new Container(entity)
+        }
+    }
+
+    private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
+        if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
+            return owner.owner
+        }
+        return Name.from(owner)
+    }
+}

package/src/managers/epochs.ts

@@ -0,0 +1,47 @@
+import {UInt64, UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
+
+export class EpochsManager extends BaseManager {
+    async getCurrentHeight(): Promise<UInt64> {
+        const game = await this.getGame()
+        return getCurrentEpoch(game)
+    }
+
+    async getCurrent(): Promise<EpochInfo> {
+        const game = await this.getGame()
+        const epoch = await this.getCurrentHeight()
+        return getEpochInfo(game, epoch)
+    }
+
+    async getByHeight(height: UInt64Type): Promise<EpochInfo> {
+        const game = await this.getGame()
+        return getEpochInfo(game, UInt64.from(height))
+    }
+
+    async getTimeRemaining(): Promise<number> {
+        const epochInfo = await this.getCurrent()
+        const now = Date.now()
+        const endTime = epochInfo.end.getTime()
+        return Math.max(0, endTime - now)
+    }
+
+    async getProgress(): Promise<number> {
+        const epochInfo = await this.getCurrent()
+        const now = Date.now()
+        const startTime = epochInfo.start.getTime()
+        const endTime = epochInfo.end.getTime()
+        const duration = endTime - startTime
+        const elapsed = now - startTime
+
+        if (elapsed <= 0) return 0
+        if (elapsed >= duration) return 1
+
+        return elapsed / duration
+    }
+
+    async fitsInCurrentEpoch(durationMs: number): Promise<boolean> {
+        const remaining = await this.getTimeRemaining()
+        return durationMs <= remaining
+    }
+}

package/src/managers/index.ts

@@ -0,0 +1,8 @@
+export {GameContext} from './context'
+export {BaseManager} from './base'
+export {EntitiesManager} from './entities'
+export type {EntityType} from './entities'
+export {PlayersManager} from './players'
+export {LocationsManager} from './locations'
+export {EpochsManager} from './epochs'
+export {ActionsManager} from './actions'

package/src/managers/locations.ts

@@ -0,0 +1,39 @@
+import {UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {CoordinatesType, coordsToLocationId, Distance} from '../types'
+import {hasSystem} from '../utils/system'
+import {findNearbyPlanets} from '../travel/travel'
+import {ServerContract} from '../contracts'
+
+export class LocationsManager extends BaseManager {
+    async hasSystem(location: CoordinatesType): Promise<boolean> {
+        const game = await this.getGame()
+        return hasSystem(game.config.seed, location)
+    }
+
+    async findNearbyPlanets(
+        origin: CoordinatesType,
+        maxDistance: UInt16Type = 20
+    ): Promise<Distance[]> {
+        const game = await this.getGame()
+        return findNearbyPlanets(game.config.seed, origin, maxDistance)
+    }
+
+    async getLocationEntity(
+        id: UInt64Type
+    ): Promise<ServerContract.Types.location_row | undefined> {
+        const row = await this.server.table('location').get(UInt64.from(id))
+        return row ?? undefined
+    }
+
+    async getLocationEntityAt(
+        coords: CoordinatesType
+    ): Promise<ServerContract.Types.location_row | undefined> {
+        const id = coordsToLocationId(coords)
+        return this.getLocationEntity(id)
+    }
+
+    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
+        return this.server.table('location').all()
+    }
+}

package/src/managers/players.ts

@@ -0,0 +1,13 @@
+import {Name, NameType} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {Player} from '../entities/player'
+
+export class PlayersManager extends BaseManager {
+    async getPlayer(account: NameType): Promise<Player | undefined> {
+        const playerRow = await this.server.table('player').get(Name.from(account))
+        if (!playerRow) {
+            return undefined
+        }
+        return new Player(playerRow)
+    }
+}

package/src/market/items.ts

@@ -0,0 +1,30 @@
+import {UInt16, UInt16Type} from '@wharfkit/antelope'
+import {Item} from '../types'
+import itemsData from '../data/items.json'
+
+const items: Item[] = itemsData.map((g) =>
+    Item.from({
+        id: g.id,
+        name: g.name,
+        description: g.description,
+        mass: g.mass,
+        category: g.category,
+        tier: g.tier,
+        color: g.color,
+    })
+)
+
+export const itemIds = items.map((i) => i.id)
+
+export function getItem(itemId: UInt16Type): Item {
+    const id = UInt16.from(itemId)
+    const item = items.find((i) => i.id.equals(id))
+    if (!item) {
+        throw new Error(`Item with id ${id} not found`)
+    }
+    return item
+}
+
+export function getItems(): Item[] {
+    return items
+}

package/src/nft/description.ts

@@ -0,0 +1,175 @@
+import {
+    getModuleCapabilityType,
+    ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_LOADER_T1,
+    ITEM_MANUFACTURING_T1,
+    ITEM_STORAGE_T1,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_EXTRACTOR,
+    MODULE_GENERATOR,
+    MODULE_LOADER,
+    MODULE_STORAGE,
+} from '../capabilities/modules'
+import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/recipes'
+import {decodeStat} from '../derivation/crafting'
+
+function idiv(a: number, b: number): number {
+    return Math.floor(a / b)
+}
+
+export function computeBaseHullmass(seed: bigint): number {
+    const density = decodeStat(seed, 1)
+    return 25000 + 75 * density
+}
+
+export function computeBaseCapacityShip(seed: bigint): number {
+    const s = decodeStat(seed, 0) + decodeStat(seed, 2) + decodeStat(seed, 3)
+    return Math.floor(1_000_000 * Math.pow(10, s / 2997))
+}
+
+export function computeBaseCapacityWarehouse(seed: bigint): number {
+    const s = decodeStat(seed, 0) + decodeStat(seed, 2) + decodeStat(seed, 3)
+    return Math.floor(20_000_000 * Math.pow(10, s / 2997))
+}
+
+export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
+export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
+export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
+export const computeGeneratorRech = (clr: number): number => 5 + idiv(clr * 15, 1000)
+export const computeExtractorRate = (str: number): number => 200 + str
+export const computeExtractorDrain = (con: number): number => Math.max(10, 50 - idiv(con, 20))
+export const computeExtractorDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+export const computeExtractorDrill = (ref: number): number => 100 + idiv(ref * 4, 5)
+export const computeLoaderMass = (duc: number): number => Math.max(200, 2000 - duc * 2)
+export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
+export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
+export const computeCrafterDrain = (clr: number): number => Math.max(5, 30 - idiv(clr, 33))
+
+export function entityDisplayName(itemId: number): string {
+    switch (itemId) {
+        case ITEM_SHIP_T1_PACKED:
+            return 'Ship T1'
+        case ITEM_WAREHOUSE_T1_PACKED:
+            return 'Warehouse T1'
+        case ITEM_CONTAINER_T1_PACKED:
+            return 'Container T1'
+        case ITEM_CONTAINER_T2_PACKED:
+            return 'Container T2'
+        default:
+            return 'Entity'
+    }
+}
+
+export function moduleDisplayName(itemId: number): string {
+    switch (itemId) {
+        case ITEM_ENGINE_T1:
+            return 'Engine T1'
+        case ITEM_GENERATOR_T1:
+            return 'Generator T1'
+        case ITEM_EXTRACTOR_T1:
+            return 'Extractor T1'
+        case ITEM_LOADER_T1:
+            return 'Loader T1'
+        case ITEM_MANUFACTURING_T1:
+            return 'Manufacturing T1'
+        case ITEM_STORAGE_T1:
+            return 'Storage T1'
+        default:
+            return 'Module'
+    }
+}
+
+export function formatModuleLine(slot: number, itemId: number, seed: bigint): string {
+    let out = `Slot ${slot} - `
+    if (itemId === 0) {
+        out += '(empty)'
+        return out
+    }
+
+    out += moduleDisplayName(itemId)
+    const subtype = getModuleCapabilityType(itemId)
+
+    switch (subtype) {
+        case MODULE_ENGINE: {
+            const vol = decodeStat(seed, 0)
+            const thm = decodeStat(seed, 1)
+            out += `  Thrust ${computeEngineThrust(vol)}  Drain ${computeEngineDrain(thm)}`
+            break
+        }
+        case MODULE_GENERATOR: {
+            const res = decodeStat(seed, 0)
+            const clr = decodeStat(seed, 1)
+            out += `  Capacity ${computeGeneratorCap(res)}  Recharge ${computeGeneratorRech(clr)}`
+            break
+        }
+        case MODULE_EXTRACTOR: {
+            const str = decodeStat(seed, 0)
+            const tol = decodeStat(seed, 1)
+            const con = decodeStat(seed, 3)
+            const ref = decodeStat(seed, 4)
+            out += `  Rate ${computeExtractorRate(str)}  Depth ${computeExtractorDepth(
+                tol
+            )}  Drill ${computeExtractorDrill(ref)}  Drain ${computeExtractorDrain(con)}`
+            break
+        }
+        case MODULE_LOADER: {
+            const duc = decodeStat(seed, 0)
+            const pla = decodeStat(seed, 1)
+            out += `  Mass ${computeLoaderMass(duc)}  Thrust ${computeLoaderThrust(pla)}`
+            break
+        }
+        case MODULE_CRAFTER: {
+            const rea = decodeStat(seed, 0)
+            const clr = decodeStat(seed, 1)
+            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(clr)}`
+            break
+        }
+        case MODULE_STORAGE: {
+            const str = decodeStat(seed, 0)
+            const duc = decodeStat(seed, 1)
+            const pur = decodeStat(seed, 2)
+            const sum = str + duc + pur
+            const pct = 10 + idiv(sum * 10, 2997)
+            out += `  +${pct}% capacity`
+            break
+        }
+    }
+    return out
+}
+
+export function buildEntityDescription(
+    itemId: number,
+    hullSeed: bigint,
+    moduleItems: number[],
+    moduleSeeds: bigint[]
+): string {
+    const hullMass = computeBaseHullmass(hullSeed)
+    let baseCapacity = 0
+    if (itemId === ITEM_SHIP_T1_PACKED) {
+        baseCapacity = computeBaseCapacityShip(hullSeed)
+    } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
+        baseCapacity = computeBaseCapacityWarehouse(hullSeed)
+    }
+
+    let out = entityDisplayName(itemId)
+    out += ` - Hull ${hullMass} mass`
+    if (baseCapacity > 0) {
+        out += ` * ${baseCapacity} capacity`
+    }
+    out += '\n\n'
+
+    for (let i = 0; i < moduleItems.length; i++) {
+        out += formatModuleLine(i, moduleItems[i], moduleSeeds[i] ?? 0n)
+        out += '\n'
+    }
+
+    return out
+}

package/src/nft/deserializers.ts

@@ -0,0 +1,81 @@
+import {getEntitySlotLayout} from '../data/recipes'
+import {
+    ITEM_TYPE_COMPONENT,
+    ITEM_TYPE_ENTITY,
+    ITEM_TYPE_MODULE,
+    ITEM_TYPE_RESOURCE,
+    itemTypeCode,
+} from '../data/tiers'
+
+export interface NFTInstalledModule {
+    item_id: number
+    seed: string
+}
+
+export interface NFTModuleSlot {
+    type: number
+    installed?: NFTInstalledModule
+}
+
+export interface NFTCargoItem {
+    item_id: number
+    quantity: number
+    seed: string
+    modules?: NFTModuleSlot[]
+}
+
+export interface NFTCommonBase {
+    quantity: number
+    seed: string
+    origin_x: string
+    origin_y: string
+}
+
+export function readCommonBase(data: Record<string, any>): NFTCommonBase {
+    return {
+        quantity: Number(data.quantity),
+        seed: String(data.seed),
+        origin_x: String(data.origin_x),
+        origin_y: String(data.origin_y),
+    }
+}
+
+export function deserializeScalar(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const base = readCommonBase(data)
+    return {item_id: itemId, quantity: base.quantity, seed: base.seed}
+}
+
+export const deserializeResource = deserializeScalar
+export const deserializeComponent = deserializeScalar
+export const deserializeModule = deserializeScalar
+
+export function deserializeEntity(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const base = readCommonBase(data)
+    const moduleItems: number[] = (data.module_items ?? []).map((v: any) => Number(v))
+    const moduleSeeds: string[] = (data.module_seeds ?? []).map((v: any) => String(v))
+    const layout = getEntitySlotLayout(itemId)
+
+    const modules: NFTModuleSlot[] = layout.map((slot, i) => ({
+        type: slot.type,
+        installed:
+            moduleItems[i] && moduleItems[i] !== 0
+                ? {item_id: moduleItems[i], seed: moduleSeeds[i]}
+                : undefined,
+    }))
+
+    return {item_id: itemId, quantity: base.quantity, seed: base.seed, modules}
+}
+
+export function deserializeAsset(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const type = itemTypeCode(itemId)
+    switch (type) {
+        case ITEM_TYPE_RESOURCE:
+        case ITEM_TYPE_COMPONENT:
+        case ITEM_TYPE_MODULE:
+            return deserializeScalar(data, itemId)
+        case ITEM_TYPE_ENTITY:
+            return deserializeEntity(data, itemId)
+        default:
+            throw new Error(`unknown item type ${type} for item ${itemId}`)
+    }
+}

package/src/nft/index.ts

@@ -0,0 +1,2 @@
+export * from './deserializers'
+export * from './description'