@shipload/sdk 1.0.0-next.11 → 1.0.0-next.13

package/src/entities/ship-deploy.ts

@@ -1,316 +0,0 @@
-import {decodeCraftedItemStats} from '../derivation/crafting'
-import {
-    getModuleCapabilityType,
-    MODULE_CRAFTER,
-    MODULE_ENGINE,
-    MODULE_GATHERER,
-    MODULE_GENERATOR,
-    MODULE_HAULER,
-    MODULE_LOADER,
-} from '../capabilities/modules'
-import {getItem} from '../data/catalog'
-import type {EntitySlot} from '../data/recipes-runtime'
-import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
-
-export type {InstalledModule}
-
-export function computeShipHullCapabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const density = stats.density
-    const strength = stats.strength
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 100000 - 75 * density
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2997.0
-    const capacity = Math.floor(1000000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}
-
-export function computeEngineCapabilities(stats: Record<string, number>): {
-    thrust: number
-    drain: number
-} {
-    const vol = stats.volatility
-    const thm = stats.thermal
-
-    return {
-        thrust: 400 + Math.floor((vol * 3) / 4),
-        drain: Math.max(30, 50 - Math.floor(thm / 70)),
-    }
-}
-
-export function computeGeneratorCapabilities(stats: Record<string, number>): {
-    capacity: number
-    recharge: number
-} {
-    const com = stats.composition
-    const fin = stats.fineness
-
-    return {
-        capacity: 300 + Math.floor(com / 6),
-        recharge: 1 + Math.floor((fin * 3) / 1000),
-    }
-}
-
-export interface GathererDepthParams {
-    readonly floor: number
-    readonly slope: number
-}
-
-export const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[] = [
-    {floor: 500, slope: 5},
-    {floor: 2000, slope: 11},
-    {floor: 7000, slope: 16},
-    {floor: 15000, slope: 18},
-    {floor: 25000, slope: 19},
-    {floor: 35000, slope: 16},
-    {floor: 46000, slope: 12},
-    {floor: 53500, slope: 10},
-    {floor: 60000, slope: 5},
-    {floor: 63500, slope: 2},
-]
-
-export const GATHERER_DEPTH_MAX_TIER = 10
-
-export function gathererDepthForTier(tol: number, tier: number): number {
-    if (tier < 1 || tier > GATHERER_DEPTH_MAX_TIER) {
-        throw new Error(`gatherer tier out of range: ${tier}`)
-    }
-    const p = GATHERER_DEPTH_TABLE[tier - 1]
-    return p.floor + tol * p.slope
-}
-
-export function computeGathererCapabilities(
-    stats: Record<string, number>,
-    tier: number
-): {
-    yield: number
-    drain: number
-    depth: number
-    speed: number
-} {
-    const str = stats.strength
-    const con = stats.conductivity
-    const ref = stats.reflectivity
-    const tol = stats.tolerance
-
-    return {
-        yield: 200 + str,
-        drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
-        depth: gathererDepthForTier(tol, tier),
-        speed: 100 + Math.floor((ref * 4) / 5),
-    }
-}
-
-export function computeLoaderCapabilities(stats: Record<string, number>): {
-    mass: number
-    thrust: number
-    quantity: number
-} {
-    const insulation = stats.insulation
-    const plasticity = stats.plasticity
-
-    return {
-        mass: Math.max(200, 2000 - Math.floor(insulation * 2)),
-        thrust: 1 + Math.floor(plasticity / 500),
-        quantity: 1,
-    }
-}
-
-export function computeCrafterCapabilities(stats: Record<string, number>): {
-    speed: number
-    drain: number
-} {
-    const rea = stats.reactivity
-    const fin = stats.fineness
-
-    return {
-        speed: 100 + Math.floor((rea * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(fin / 33)),
-    }
-}
-
-export function computeHaulerCapabilities(stats: Record<string, number>): {
-    capacity: number
-    efficiency: number
-    drain: number
-} {
-    const fineness = stats.fineness
-    const conductivity = stats.conductivity
-    const composition = stats.composition
-
-    return {
-        capacity: Math.max(1, 1 + Math.floor(fineness / 400)),
-        efficiency: 2000 + conductivity * 6,
-        drain: Math.max(3, 15 - Math.floor(composition / 80)),
-    }
-}
-
-export function computeStorageCapabilities(
-    stats: Record<string, number>,
-    baseCapacity: number
-): {
-    capacityBonus: number
-} {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const statSum = strength + density + hardness + saturation
-    const capacityBonus = Math.floor(
-        (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
-    )
-
-    return {capacityBonus}
-}
-
-export function computeWarehouseHullCapabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const density = stats.density
-    const strength = stats.strength
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 100000 - 75 * density
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2997.0
-    const capacity = Math.floor(20000000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}
-
-export interface ShipCapabilities {
-    engines?: {thrust: number; drain: number}
-    generator?: {capacity: number; recharge: number}
-    gatherer?: {yield: number; drain: number; depth: number; speed: number}
-    hauler?: {capacity: number; efficiency: number; drain: number}
-    loaders?: {mass: number; thrust: number; quantity: number}
-    crafter?: {speed: number; drain: number}
-}
-
-export function computeShipCapabilities(
-    modules: InstalledModule[],
-    layout: EntitySlot[]
-): ShipCapabilities {
-    const ship: ShipCapabilities = {}
-
-    const engineModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_ENGINE)
-    if (engineModules.length > 0) {
-        let totalThrust = 0
-        let totalDrain = 0
-        for (const m of engineModules) {
-            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
-            totalDrain += caps.drain
-        }
-        ship.engines = {thrust: totalThrust, drain: totalDrain}
-    }
-
-    const generatorModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR
-    )
-    if (generatorModules.length > 0) {
-        let totalCapacity = 0
-        let totalRecharge = 0
-        for (const m of generatorModules) {
-            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            const amp = getSlotAmp(layout, m.slotIndex)
-            totalCapacity += applySlotMultiplier(caps.capacity, amp)
-            totalRecharge += applySlotMultiplier(caps.recharge, amp)
-        }
-        ship.generator = {
-            capacity: clampUint16(totalCapacity),
-            recharge: clampUint16(totalRecharge),
-        }
-    }
-
-    const gathererModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER
-    )
-    if (gathererModules.length > 0) {
-        let totalYield = 0
-        let totalDrain = 0
-        let maxDepth = 0
-        let totalSpeed = 0
-        for (const m of gathererModules) {
-            const tier = getItem(m.itemId).tier
-            const caps = computeGathererCapabilities(
-                decodeCraftedItemStats(m.itemId, m.stats),
-                tier
-            )
-            const amp = getSlotAmp(layout, m.slotIndex)
-            totalYield += applySlotMultiplier(caps.yield, amp)
-            totalDrain += caps.drain
-            if (caps.depth > maxDepth) maxDepth = caps.depth
-            totalSpeed += applySlotMultiplier(caps.speed, amp)
-        }
-        ship.gatherer = {
-            yield: clampUint16(totalYield),
-            drain: totalDrain,
-            depth: maxDepth,
-            speed: clampUint16(totalSpeed),
-        }
-    }
-
-    const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)
-    if (haulerModules.length > 0) {
-        let totalCapacity = 0
-        let weightedEffNum = 0
-        let totalDrain = 0
-        for (const m of haulerModules) {
-            const caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            const eff = applySlotMultiplier(caps.efficiency, getSlotAmp(layout, m.slotIndex))
-            totalCapacity += caps.capacity
-            weightedEffNum += eff * caps.capacity
-            totalDrain += caps.drain
-        }
-        const efficiency = totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0
-        ship.hauler = {
-            capacity: totalCapacity,
-            efficiency: clampUint16(efficiency),
-            drain: totalDrain,
-        }
-    }
-
-    const loaderModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_LOADER)
-    if (loaderModules.length > 0) {
-        let totalMass = 0
-        let totalThrust = 0
-        let totalQuantity = 0
-        for (const m of loaderModules) {
-            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalMass += caps.mass
-            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
-            totalQuantity += caps.quantity
-        }
-        ship.loaders = {
-            mass: totalMass,
-            thrust: clampUint16(totalThrust),
-            quantity: totalQuantity,
-        }
-    }
-
-    const crafterModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_CRAFTER
-    )
-    if (crafterModules.length > 0) {
-        let totalSpeed = 0
-        let totalDrain = 0
-        for (const m of crafterModules) {
-            const caps = computeCrafterCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalSpeed += applySlotMultiplier(caps.speed, getSlotAmp(layout, m.slotIndex))
-            totalDrain += caps.drain
-        }
-        ship.crafter = {speed: clampUint16(totalSpeed), drain: totalDrain}
-    }
-
-    return ship
-}

