@shipload/sdk 0.7.1 → 2.0.0-rc2

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,9 @@
+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 {TradesManager} from './trades'
+export {EpochsManager} from './epochs'
+export {ActionsManager} from './actions'

package/src/managers/locations.ts

@@ -0,0 +1,122 @@
+import {Bytes, Checksum256, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {CoordinatesType, coordsToLocationId, Distance, GoodPrice} from '../types'
+import {marketPrice, marketPrices} from '../market/market'
+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, 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.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)
+    }
+
+    async findNearbyPlanets(
+        origin: CoordinatesType,
+        maxDistance: UInt16Type = 20
+    ): Promise<Distance[]> {
+        const game = await this.getGame()
+        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> {
+        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/managers/trades.ts

@@ -0,0 +1,119 @@
+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 || Coordinates.from(ship.coordinates)
+        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 || Coordinates.from(ship.coordinates)
+        const callbacks = await this.createCallbacks()
+
+        return analyzeCollectOptions(ship, location, callbacks, options)
+    }
+}

package/src/market/goods.ts

@@ -0,0 +1,31 @@
+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))
+}

package/src/{market.ts → market/market.ts}

@@ -1,8 +1,8 @@
-import {Coordinates, GoodPrice} from './types'
+import {CoordinatesType, GoodPrice} from '../types'
 import {getGood, getGoods} from './goods'
