@shipload/sdk 2.0.0-rc1 → 2.0.0-rc11

package/src/managers/actions.ts

@@ -1,19 +1,11 @@
 import {Action, Int64, Name, NameType, UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
 import {CoordinatesType, EntityType, EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
 
-interface SellableCargo {
-    good_id: {toNumber(): number} | number
-    quantity: {toNumber(): number} | number
-    hasCargo: boolean
-}
-
-export type CargoItemInput = {
-    goodId: UInt64Type
-    quantity: UInt64Type
-    unitCost?: UInt64Type
+export type EntityRefInput = {
+    entityType: EntityTypeName
+    entityId: UInt64Type
 }
 
 export class ActionsManager extends BaseManager {
@@ -30,6 +22,24 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    grouptravel(entities: EntityRefInput[], destination: CoordinatesType, recharge = true): Action {
+        const entityRefs = entities.map((e) =>
+            ServerContract.Types.entity_ref.from({
+                entity_type: e.entityType,
+                entity_id: UInt64.from(e.entityId),
+            })
+        )
+        const x = Int64.from(destination.x)
+        const y = Int64.from(destination.y)
+
+        return this.server.action('grouptravel', {
+            entities: entityRefs,
+            x,
+            y,
+            recharge,
+        })
+    }
+
     resolve(entityId: UInt64Type, entityType: EntityTypeName = EntityType.SHIP): Action {
         return this.server.action('resolve', {
             entity_type: entityType,
@@ -61,108 +71,130 @@ export class ActionsManager extends BaseManager {
         sourceId: UInt64Type,
         destType: EntityTypeName,
         destId: UInt64Type,
-        cargo: CargoItemInput[]
+        goodId: UInt64Type,
+        quantity: UInt64Type
     ): Action {
-        const cargoItems = cargo.map((c) =>
-            ServerContract.Types.cargo_item.from({
-                good_id: UInt16.from(c.goodId),
-                quantity: UInt32.from(c.quantity),
-                unit_cost: UInt64.from(c.unitCost || 0),
-            })
-        )
         return this.server.action('transfer', {
             source_type: sourceType,
             source_id: UInt64.from(sourceId),
             dest_type: destType,
             dest_id: UInt64.from(destId),
-            cargo: cargoItems,
+            item_id: UInt16.from(goodId),
+            quantity: UInt32.from(quantity),
         })
     }
 
-    buyGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action {
-        return this.server.action('buygoods', {
-            ship_id: UInt64.from(shipId),
-            good_id: UInt64.from(goodId),
-            quantity: UInt64.from(quantity),
+    foundCompany(account: NameType, name: string): Action {
+        return this.platform.action('foundcompany', {
+            account: Name.from(account),
+            name,
         })
     }
 
-    sellGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action {
-        return this.server.action('sellgoods', {
-            ship_id: UInt64.from(shipId),
-            good_id: UInt64.from(goodId),
-            quantity: UInt64.from(quantity),
+    join(account: NameType): Action {
+        return this.server.action('join', {
+            account: Name.from(account),
         })
     }
 
-    buyShip(account: NameType, name: string): Action {
-        return this.server.action('buyship', {
-            account: Name.from(account),
-            name,
+    gather(shipId: UInt64Type, stratum: number, quantity: number): Action {
+        return this.server.action('gather', {
+            entity_type: EntityType.SHIP,
+            id: UInt64.from(shipId),
+            stratum: UInt16.from(stratum),
+            quantity: UInt32.from(quantity),
         })
     }
 
-    buyWarehouse(account: NameType, shipId: UInt64Type, name: string): Action {
-        return this.server.action('buywarehouse', {
-            account: Name.from(account),
-            ship_id: UInt64.from(shipId),
-            name,
+    warp(shipId: UInt64Type, destination: CoordinatesType): Action {
+        const x = Int64.from(destination.x)
+        const y = Int64.from(destination.y)
+
+        return this.server.action('warp', {
+            entity_type: EntityType.SHIP,
+            id: UInt64.from(shipId),
+            x,
+            y,
         })
     }
 
-    takeLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('takeloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
+    craft(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        recipeId: number,
+        quantity: number,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
+        return this.server.action('craft', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            recipe_id: UInt16.from(recipeId),
+            quantity: UInt32.from(quantity),
+            inputs: cargoInputs,
         })
     }
 
-    payLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('payloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
+    blend(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
+        return this.server.action('blend', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            inputs: cargoInputs,
         })
     }
 
-    foundCompany(account: NameType, name: string): Action {
-        return this.platform.action('foundcompany', {
-            account: Name.from(account),
-            name,
+    deploy(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        packedItemId: number,
+        seed: bigint,
+        entityName: string
+    ): Action {
+        return this.server.action('deploy', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            packed_item_id: UInt16.from(packedItemId),
+            seed: UInt64.from(seed),
+            entity_name: entityName,
         })
     }
 
-    join(account: NameType): Action {
-        return this.server.action('join', {
-            account: Name.from(account),
+    addmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        moduleCargoId: UInt64Type,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): Action {
+        return this.server.action('addmodule', {
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            module_cargo_id: UInt64.from(moduleCargoId),
+            target_cargo_id: UInt64.from(targetCargoId),
         })
     }
 
-    joinGame(account: NameType, companyName: string): Action[] {
-        return [this.foundCompany(account, companyName), this.join(account)]
+    rmmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): Action {
+        return this.server.action('rmmodule', {
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            target_cargo_id: UInt64.from(targetCargoId),
+        })
     }
 
-    sellAllCargo(ship: Ship | UInt64Type, cargo?: SellableCargo[]): Action[] {
-        let shipCargo: SellableCargo[]
-
-        if (ship instanceof Ship) {
-            shipCargo = cargo || ship.inventory
-        } else {
-            if (!cargo) {
-                throw new Error('cargo parameter required when ship is a UInt64Type')
-            }
-            shipCargo = cargo
-        }
-
-        const shipId = ship instanceof Ship ? ship.id : UInt64.from(ship)
-
-        return shipCargo
-            .filter((c) => c.hasCargo)
-            .map((c) =>
-                this.server.action('sellgoods', {
-                    ship_id: shipId,
-                    good_id: c.good_id,
-                    quantity: c.quantity,
-                })
-            )
+    joinGame(account: NameType, companyName: string): Action[] {
+        return [this.foundCompany(account, companyName), this.join(account)]
     }
 }

package/src/managers/context.ts

@@ -6,7 +6,6 @@ import {GameState} from '../entities/gamestate'
 import {EntitiesManager} from './entities'
 import {PlayersManager} from './players'
 import {LocationsManager} from './locations'
-import {TradesManager} from './trades'
 import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
 
@@ -14,7 +13,6 @@ export class GameContext {
     private _entities?: EntitiesManager
     private _players?: PlayersManager
     private _locations?: LocationsManager
-    private _trades?: TradesManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
 
@@ -48,13 +46,6 @@ export class GameContext {
         return this._locations
     }
 
-    get trades(): TradesManager {
-        if (!this._trades) {
-            this._trades = new TradesManager(this)
-        }
-        return this._trades
-    }
-
     get epochs(): EpochsManager {
         if (!this._epochs) {
             this._epochs = new EpochsManager(this)

package/src/managers/entities.ts

@@ -2,12 +2,13 @@ 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'
+export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse> {
+    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,
@@ -19,7 +20,7 @@ export class EntitiesManager extends BaseManager {
     async getEntities(
         owner: NameType | ServerContract.Types.player_row,
         type?: EntityType
-    ): Promise<(Ship | Warehouse)[]> {
+    ): Promise<(Ship | Warehouse | Container)[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
@@ -49,6 +50,10 @@ export class EntitiesManager extends BaseManager {
         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[]
     }
@@ -57,6 +62,10 @@ export class EntitiesManager extends BaseManager {
         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[]> {
@@ -69,11 +78,19 @@ export class EntitiesManager extends BaseManager {
         return this.getSummaries(owner, 'warehouse')
     }
 
-    private wrapEntity(entity: ServerContract.Types.entity_info): Ship | 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 {
+        } else if (entity.type.equals('warehouse')) {
             return new Warehouse(entity)
+        } else {
+            return new Container(entity)
         }
     }
 

package/src/managers/index.ts

@@ -4,6 +4,5 @@ export {EntitiesManager} from './entities'
 export type {EntityType} from './entities'
 export {PlayersManager} from './players'
 export {LocationsManager} from './locations'
-export {TradesManager} from './trades'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'

package/src/managers/locations.ts

@@ -1,54 +1,11 @@
-import {Bytes, Checksum256, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {CoordinatesType, Distance, GoodPrice} from '../types'
-import {marketPrice, marketPrices} from '../market/market'
+import {CoordinatesType, coordsToLocationId, Distance} from '../types'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
-import {Location, toLocation} from '../entities/location'
+import {ServerContract} from '../contracts'
 
 export class LocationsManager extends BaseManager {
-    async getMarketPrice(location: CoordinatesType, goodId: number): Promise<GoodPrice> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketPrice(location, goodId, game.config.seed, state)
-    }
-
-    async getMarketPrices(location: CoordinatesType): Promise<GoodPrice[]> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketPrices(location, game.config.seed, state)
-    }
-
-    async getMarketPricesWithSupply(location: CoordinatesType): Promise<GoodPrice[]> {
-        const [game, state, locationRows] = await Promise.all([
-            this.getGame(),
-            this.getState(),
-            this.getLocation(location),
-        ])
-
-        const prices = marketPrices(location, game.config.seed, state)
-
-        const supplyMap = new Map<number, number>()
-        for (const row of locationRows) {
-            if (UInt64.from(row.epoch).equals(state.epoch)) {
-                supplyMap.set(Number(row.good_id), Number(row.supply))
-            }
-        }
-
-        return prices.map((price) => {
-            const actualSupply = supplyMap.get(Number(price.id))
-            if (actualSupply !== undefined) {
-                return GoodPrice.from({
-                    id: price.id,
-                    good: price.good,
-                    price: price.price,
-                    supply: UInt64.from(actualSupply),
-                })
-            }
-            return price
-        })
-    }
-
     async hasSystem(location: CoordinatesType): Promise<boolean> {
         const game = await this.getGame()
         return hasSystem(game.config.seed, location)
@@ -62,42 +19,21 @@ export class LocationsManager extends BaseManager {
         return findNearbyPlanets(game.config.seed, origin, maxDistance)
     }
 
-    async getLocation(location: CoordinatesType) {
-        const hash = Checksum256.hash(Bytes.from(`${location.x}-${location.y}`, 'utf8'))
-        return this.server.table('location').all({
-            index_position: 'secondary',
-            from: hash,
-            to: hash,
-        })
+    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 getLocationWithPrices(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const prices = await this.getMarketPrices(location.coordinates)
-        location.setMarketPrices(prices)
-        return location
+    async getLocationEntityAt(
+        coords: CoordinatesType
+    ): Promise<ServerContract.Types.location_row | undefined> {
+        const id = coordsToLocationId(coords)
+        return this.getLocationEntity(id)
     }
 
-    async getLocationWithSupply(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const [rows, state] = await Promise.all([
-            this.getLocation(location.coordinates),
-            this.getState(),
-        ])
-        location.setLocationRows(rows, state.epoch)
-        return location
-    }
-
-    async getLocationComplete(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const [prices, rows, state] = await Promise.all([
-            this.getMarketPrices(location.coordinates),
-            this.getLocation(location.coordinates),
-            this.getState(),
-        ])
-
-        location.setMarketPrices(prices)
-        location.setLocationRows(rows, state.epoch)
-        return location
+    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
+        return this.server.table('location').all()
     }
 }

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_GATHERER_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_LOADER_T1,
+    ITEM_MANUFACTURING_T1,
+    ITEM_STORAGE_T1,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_GATHERER,
+    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 computeGathererYield = (str: number): number => 200 + str
+export const computeGathererDrain = (con: number): number => Math.max(10, 50 - idiv(con, 20))
+export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+export const computeGathererSpeed = (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_GATHERER_T1:
+            return 'Gatherer 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_GATHERER: {
+            const str = decodeStat(seed, 0)
+            const tol = decodeStat(seed, 1)
+            const con = decodeStat(seed, 3)
+            const ref = decodeStat(seed, 4)
+            out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
+                tol
+            )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(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
+}