@shipload/sdk 2.0.0-rc5 → 2.0.0-rc7

package/src/managers/actions.ts

@@ -1,15 +1,8 @@
 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 {
-    item_id: {toNumber(): number} | number
-    quantity: {toNumber(): number} | number
-    hasCargo: boolean
-}
-
 export type EntityRefInput = {
     entityType: EntityTypeName
     entityId: UInt64Type
@@ -91,71 +84,6 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    buyItems(
-        entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
-        return this.server.action('buyitems', {
-            entity_type: entityType,
-            id: UInt64.from(entityId),
-            item_id: UInt16.from(goodId),
-            quantity: UInt32.from(quantity),
-        })
-    }
-
-    sellItems(
-        entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
-        return this.server.action('sellitems', {
-            entity_type: entityType,
-            id: UInt64.from(entityId),
-            item_id: UInt16.from(goodId),
-            quantity: UInt32.from(quantity),
-        })
-    }
-
-    buyShip(account: NameType, name: string): Action {
-        return this.server.action('buyship', {
-            account: Name.from(account),
-            name,
-        })
-    }
-
-    buyWarehouse(account: NameType, shipId: UInt64Type, name: string): Action {
-        return this.server.action('buywarehouse', {
-            account: Name.from(account),
-            ship_id: UInt64.from(shipId),
-            name,
-        })
-    }
-
-    buyContainer(account: NameType, shipId: UInt64Type, name: string): Action {
-        return this.server.action('buycontainer', {
-            account: Name.from(account),
-            ship_id: UInt64.from(shipId),
-            name,
-        })
-    }
-
-    takeLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('takeloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
-        })
-    }
-
-    payLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('payloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
-        })
-    }
-
     foundCompany(account: NameType, name: string): Action {
         return this.platform.action('foundcompany', {
             account: Name.from(account),
@@ -187,26 +115,87 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    joinGame(account: NameType, companyName: string): Action[] {
-        return [this.foundCompany(account, companyName), this.join(account)]
+    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,
+        })
+    }
+
+    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,
+        })
     }
 
-    sellAllCargo(ship: Ship | UInt64Type, cargo?: SellableCargo[]): Action[] {
-        let shipCargo: SellableCargo[]
+    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,
+        })
+    }
 
-        if (ship instanceof Ship) {
-            shipCargo = cargo || ship.inventory
-        } else {
-            if (!cargo) {
-                throw new Error('cargo parameter required when ship is a UInt64Type')
-            }
-            shipCargo = cargo
-        }
+    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),
+        })
+    }
 
-        const shipId = ship instanceof Ship ? ship.id : UInt64.from(ship)
+    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),
+        })
+    }
 
