@shipload/sdk 0.7.0 → 2.0.0-rc1

package/src/scheduling/projection.ts

@@ -0,0 +1,218 @@
+import {UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates, PRECISION, TaskType} from '../types'
+import {distanceBetweenCoordinates, lerp} from '../travel/travel'
+import {getGood} from '../market/goods'
+import * as schedule from './schedule'
+import {ScheduleData} from './schedule'
+
+/**
+ * Projected state of an entity after scheduled tasks complete.
+ * Mirrors contract's projected_entity struct.
+ */
+export interface ProjectedEntity {
+    location: Coordinates
+    energy: UInt16
+    cargoMass: UInt64
+    shipMass: UInt32
+    capacity?: UInt64
+    engines?: ServerContract.Types.movement_stats
+    loaders?: ServerContract.Types.loader_stats
+    generator?: ServerContract.Types.energy_stats
+    readonly totalMass: UInt64
+}
+
+/**
+ * Interface for entities that can be projected.
+ * Ships and Warehouses both implement this.
+ */
+export interface Projectable extends ScheduleData {
+    location: Coordinates
+    energy: UInt16
+    mass: UInt32
+    generator?: ServerContract.Types.energy_stats
+    engines?: ServerContract.Types.movement_stats
+    loaders?: ServerContract.Types.loader_stats
+    capacity?: UInt64
+    calcCargoMass(): UInt64
+}
+
+/**
+ * Create initial projected entity state from a projectable entity.
+ */
+export function createProjectedEntity(entity: Projectable): ProjectedEntity {
+    const cargoMass = entity.calcCargoMass()
+    const shipMass = UInt32.from(entity.mass)
+    const loaders = entity.loaders
+
+    return {
+        location: Coordinates.from(entity.location),
+        energy: UInt16.from(entity.energy),
+        cargoMass,
+        shipMass,
+        capacity: entity.capacity,
+        engines: entity.engines,
+        generator: entity.generator,
+        loaders,
+        get totalMass() {
+            let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
+            if (this.loaders) {
+                mass = mass.adding(this.loaders.mass.multiplying(this.loaders.quantity))
+            }
+            return mass
+        },
+    }
+}
+
+/**
+ * Apply a recharge task to projected state.
+ */
+function applyRechargeTask(
+    projected: ProjectedEntity,
+    _task: ServerContract.Types.task,
+    options: {complete: boolean; progress?: number}
+): void {
+    if (!projected.generator) return
+
+    if (options.complete) {
+        projected.energy = UInt16.from(projected.generator.capacity)
+    } else if (options.progress !== undefined) {
+        const capacity = Number(projected.generator.capacity)
+        const currentEnergy = Number(projected.energy)
+        const rechargeAmount = (capacity - currentEnergy) * options.progress
+        projected.energy = UInt16.from(Math.min(capacity, currentEnergy + rechargeAmount))
+    }
+}
+
+/**
+ * Apply a flight task to projected state.
+ */
+function applyFlightTask(
+    projected: ProjectedEntity,
+    task: ServerContract.Types.task,
+    options: {complete: boolean; progress?: number}
+): void {
+    if (!task.location || !projected.engines) return
+
+    const origin = projected.location
+    const destination = Coordinates.from(task.location)
+    const distance = distanceBetweenCoordinates(origin, task.location)
+    const energyUsage = distance.dividing(PRECISION).multiplying(projected.engines.drain)
+
+    if (options.complete) {
+        projected.energy = projected.energy.gt(energyUsage)
+            ? UInt16.from(projected.energy.subtracting(energyUsage))
+            : UInt16.from(0)
+        projected.location = destination
+    } else if (options.progress !== undefined) {
+        const interpolated = lerp(origin, destination, options.progress)
+        projected.location = Coordinates.from({
+            x: Math.round(interpolated.x),
+            y: Math.round(interpolated.y),
+        })
+        const partialEnergy = UInt64.from(Math.floor(Number(energyUsage) * options.progress))
+        projected.energy = projected.energy.gt(partialEnergy)
+            ? UInt16.from(projected.energy.subtracting(partialEnergy))
+            : UInt16.from(0)
+    }
+}
+
+/**
+ * Apply a load task to projected state.
+ */
+function applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    for (const item of task.cargo) {
+        const good = getGood(item.good_id)
+        projected.cargoMass = projected.cargoMass.adding(good.mass.multiplying(item.quantity))
+    }
+}
+
+/**
+ * Apply an unload task to projected state.
+ */
+function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    for (const item of task.cargo) {
+        const good = getGood(item.good_id)
+        const cargoMass = good.mass.multiplying(item.quantity)
+        projected.cargoMass = projected.cargoMass.gt(cargoMass)
+            ? projected.cargoMass.subtracting(cargoMass)
+            : UInt64.from(0)
+    }
+}
+
+/**
+ * Project entity state after all scheduled tasks complete.
+ * Mirrors contract's project_ship/project_warehouse methods.
+ */
+export function projectEntity(entity: Projectable): ProjectedEntity {
+    const projected = createProjectedEntity(entity)
+
+    if (!entity.schedule) {
+        return projected
+    }
+
+    for (const task of entity.schedule.tasks) {
+        switch (task.type.toNumber()) {
+            case TaskType.RECHARGE:
+                applyRechargeTask(projected, task, {complete: true})
+                break
+            case TaskType.FLIGHT:
+                applyFlightTask(projected, task, {complete: true})
+                break
+            case TaskType.LOAD:
+                applyLoadTask(projected, task)
+                break
+            case TaskType.UNLOAD:
+                applyUnloadTask(projected, task)
+                break
+        }
+    }
+
+    return projected
+}
+
+/**
+ * Project entity state at a specific time (partial task execution).
+ */
+export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
+    const projected = createProjectedEntity(entity)
+
+    if (!entity.schedule || entity.schedule.tasks.length === 0) {
+        return projected
+    }
+
+    for (let i = 0; i < entity.schedule.tasks.length; i++) {
+        const task = entity.schedule.tasks[i]
+        const taskComplete = schedule.isTaskComplete(entity, i, now)
+        const taskInProgress = schedule.isTaskInProgress(entity, i, now)
+
+        if (!taskComplete && !taskInProgress) {
+            break
+        }
+
+        const progress = taskInProgress
+            ? schedule.getTaskElapsed(entity, i, now) / task.duration.toNumber()
+            : undefined
+
+        switch (task.type.toNumber()) {
+            case TaskType.RECHARGE:
+                applyRechargeTask(projected, task, {complete: taskComplete, progress})
+                break
+            case TaskType.FLIGHT:
+                applyFlightTask(projected, task, {complete: taskComplete, progress})
+                break
+            case TaskType.LOAD:
+                if (taskComplete) {
+                    applyLoadTask(projected, task)
+                }
+                break
+            case TaskType.UNLOAD:
+                if (taskComplete) {
+                    applyUnloadTask(projected, task)
+                }
+                break
+        }
+    }
+
+    return projected
+}