package/src/entities/ship.ts

@@ -1,221 +0,0 @@
-import {type UInt16, type UInt16Type, UInt32, UInt64, type UInt64Type} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import {Coordinates, type CoordinatesType} from '../types'
-import {
-    type FloatPosition,
-    getDestinationLocation,
-    getInterpolatedPosition,
-    getPositionAt,
-    getFlightOrigin as travelGetFlightOrigin,
-} from '../travel/travel'
-import {
-    type ProjectedEntity,
-    projectFromCurrentState as sharedProjectFromCurrentState,
-    projectFromCurrentStateAt as sharedProjectFromCurrentStateAt,
-} from '../scheduling/projection'
-import {Location} from './location'
-import {ScheduleAccessor} from '../scheduling/accessor'
-import {InventoryAccessor} from './inventory-accessor'
-import type {EntityInventory} from './entity-inventory'
-import {
-    energyPercent as calcEnergyPercent,
-    needsRecharge as calcNeedsRecharge,
-    hasEnergyForDistance,
-    maxTravelDistance,
-} from '../capabilities/movement'
-import * as schedule from '../scheduling/schedule'
-
-export interface PackedModuleInput {
-    itemId: UInt16Type
-    stats: UInt64Type
-}
-
-export interface ShipStateInput {
-    id: UInt64Type
-    owner: string
-    name: string
-    coordinates: CoordinatesType | {x: number; y: number; z?: number}
-    hullmass?: number
-    capacity?: number
-    energy?: number
-    modules?: PackedModuleInput[]
-    schedule?: ServerContract.Types.schedule
-    cargo?: ServerContract.Types.cargo_item[]
-}
-
-type MovementEntity = {
-    engines: ServerContract.Types.movement_stats
-    generator: ServerContract.Types.energy_stats
-    energy: UInt16
-}
-
-export class Ship extends ServerContract.Types.entity_info {
-    private _sched?: ScheduleAccessor
-    private _inv?: InventoryAccessor
-
-    get name(): string {
-        return this.entity_name
-    }
-
-    get entityClass(): 'orbital' {
-        return 'orbital'
-    }
-
-    get canUndeploy(): boolean {
-        return true
-    }
-
-    get inv(): InventoryAccessor {
-        this._inv ??= new InventoryAccessor(this)
-        return this._inv
-    }
-
-    get inventory(): EntityInventory[] {
-        return this.inv.items
-    }
-
-    get sched(): ScheduleAccessor {
-        this._sched ??= new ScheduleAccessor(this)
-        return this._sched
-    }
-
-    get maxDistance(): UInt32 {
-        if (!this.generator || !this.engines) return UInt32.from(0)
-        return maxTravelDistance(this as MovementEntity)
-    }
-
-    get isIdle(): boolean {
-        return this.is_idle
-    }
-
-    getFlightOrigin(flightTaskIndex: number): Coordinates {
-        return Coordinates.from(travelGetFlightOrigin(this, flightTaskIndex))
-    }
-
-    destinationLocation(): Coordinates | undefined {
-        const dest = getDestinationLocation(this)
-        return dest ? Coordinates.from(dest) : undefined
-    }
-
-    /** Chain-tile coordinates at `now`. For smooth visual position use interpolatedPositionAt. */
-    positionAt(now: Date): Coordinates {
-        const taskIndex = this.sched.currentTaskIndex(now)
-        const progress = this.sched.currentTaskProgress(now)
-        return Coordinates.from(getPositionAt(this, taskIndex, progress))
-    }
-
-    interpolatedPositionAt(now: Date): FloatPosition {
-        const taskIndex = this.sched.currentTaskIndex(now)
-        const progress = this.sched.currentTaskProgressFloat(now)
-        return getInterpolatedPosition(this, taskIndex, progress)
-    }
-
-    isInFlight(now: Date): boolean {
-        return schedule.isInFlight(this, now)
-    }
-
-    isRecharging(now: Date): boolean {
-        return schedule.isRecharging(this, now)
-    }
-
-    isLoading(now: Date): boolean {
-        return schedule.isLoading(this, now)
-    }
-
-    isUnloading(now: Date): boolean {
-        return schedule.isUnloading(this, now)
-    }
-
-    isGathering(now: Date): boolean {
-        return schedule.isGathering(this, now)
-    }
-
-    get hasEngines(): boolean {
-        return this.engines !== undefined
-    }
-
-    get hasGenerator(): boolean {
-        return this.generator !== undefined
-    }
-
-    get hasGatherer(): boolean {
-        return this.gatherer !== undefined
-    }
-
-    get hasWarp(): boolean {
-        return this.warp !== undefined
-    }
-
-    project(): ProjectedEntity {
-        return sharedProjectFromCurrentState(this)
-    }
-
-    projectAt(now: Date): ProjectedEntity {
-        return sharedProjectFromCurrentStateAt(this, now)
-    }
-
-    get location(): Location {
-        return Location.from(this.coordinates)
-    }
-
-    get totalCargoMass(): UInt64 {
-        return this.inv.totalMass
-    }
-
-    get totalMass(): UInt64 {
-        let mass = UInt64.from(this.hullmass ?? 0).adding(this.totalCargoMass)
-        if (this.loaders) {
-            mass = mass.adding(UInt64.from(this.loaders.mass).multiplying(this.loaders.quantity))
-        }
-        return mass
-    }
-
-    get maxCapacity(): UInt64 {
-        return UInt64.from(this.capacity)
-    }
-
-    hasSpace(goodMass: UInt64, quantity: number): boolean {
-        return this.totalMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity)
-    }
-
-    get availableCapacity(): UInt64 {
-        return this.totalMass.gte(this.maxCapacity)
-            ? UInt64.from(0)
-            : this.maxCapacity.subtracting(this.totalMass)
-    }
-
-    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inv.forItem(goodId)
-    }
-
-    get sellableCargo(): EntityInventory[] {
-        return this.inv.sellable
-    }
-
-    get hasSellableCargo(): boolean {
-        return this.inv.hasSellable
-    }
-
-    get sellableGoodsCount(): number {
-        return this.inv.sellableCount
-    }
-
-    get isFull(): boolean {
-        return this.totalMass.gte(this.maxCapacity)
-    }
-
-    get energyPercent(): number {
-        if (!this.generator || this.energy === undefined) return 0
-        return calcEnergyPercent(this as MovementEntity)
-    }
-
-    get needsRecharge(): boolean {
-        if (!this.generator || this.energy === undefined) return false
-        return calcNeedsRecharge(this as MovementEntity)
-    }
-
-    hasEnergyFor(distance: UInt64): boolean {
-        if (!this.engines || !this.generator || this.energy === undefined) return false
-        return hasEnergyForDistance(this as MovementEntity, distance)
-    }
-}