-        return shipCargo
-            .filter((c) => c.hasCargo)
-            .map((c) => this.sellItems(shipId, c.item_id, c.quantity, EntityType.SHIP))
+    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/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,55 +1,11 @@
-import {Bytes, Checksum256, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {CoordinatesType, coordsToLocationId, Distance, ItemPrice} 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<ItemPrice> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketPrice(location, goodId, game.config.seed, state)
-    }
-
-    async getMarketPrices(location: CoordinatesType): Promise<ItemPrice[]> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketPrices(location, game.config.seed, state)
-    }
-
-    async getMarketPricesWithSupply(location: CoordinatesType): Promise<ItemPrice[]> {
-        const [game, state, supplyRows] = await Promise.all([
-            this.getGame(),
-            this.getState(),
-            this.getSupplyRows(location),
-        ])
-
-        const prices = marketPrices(location, game.config.seed, state)
-
-        const supplyMap = new Map<number, number>()
-        for (const row of supplyRows) {
-            if (UInt64.from(row.epoch).equals(state.epoch)) {
-                supplyMap.set(Number(row.item_id), Number(row.supply))
-            }
-        }
-
-        return prices.map((price) => {
-            const actualSupply = supplyMap.get(Number(price.id))
-            if (actualSupply !== undefined) {
-                return ItemPrice.from({
-                    id: price.id,
-                    item: price.item,
-                    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)
@@ -63,45 +19,6 @@ export class LocationsManager extends BaseManager {
         return findNearbyPlanets(game.config.seed, origin, maxDistance)
     }
 
-    async getSupplyRows(location: CoordinatesType) {
-        const hash = Checksum256.hash(Bytes.from(`${location.x}-${location.y}`, 'utf8'))
-        return this.server.table('supply').all({
-            index_position: 'secondary',
-            from: hash,
-            to: hash,
-        })
-    }
-
-    async getLocationWithPrices(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const prices = await this.getMarketPrices(location.coordinates)
-        location.setMarketPrices(prices)
-        return location
-    }
-
-    async getLocationWithSupply(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const [rows, state] = await Promise.all([
-            this.getSupplyRows(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.getSupplyRows(location.coordinates),
-            this.getState(),
-        ])
-
-        location.setMarketPrices(prices)
-        location.setLocationRows(rows, state.epoch)
-        return location
-    }
-
     async getLocationEntity(
         id: UInt64Type
     ): Promise<ServerContract.Types.location_row | undefined> {

package/src/market/items.ts

@@ -7,7 +7,6 @@ const items: Item[] = itemsData.map((g) =>
         id: g.id,
         name: g.name,
         description: g.description,
-        base_price: g.base_price,
         mass: g.mass,
         category: g.category,
         tier: g.tier,

package/src/resolution/resolve-item.ts

@@ -0,0 +1,242 @@
+import {UInt16, UInt64} from '@wharfkit/antelope'
+import type {UInt16Type, UInt64Type} from '@wharfkit/antelope'
+import type {ResourceCategory, ResourceTier} from '../types'
+import {getItem} from '../market/items'
+import {getComponentById, getModuleRecipeByItemId, getEntityRecipeByItemId} from '../data/recipes'
+import {isModuleItem, getModuleCapabilityType, MODULE_ENGINE, MODULE_GENERATOR, MODULE_EXTRACTOR, MODULE_LOADER, MODULE_CRAFTER} from '../capabilities/modules'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {deriveResourceStats} from '../derivation/stratum'
+import {getStatDefinitions} from '../derivation/stats'
+import {computeShipHullCapabilities, computeEngineCapabilities, computeGeneratorCapabilities, computeExtractorCapabilities, computeLoaderCapabilities, computeManufacturingCapabilities} from '../entities/ship-deploy'
+import {computeContainerCapabilities} from '../entities/container'
+import {categoryColors, categoryIcons, componentIcon, moduleIcon} from '../data/colors'
+import {ServerContract} from '../contracts'
+
+export interface ResolvedItemStat {
+    key: string
+    label: string
+    abbreviation: string
+    value: number
+    color: string
+    category: ResourceCategory
+    inverted?: boolean
+}
+
+export interface ResolvedAttributeGroup {
+    capability: string
+    attributes: {label: string; value: number}[]
+}
+
+export type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity'
+
+export interface ResolvedItem {
+    itemId: number
+    name: string
+    icon: string
+    category?: ResourceCategory
+    tier: ResourceTier
+    mass: number
+    itemType: ResolvedItemType
+    stats?: ResolvedItemStat[]
+    attributes?: ResolvedAttributeGroup[]
+}
+
+function toNum(v: UInt16Type): number {
+    return Number(UInt16.from(v).value.toString())
+}
+
+function toBigSeed(v: UInt64Type): bigint {
+    return BigInt(UInt64.from(v).toString())
+}
+
+function resolveResource(id: number, seed?: UInt64Type): ResolvedItem {
+    const item = getItem(id)
+    const cat = item.category
+    let stats: ResolvedItemStat[] | undefined
+    if (seed !== undefined) {
+        const derived = deriveResourceStats(toBigSeed(seed))
+        const defs = getStatDefinitions(cat)
+        const values = [derived.stat1, derived.stat2, derived.stat3]
+        stats = defs.map((d, i) => ({
+            key: d.key,
+            label: d.label,
+            abbreviation: d.abbreviation,
+            value: values[i] ?? 0,
+            color: categoryColors[cat],
+            category: cat,
+            inverted: d.inverted,
+        }))
+    }
+    return {
+        itemId: id,
+        name: String(item.name),
+        icon: categoryIcons[cat] ?? '⬡',
+        category: cat,
+        tier: item.tier,
+        mass: Number(item.mass.value.toString()),
+        itemType: 'resource',
+        stats,
+    }
+}
+
+function resolveComponent(id: number, seed?: UInt64Type): ResolvedItem {
+    const comp = getComponentById(id)!
+    let stats: ResolvedItemStat[] | undefined
+    if (seed !== undefined) {
+        const decoded = decodeCraftedItemStats(id, toBigSeed(seed))
+        stats = Object.entries(decoded).map(([key, value]) => {
+            const allDefs = getStatDefinitions('metal')
+                .concat(getStatDefinitions('precious'))
+                .concat(getStatDefinitions('gas'))
+                .concat(getStatDefinitions('mineral'))
+                .concat(getStatDefinitions('organic'))
+            const def = allDefs.find((d) => d.key === key)
+            const statDef = comp.stats.find((s) => s.key === key)
+            const cat = (statDef?.source ?? 'metal') as ResourceCategory
+            return {
+                key,
+                label: def?.label ?? key,
+                abbreviation: def?.abbreviation ?? key.slice(0, 3).toUpperCase(),
+                value,
+                color: categoryColors[cat],
+                category: cat,
+                inverted: def?.inverted,
+            }
+        })
+    }
+    return {
+        itemId: id,
+        name: comp.name,
+        icon: componentIcon,
+        tier: 't1' as ResourceTier,
+        mass: comp.mass,
+        itemType: 'component',
+        stats,
+    }
+}
+
+function computeCapabilityGroup(moduleType: number, stats: Record<string, number>): ResolvedAttributeGroup | undefined {
+    switch (moduleType) {
+        case MODULE_ENGINE: {
+            const caps = computeEngineCapabilities(stats)
+            return {capability: 'Engine', attributes: [
+                {label: 'Thrust', value: caps.thrust},
+                {label: 'Drain', value: caps.drain},
+            ]}
+        }
+        case MODULE_GENERATOR: {
+            const caps = computeGeneratorCapabilities(stats)
+            return {capability: 'Generator', attributes: [
+                {label: 'Capacity', value: caps.capacity},
+                {label: 'Recharge', value: caps.recharge},
+            ]}
+        }
+        case MODULE_EXTRACTOR: {
+            const caps = computeExtractorCapabilities(stats)
+            return {capability: 'Extractor', attributes: [
+                {label: 'Rate', value: caps.rate},
+                {label: 'Drain', value: caps.drain},
+                {label: 'Depth', value: caps.depth},
+                {label: 'Drill', value: caps.drill},
+            ]}
+        }
+        case MODULE_LOADER: {
+            const caps = computeLoaderCapabilities(stats)
+            return {capability: 'Loader', attributes: [
+                {label: 'Mass', value: caps.mass},
+                {label: 'Thrust', value: caps.thrust},
+                {label: 'Quantity', value: caps.quantity},
+            ]}
+        }
+        case MODULE_CRAFTER: {
+            const caps = computeManufacturingCapabilities(stats)
+            return {capability: 'Manufacturing', attributes: [
+                {label: 'Speed', value: caps.speed},
+                {label: 'Drain', value: caps.drain},
+            ]}
+        }
+        default:
+            return undefined
+    }
+}
+
+function resolveModule(id: number, seed?: UInt64Type): ResolvedItem {
+    const recipe = getModuleRecipeByItemId(id)!
+    let attributes: ResolvedAttributeGroup[] | undefined
+    if (seed !== undefined) {
+        const stats = decodeCraftedItemStats(id, toBigSeed(seed))
+        const modType = getModuleCapabilityType(id)
+        const group = computeCapabilityGroup(modType, stats)
+        if (group) attributes = [group]
+    }
+    return {
+        itemId: id,
+        name: recipe.name,
+        icon: moduleIcon,
+        tier: 't1' as ResourceTier,
+        mass: 0,
+        itemType: 'module',
+        attributes,
+    }
+}
+
+function resolveEntity(id: number, seed?: UInt64Type, modules?: ServerContract.Types.module_entry[]): ResolvedItem {
+    const recipe = getEntityRecipeByItemId(id)!
+    let attributes: ResolvedAttributeGroup[] | undefined
+    if (seed !== undefined) {
+        const stats = decodeCraftedItemStats(id, toBigSeed(seed))
+        attributes = []
+
+        const isShip = recipe.id === 'ship-t1'
+        if (isShip) {
+            const hullCaps = computeShipHullCapabilities(stats)
+            attributes.push({capability: 'Hull', attributes: [
+                {label: 'Mass', value: hullCaps.hullmass},
+                {label: 'Capacity', value: hullCaps.capacity},
+            ]})
+        } else {
+            const containerCaps = computeContainerCapabilities(stats)
+            attributes.push({capability: 'Hull', attributes: [
+                {label: 'Mass', value: containerCaps.hullmass},
+                {label: 'Capacity', value: containerCaps.capacity},
+            ]})
+        }
+
+        if (modules) {
+            for (const mod of modules) {
+                if (!mod.installed) continue
+                const modItemId = Number(mod.installed.item_id.value.toString())
+                const modSeed = BigInt(mod.installed.seed.toString())
+                const modStats = decodeCraftedItemStats(modItemId, modSeed)
+                const modType = getModuleCapabilityType(modItemId)
+                const group = computeCapabilityGroup(modType, modStats)
+                if (group) attributes.push(group)
+            }
+        }
+    }
+    return {
+        itemId: id,
+        name: recipe.name,
+        icon: componentIcon,
+        tier: 't1' as ResourceTier,
+        mass: 0,
+        itemType: 'entity',
+        attributes,
+    }
+}
+
+export function resolveItem(
+    itemId: UInt16Type,
+    seed?: UInt64Type,
+    modules?: ServerContract.Types.module_entry[]
+): ResolvedItem {
+    const id = toNum(itemId)
+
+    if (isModuleItem(id)) return resolveModule(id, seed)
+
+    if (getComponentById(id)) return resolveComponent(id, seed)
+
+    if (getEntityRecipeByItemId(id)) return resolveEntity(id, seed, modules)
+
+    return resolveResource(id, seed)
+}

package/src/scheduling/projection.ts

@@ -23,13 +23,11 @@ export interface ProjectedEntity {
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
-    trade?: ServerContract.Types.trade_stats
     readonly totalMass: UInt64
 
     hasMovement(): boolean
     hasStorage(): boolean
     hasLoaders(): boolean
-    hasTrade(): boolean
 
     capabilities(): EntityCapabilities
     state(): EntityState
@@ -42,7 +40,6 @@ export interface Projectable extends ScheduleData {
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
-    trade?: ServerContract.Types.trade_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
     cargomass: UInt32
@@ -59,7 +56,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const loaders = entity.loaders
     const engines = entity.engines
     const generator = entity.generator
-    const trade = entity.trade
     const capacity = entity.capacity
 
     const projected: ProjectedEntity = {
@@ -71,7 +67,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         engines,
         generator,
         loaders,
-        trade,
 
         get totalMass() {
             let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
@@ -93,10 +88,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             return capsHasLoaders(this.capabilities())
         },
 
-        hasTrade() {
-            return this.trade !== undefined
-        },
-
         capabilities(): EntityCapabilities {
             return {
                 hullmass: this.shipMass,
@@ -104,7 +95,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 engines: this.engines,
                 generator: this.generator,
                 loaders: this.loaders,
-                trade: this.trade,
             }
         },
 

package/src/shipload.ts

@@ -7,7 +7,6 @@ import {GameContext} from './managers/context'
 import {EntitiesManager} from './managers/entities'
 import {PlayersManager} from './managers/players'
 import {LocationsManager} from './managers/locations'
-import {TradesManager} from './managers/trades'
 import {EpochsManager} from './managers/epochs'
 import {ActionsManager} from './managers/actions'
 import {GameState} from './entities/gamestate'
@@ -94,10 +93,6 @@ export class Shipload {
         return this._context.locations
     }
 
-    get trades(): TradesManager {
-        return this._context.trades
-    }
-
     get epochs(): EpochsManager {
         return this._context.epochs
     }

package/src/travel/travel.ts

@@ -24,7 +24,7 @@ import {ServerContract} from '../contracts'
 import {
     CargoMassInfo,
     Distance,
-    INITIAL_SHIP_MASS,
+    BASE_ORBITAL_MASS,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
     PRECISION,
@@ -35,11 +35,11 @@ import {getItem} from '../market/items'
 import {hasSystem} from '../utils/system'
 
 export function calc_orbital_altitude(mass: number): number {
-    if (mass <= INITIAL_SHIP_MASS) {
+    if (mass <= BASE_ORBITAL_MASS) {
         return MIN_ORBITAL_ALTITUDE
     }
 
-    const ratio = mass / INITIAL_SHIP_MASS
+    const ratio = mass / BASE_ORBITAL_MASS
     const capRatio = 10.0
     let scale = Math.log(ratio) / Math.log(capRatio)
     scale = Math.min(scale, 1.0)