-import {Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {Checksum256Type, UInt16, UInt16Type, UInt32} from '@wharfkit/antelope'
 import {roll} from './rolls'
-import {ServerContract} from './contracts'
+import {ServerContract} from '../contracts'
 
 export enum Rarities {
     legendary = 'LEGENDARY',
@@ -19,21 +19,13 @@ export interface 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
+    location: CoordinatesType,
+    goodId: UInt16Type
 ): Rarity {
-    const seed = `${epochSeed}${location.x}${location.y}${good_id}rarity`
+    const seed = `${epochSeed}${location.x}${location.y}${goodId}rarity`
     const rarityRoll = roll(gameSeed, seed)
 
     if (rarityRoll < 13) {
@@ -119,22 +111,22 @@ export function getRarity(
 export function getRarityMultiplier(
     gameSeed: Checksum256Type,
     epochSeed: Checksum256Type,
-    location: Coordinates,
-    good_id: UInt16Type
+    location: CoordinatesType,
+    goodId: UInt16Type
 ): number {
-    const rarity = getRarity(gameSeed, epochSeed, location, good_id)
+    const rarity = getRarity(gameSeed, epochSeed, location, goodId)
     const range = rarity.maxMultiplier - rarity.minMultiplier
-    const seed = `${epochSeed}${location.x}${location.y}${good_id}raritymultiplier`
+    const seed = `${epochSeed}${location.x}${location.y}${goodId}raritymultiplier`
     const r = roll(gameSeed, seed)
     return rarity.minMultiplier + (r / 65535) * range
 }
 
 export function getLocationMultiplier(
     gameSeed: Checksum256Type,
-    location: Coordinates,
-    good_id: UInt16Type
+    location: CoordinatesType,
+    goodId: UInt16Type
 ): number {
-    const seed = `${location.x}${location.y}${good_id}locationmultiplier`
+    const seed = `${location.x}${location.y}${goodId}locationmultiplier`
     const r = roll(gameSeed, seed)
     if (r < 13) {
         return 0.75
@@ -164,51 +156,53 @@ export function getLocationMultiplier(
 export function getSupply(
     gameSeed: Checksum256Type,
     state: ServerContract.Types.state_row,
-    location: Coordinates,
-    good_id: UInt16Type
+    location: CoordinatesType,
+    goodId: UInt16Type
 ): number {
-    const seed = `${state.seed}${location.x}${location.y}${good_id}supply`
+    const seed = `${state.seed}${location.x}${location.y}${goodId}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()
+    const ship = 1
+    const goodIdNum = Number(goodId)
+    const base = Math.floor(128 / goodIdNum)
+    return Math.floor(base * percent * ship * epoch)
 }
 
-export function marketprice(
+export function marketPrice(
     location: ServerContract.ActionParams.Type.coordinates,
-    good_id: UInt16Type,
+    goodId: UInt16Type,
     gameSeed: Checksum256Type,
     state: ServerContract.Types.state_row
 ): GoodPrice {
-    const good = getGood(good_id)
+    const good = getGood(goodId)
     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)
+    const rarityMultiplier = getRarityMultiplier(gameSeed, state.seed, location, goodId)
     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)
+    const locationMultiplier = getLocationMultiplier(gameSeed, location, goodId)
     price *= locationMultiplier
 
     // Determine the current supply of the good at the location
-    const supply = getSupply(gameSeed, state, location, good_id)
+    const supply = getSupply(gameSeed, state, location, goodId)
 
     return GoodPrice.from({
-        id: good_id,
+        id: goodId,
         good,
-        price: UInt64.from(price),
-        supply: UInt64.from(supply),
+        price: UInt32.from(price),
+        supply: UInt16.from(supply),
     })
 }
 
-export function marketprices(
+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))
+    return getGoods().map((good) => marketPrice(location, good.id, gameSeed, state))
 }

package/src/{rolls.ts → market/rolls.ts}

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

package/src/scheduling/accessor.ts

@@ -0,0 +1,82 @@
+import {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+import {ScheduleData} from './schedule'
+import * as schedule from './schedule'
+
+type Task = ServerContract.Types.task
+
+export class ScheduleAccessor {
+    constructor(private entity: ScheduleData) {}
+
+    get hasSchedule(): boolean {
+        return schedule.hasSchedule(this.entity)
+    }
+
+    get isIdle(): boolean {
+        return schedule.isIdle(this.entity)
+    }
+
+    get tasks(): Task[] {
+        return schedule.getTasks(this.entity)
+    }
+
+    duration(): number {
+        return schedule.scheduleDuration(this.entity)
+    }
+
+    elapsed(now: Date): number {
+        return schedule.scheduleElapsed(this.entity, now)
+    }
+
+    remaining(now: Date): number {
+        return schedule.scheduleRemaining(this.entity, now)
+    }
+
+    complete(now: Date): boolean {
+        return schedule.scheduleComplete(this.entity, now)
+    }
+
+    currentTaskIndex(now: Date): number {
+        return schedule.currentTaskIndex(this.entity, now)
+    }
+
+    currentTask(now: Date): Task | undefined {
+        return schedule.currentTask(this.entity, now)
+    }
+
+    currentTaskType(now: Date): TaskType | undefined {
+        return schedule.currentTaskType(this.entity, now)
+    }
+
+    taskStartTime(index: number): number {
+        return schedule.getTaskStartTime(this.entity, index)
+    }
+
+    taskElapsed(index: number, now: Date): number {
+        return schedule.getTaskElapsed(this.entity, index, now)
+    }
+
+    taskRemaining(index: number, now: Date): number {
+        return schedule.getTaskRemaining(this.entity, index, now)
+    }
+
+    taskComplete(index: number, now: Date): boolean {
+        return schedule.isTaskComplete(this.entity, index, now)
+    }
+
+    taskInProgress(index: number, now: Date): boolean {
+        return schedule.isTaskInProgress(this.entity, index, now)
+    }
+
+    currentTaskProgress(now: Date): number {
+        return schedule.currentTaskProgress(this.entity, now)
+    }
+
+    progress(now: Date): number {
+        return schedule.scheduleProgress(this.entity, now)
+    }
+}
+
+export function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor {
+    return new ScheduleAccessor(entity)
+}

package/src/{epoch.ts → scheduling/epoch.ts}

@@ -1,5 +1,5 @@
 import {UInt64} from '@wharfkit/antelope'
-import {PlatformContract} from './contracts'
+import {PlatformContract} from '../contracts'
 
 export interface EpochInfo {
     epoch: UInt64