package/src/entities/warehouse.ts

@@ -1,136 +0,0 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import type {CoordinatesType} from '../types'
-import {Location} from './location'
-import {ScheduleAccessor} from '../scheduling/accessor'
-import {InventoryAccessor} from './inventory-accessor'
-import type {EntityInventory} from './entity-inventory'
-import * as schedule from '../scheduling/schedule'
-import type {PackedModuleInput} from './ship'
-import {decodeCraftedItemStats} from '../derivation/crafting'
-import {getModuleCapabilityType, MODULE_LOADER} from '../capabilities/modules'
-import {computeLoaderCapabilities} from './ship-deploy'
-import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
-import type {EntitySlot} from '../data/recipes-runtime'
-
-export interface WarehouseStateInput {
-    id: UInt64Type
-    owner: string
-    name: string
-    coordinates: CoordinatesType | {x: number; y: number; z?: number}
-    hullmass?: number
-    capacity: number
-    modules?: PackedModuleInput[]
-    schedule?: ServerContract.Types.schedule
-    cargo?: ServerContract.Types.cargo_item[]
-}
-
-export class Warehouse extends ServerContract.Types.entity_info {
-    private _sched?: ScheduleAccessor
-    private _inv?: InventoryAccessor
-
-    get name(): string {
-        return this.entity_name
-    }
-
-    get entityClass(): 'planetary' {
-        return 'planetary'
-    }
-
-    get canDemolish(): boolean {
-        return true
-    }
-
-    get inv(): InventoryAccessor {
-        this._inv ??= new InventoryAccessor(this)
-        return this._inv
-    }
-
-    get inventory(): EntityInventory[] {
-        return this.inv.items
-    }
-
-    get sched(): ScheduleAccessor {
-        this._sched ??= new ScheduleAccessor(this)
-        return this._sched
-    }
-
-    get isIdle(): boolean {
-        return this.is_idle
-    }
-
-    isLoading(now: Date): boolean {
-        return schedule.isLoading(this, now)
-    }
-
-    isUnloading(now: Date): boolean {
-        return schedule.isUnloading(this, now)
-    }
-
-    get location(): Location {
-        return Location.from(this.coordinates)
-    }
-
-    get totalCargoMass(): UInt64 {
-        return this.inv.totalMass
-    }
-
-    get maxCapacity(): UInt64 {
-        return UInt64.from(this.capacity)
-    }
-
-    get availableCapacity(): UInt64 {
-        const cargo = this.totalCargoMass
-        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
-    }
-
-    hasSpace(goodMass: UInt64, quantity: number): boolean {
-        return this.totalCargoMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity)
-    }
-
-    get isFull(): boolean {
-        return this.totalCargoMass.gte(this.maxCapacity)
-    }
-
-    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inv.forItem(goodId)
-    }
-
-    get orbitalAltitude(): number {
-        return this.coordinates.z?.toNumber() || 0
-    }
-
-    get totalMass(): UInt64 {
-        const hull = this.hullmass ? UInt64.from(this.hullmass) : UInt64.from(0)
-        return hull.adding(this.totalCargoMass)
-    }
-}
-
-export function computeWarehouseCapabilities(
-    modules: InstalledModule[],
-    layout: EntitySlot[]
-): {
-    loaders?: {mass: number; thrust: number; quantity: number}
-} {
-    const warehouse: {loaders?: {mass: number; thrust: number; quantity: number}} = {}
-
-    const loaderModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_LOADER)
-    if (loaderModules.length > 0) {
-        let totalMass = 0
-        let totalThrust = 0
-        let totalQuantity = 0
-        for (const m of loaderModules) {
-            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalMass += caps.mass
-            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
-            totalQuantity += caps.quantity
-        }
-        warehouse.loaders = {
-            mass: totalMass,
-            thrust: clampUint16(totalThrust),
-            quantity: totalQuantity,
-        }
-    }
-
-    return warehouse
-}