package/src/scheduling/schedule.ts

@@ -0,0 +1,155 @@
+import {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+type Schedule = ServerContract.Types.schedule
+type Task = ServerContract.Types.task
+
+export interface ScheduleData {
+    schedule?: Schedule
+}
+
+export interface Scheduleable extends ScheduleData {
+    hasSchedule: boolean
+    isIdle: boolean
+    tasks: Task[]
+    scheduleDuration(): number
+    scheduleElapsed(now: Date): number
+    scheduleRemaining(now: Date): number
+    scheduleComplete(now: Date): boolean
+    currentTaskIndex(now: Date): number
+    currentTask(now: Date): Task | undefined
+    currentTaskType(now: Date): TaskType | undefined
+    getTaskStartTime(index: number): number
+    getTaskElapsed(index: number, now: Date): number
+    getTaskRemaining(index: number, now: Date): number
+    isTaskComplete(index: number, now: Date): boolean
+    isTaskInProgress(index: number, now: Date): boolean
+    currentTaskProgress(now: Date): number
+    scheduleProgress(now: Date): number
+}
+
+export function hasSchedule(entity: ScheduleData): boolean {
+    return !!entity.schedule && entity.schedule.tasks.length > 0
+}
+
+export function isIdle(entity: ScheduleData): boolean {
+    return !hasSchedule(entity)
+}
+
+export function getTasks(entity: ScheduleData): Task[] {
+    return entity.schedule?.tasks || []
+}
+
+export function scheduleDuration(entity: ScheduleData): number {
+    if (!entity.schedule) return 0
+    return entity.schedule.tasks.reduce((sum, task) => sum + task.duration.toNumber(), 0)
+}
+
+export function scheduleElapsed(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule) return 0
+    const started = entity.schedule.started.toDate()
+    const elapsed = Math.floor((now.getTime() - started.getTime()) / 1000)
+    return Math.max(0, elapsed)
+}
+
+export function scheduleRemaining(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule) return 0
+    const duration = scheduleDuration(entity)
+    const elapsed = scheduleElapsed(entity, now)
+    return Math.max(0, duration - elapsed)
+}
+
+export function scheduleComplete(entity: ScheduleData, now: Date): boolean {
+    return hasSchedule(entity) && scheduleRemaining(entity, now) === 0
+}
+
+export function currentTaskIndex(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return -1
+
+    const elapsed = scheduleElapsed(entity, now)
+    let timeAccum = 0
+
+    for (let i = 0; i < entity.schedule.tasks.length; i++) {
+        const taskDuration = entity.schedule.tasks[i].duration.toNumber()
+        if (elapsed < timeAccum + taskDuration) {
+            return i
+        }
+        timeAccum += taskDuration
+    }
+
+    return entity.schedule.tasks.length - 1
+}
+
+export function currentTask(entity: ScheduleData, now: Date): Task | undefined {
+    const index = currentTaskIndex(entity, now)
+    if (index < 0 || !entity.schedule) return undefined
+    return entity.schedule.tasks[index]
+}
+
+export function currentTaskType(entity: ScheduleData, now: Date): TaskType | undefined {
+    const task = currentTask(entity, now)
+    if (!task) return undefined
+    return task.type.toNumber() as TaskType
+}
+
+export function getTaskStartTime(entity: ScheduleData, index: number): number {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+    let timeAccum = 0
+    for (let i = 0; i < index; i++) {
+        timeAccum += entity.schedule.tasks[i].duration.toNumber()
+    }
+    return timeAccum
+}
+
+export function getTaskElapsed(entity: ScheduleData, index: number, now: Date): number {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+
+    const elapsed = scheduleElapsed(entity, now)
+    const taskStart = getTaskStartTime(entity, index)
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+
+    if (elapsed <= taskStart) return 0
+    const elapsedInTask = elapsed - taskStart
+    return Math.min(elapsedInTask, taskDuration)
+}
+
+export function getTaskRemaining(entity: ScheduleData, index: number, now: Date): number {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+    const taskElapsed = getTaskElapsed(entity, index, now)
+    return Math.max(0, taskDuration - taskElapsed)
+}
+
+export function isTaskComplete(entity: ScheduleData, index: number, now: Date): boolean {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return false
+
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+    const taskElapsed = getTaskElapsed(entity, index, now)
+    return taskElapsed >= taskDuration
+}
+
+export function isTaskInProgress(entity: ScheduleData, index: number, now: Date): boolean {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return false
+
+    const taskElapsed = getTaskElapsed(entity, index, now)
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+    return taskElapsed > 0 && taskElapsed < taskDuration
+}
+
+export function currentTaskProgress(entity: ScheduleData, now: Date): number {
+    const task = currentTask(entity, now)
+    if (!task) return 0
+    const index = currentTaskIndex(entity, now)
+    const elapsed = getTaskElapsed(entity, index, now)
+    const duration = task.duration.toNumber()
+    if (duration === 0) return 1
+    return Math.min(1, elapsed / duration)
+}
+
+export function scheduleProgress(entity: ScheduleData, now: Date): number {
+    const duration = scheduleDuration(entity)
+    if (duration === 0) return hasSchedule(entity) ? 1 : 0
+    const elapsed = scheduleElapsed(entity, now)
+    return Math.min(1, elapsed / duration)
+}

package/src/shipload.ts

@@ -1,25 +1,16 @@
-import {
-    APIClient,
-    Bytes,
-    Checksum256,
-    Name,
-    NameType,
-    Serializer,
-    UInt16Type,
-    UInt64,
-    UInt64Type,
-} from '@wharfkit/antelope'
-import {Coordinates, Distance, GoodPrice} from './types'
-import {marketprice, marketprices} from './market'
+import {APIClient} from '@wharfkit/antelope'
 import {PlatformContract, ServerContract} from './contracts'
-import {ERROR_SYSTEM_NOT_INITIALIZED} from './errors'
 import {ChainDefinition} from '@wharfkit/session'
 import ContractKit, {Contract} from '@wharfkit/contract'
-import {findNearbyPlanets, travelplan} from './travel'
 
-import {Ship} from './ship'
-import {EpochInfo, getCurrentEpoch, getEpochInfo} from './epoch'
-import {hasSystem} from './system'
+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'
 
 interface ShiploadOptions {
     platformContractName?: string
@@ -33,22 +24,21 @@ interface ShiploadConstructorOptions extends ShiploadOptions {
 }
 
 export class Shipload {
-    public client: APIClient
-    public server: Contract
-    public platform: Contract
-    public game: PlatformContract.Types.game_row | undefined
+    private readonly _context: GameContext
 
     constructor(chain: ChainDefinition, constructorOptions?: ShiploadConstructorOptions) {
         const {client, platformContract, serverContract} = constructorOptions || {}
-        this.client = client || new APIClient({url: chain.url})
+        const apiClient = client || new APIClient({url: chain.url})
 
-        this.platform = platformContract
+        const platform = platformContract
             ? platformContract
-            : new PlatformContract.Contract({client: this.client})
+            : new PlatformContract.Contract({client: apiClient})
 
-        this.server = serverContract
+        const server = serverContract
             ? serverContract
-            : new ServerContract.Contract({client: this.client})
+            : new ServerContract.Contract({client: apiClient})
+
+        this._context = new GameContext(apiClient, server, platform)
     }
 
     static async load(
@@ -80,155 +70,47 @@ export class Shipload {
         })
     }
 
-    async getGame(reload = false): Promise<PlatformContract.Types.game_row> {
-        if (!reload && this.game) {
-            return this.game
-        }
-        const game = await this.platform.table('games').get()
-        if (!game) {
-            throw new Error(ERROR_SYSTEM_NOT_INITIALIZED)
-        }
-        this.game = game
-        return game
-    }
-
-    async getState(): Promise<ServerContract.Types.state_row> {
-        const state = await this.server.table('state').get()
-        if (!state) {
-            throw new Error(ERROR_SYSTEM_NOT_INITIALIZED)
-        }
-        return state
-    }
-
-    async getShip(ship_id: UInt64Type): Promise<Ship> {
-        const ship = await this.server.table('ship').get(UInt64.from(ship_id))
-        if (!ship) {
-            throw new Error('No ship found')
-        }
-        return new Ship(ship)
-    }
-
-    async getShips(player: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
-        let account: Name
-        if (player instanceof ServerContract.Types.player_row) {
-            account = player.owner
-        } else {
-            account = Name.from(player)
-        }
-        const from = Serializer.decode({
-            data:
-                Serializer.encode({object: UInt64.from(UInt64.min)}).hexString +
-                Serializer.encode({object: Name.from(account)}).hexString,
-            type: 'uint128',
-        })
-        const to = Serializer.decode({
-            data:
-                Serializer.encode({object: UInt64.from(UInt64.max)}).hexString +
-                Serializer.encode({object: Name.from(account)}).hexString,
-            type: 'uint128',
-        })
-        const ships = await this.server
-            .table('ship')
-            .query({
-                key_type: 'i128',
-                index_position: 'secondary',
-                from,
-                to,
-            })
-            .all()
-        return ships.map((ship) => new Ship(ship))
+    get client(): APIClient {
+        return this._context.client
     }
 
-    async marketprice(
-        location: ServerContract.ActionParams.Type.coordinates,
-        good_id: number
-    ): Promise<GoodPrice> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketprice(location, good_id, game.config.seed, state)
+    get server(): Contract {
+        return this._context.server
     }
 
-    async marketprices(
-        location: ServerContract.ActionParams.Type.coordinates
-    ): Promise<GoodPrice[]> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketprices(location, game.config.seed, state)
+    get platform(): Contract {
+        return this._context.platform
     }
 
-    async hasSystem(location: ServerContract.ActionParams.Type.coordinates): Promise<boolean> {
-        const game = await this.getGame()
-        return hasSystem(game.config.seed, location)
+    get entities(): EntitiesManager {
+        return this._context.entities
     }
 
-    async findNearbyPlanets(
-        origin: ServerContract.ActionParams.Type.coordinates,
-        maxDistance: UInt16Type = 20
-    ): Promise<Distance[]> {
-        const game = await this.getGame()
-        return findNearbyPlanets(game.config.seed, origin, maxDistance)
+    get players(): PlayersManager {
+        return this._context.players
     }
 
-    async travelplan(
-        ship: ServerContract.Types.ship_row,
-        origin: ServerContract.ActionParams.Type.coordinates,
-        destination: ServerContract.ActionParams.Type.coordinates,
-        recharge = false
-    ): Promise<ServerContract.Types.travel_plan> {
-        const game = await this.getGame()
-        const cargos = await this.server.table('cargo').all({
-            from: ship.id,
-            to: ship.id,
-            index_position: 'secondary',
-        })
-        return travelplan(game, ship, cargos, origin, destination, recharge)
+    get locations(): LocationsManager {
+        return this._context.locations
     }
 
-    async getCargo(
-        ship: UInt64Type | ServerContract.Types.ship_row
-    ): Promise<ServerContract.Types.cargo_row[]> {
-        let shipId: UInt64
-        if (ship instanceof ServerContract.Types.ship_row) {
-            shipId = UInt64.from(ship.id)
-        } else {
-            shipId = UInt64.from(ship)
-        }
-
-        const cargoItems = await this.server
-            .table('cargo')
-            .query({
-                key_type: 'i64',
-                index_position: 'secondary',
-                from: shipId,
-                to: shipId,
-            })
-            .all()
-
-        return cargoItems
+    get trades(): TradesManager {
+        return this._context.trades
     }
 
-    async getCurrentEpochHeight(): Promise<UInt64> {
-        const game = await this.getGame()
-        return getCurrentEpoch(game)
+    get epochs(): EpochsManager {
+        return this._context.epochs
     }
 
-    async getCurrentEpoch(): Promise<EpochInfo> {
-        const game = await this.getGame()
-        const epoch = await this.getCurrentEpochHeight()
-        return getEpochInfo(game, epoch)
+    get actions(): ActionsManager {
+        return this._context.actions
     }
 
-    async getEpoch(height: UInt64Type): Promise<EpochInfo> {
-        const game = await this.getGame()
-        return getEpochInfo(game, UInt64.from(height))
+    async getGame(reload = false): Promise<PlatformContract.Types.game_row> {
+        return this._context.getGame(reload)
     }
 
-    async getLocation(location: Coordinates) {
-        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 getState(reload = false): Promise<GameState> {
+        return this._context.getState(reload)
     }
 }