@shipload/sdk 2.0.0-rc2 → 2.0.0-rc4

package/src/managers/actions.ts

@@ -5,7 +5,7 @@ import {CoordinatesType, EntityType, EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
 
 interface SellableCargo {
-    good_id: {toNumber(): number} | number
+    item_id: {toNumber(): number} | number
     quantity: {toNumber(): number} | number
     hasCargo: boolean
 }
@@ -86,35 +86,35 @@ export class ActionsManager extends BaseManager {
             source_id: UInt64.from(sourceId),
             dest_type: destType,
             dest_id: UInt64.from(destId),
-            good_id: UInt16.from(goodId),
+            item_id: UInt16.from(goodId),
             quantity: UInt32.from(quantity),
         })
     }
 
-    buyGoods(
+    buyItems(
         entityId: UInt64Type,
         goodId: UInt64Type,
         quantity: UInt64Type,
         entityType: EntityTypeName = EntityType.SHIP
     ): Action {
-        return this.server.action('buygoods', {
+        return this.server.action('buyitems', {
             entity_type: entityType,
             id: UInt64.from(entityId),
-            good_id: UInt16.from(goodId),
+            item_id: UInt16.from(goodId),
             quantity: UInt32.from(quantity),
         })
     }
 
-    sellGoods(
+    sellItems(
         entityId: UInt64Type,
         goodId: UInt64Type,
         quantity: UInt64Type,
         entityType: EntityTypeName = EntityType.SHIP
     ): Action {
-        return this.server.action('sellgoods', {
+        return this.server.action('sellitems', {
             entity_type: entityType,
             id: UInt64.from(entityId),
-            good_id: UInt16.from(goodId),
+            item_id: UInt16.from(goodId),
             quantity: UInt32.from(quantity),
         })
     }
@@ -175,6 +175,18 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    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,
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }
@@ -195,6 +207,6 @@ export class ActionsManager extends BaseManager {
 
         return shipCargo
             .filter((c) => c.hasCargo)
-            .map((c) => this.sellGoods(shipId, c.good_id, c.quantity, EntityType.SHIP))
+            .map((c) => this.sellItems(shipId, c.item_id, c.quantity, EntityType.SHIP))
     }
 }

package/src/managers/locations.ts

@@ -1,6 +1,6 @@
 import {Bytes, Checksum256, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {CoordinatesType, coordsToLocationId, Distance, GoodPrice} from '../types'
+import {CoordinatesType, coordsToLocationId, Distance, ItemPrice} from '../types'
 import {marketPrice, marketPrices} from '../market/market'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
@@ -8,19 +8,19 @@ import {Location, toLocation} from '../entities/location'
 import {ServerContract} from '../contracts'
 
 export class LocationsManager extends BaseManager {
-    async getMarketPrice(location: CoordinatesType, goodId: number): Promise<GoodPrice> {
+    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<GoodPrice[]> {
+    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<GoodPrice[]> {
+    async getMarketPricesWithSupply(location: CoordinatesType): Promise<ItemPrice[]> {
         const [game, state, supplyRows] = await Promise.all([
             this.getGame(),
             this.getState(),
@@ -32,16 +32,16 @@ export class LocationsManager extends BaseManager {
         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))
+                supplyMap.set(Number(row.item_id), Number(row.supply))
             }
         }
 
         return prices.map((price) => {
             const actualSupply = supplyMap.get(Number(price.id))
             if (actualSupply !== undefined) {
-                return GoodPrice.from({
+                return ItemPrice.from({
                     id: price.id,
-                    good: price.good,
+                    item: price.item,
                     price: price.price,
                     supply: UInt64.from(actualSupply),
                 })

package/src/managers/trades.ts

@@ -8,13 +8,13 @@ import {
     CollectAnalysisCallbacks,
     CollectAnalysisOptions,
 } from '../trading/collect'
-import {Coordinates, GoodPrice} from '../types'
+import {Coordinates, ItemPrice} 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 priceCache = new Map<string, ItemPrice[]>()
     private priceCacheEpoch: UInt64 | undefined
 
     private makePriceCacheKey(location: Coordinates): string {
@@ -39,7 +39,7 @@ export class TradesManager extends BaseManager {
             return nearby.map((d) => toLocation(d.destination))
         }
 
-        const getMarketPrices = async (location: Coordinates): Promise<GoodPrice[]> => {
+        const getMarketPrices = async (location: Coordinates): Promise<ItemPrice[]> => {
             const cacheKey = this.makePriceCacheKey(location)
             const cached = this.priceCache.get(cacheKey)
             if (cached) {
@@ -53,9 +53,9 @@ export class TradesManager extends BaseManager {
                 const actualSupply = locationWithSupply.getSupply(price.id)
 
                 if (actualSupply !== undefined) {
-                    return GoodPrice.from({
+                    return ItemPrice.from({
                         id: price.id,
-                        good: price.good,
+                        item: price.item,
                         price: price.price,
                         supply: actualSupply,
                     })

package/src/market/items.ts

@@ -0,0 +1,31 @@
+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,
+        base_price: g.base_price,
+        mass: g.mass,
+        category: g.category,
+        rarity: g.rarity,
+        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/market/market.ts

@@ -1,5 +1,5 @@
-import {CoordinatesType, GoodPrice} from '../types'
-import {getGood, getGoods} from './goods'
+import {CoordinatesType, ItemPrice} from '../types'
+import {getItem, getItems} from './items'
 import {Checksum256Type, UInt16, UInt16Type, UInt32} from '@wharfkit/antelope'
 import {roll} from './rolls'
 import {ServerContract} from '../contracts'
@@ -174,9 +174,9 @@ export function marketPrice(
     goodId: UInt16Type,
     gameSeed: Checksum256Type,
     state: ServerContract.Types.state_row
-): GoodPrice {
-    const good = getGood(goodId)
-    let price = Number(good.base_price)
+): ItemPrice {
+    const item = getItem(goodId)
+    let price = Number(item.base_price)
 
     // Rarity multiplier of the deal (changes with epoch)
     // Large impact range on price, from 0.285x to 3.0x
@@ -191,9 +191,9 @@ export function marketPrice(
     // Determine the current supply of the good at the location
     const supply = getSupply(gameSeed, state, location, goodId)
 
-    return GoodPrice.from({
+    return ItemPrice.from({
         id: goodId,
-        good,
+        item,
         price: UInt32.from(price),
         supply: UInt16.from(supply),
     })
@@ -203,6 +203,6 @@ 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))
+): ItemPrice[] {
+    return getItems().map((item) => marketPrice(location, item.id, gameSeed, state))
 }

package/src/scheduling/projection.ts

@@ -10,7 +10,7 @@ import {
 } from '../types/capabilities'
 import {distanceBetweenCoordinates, lerp} from '../travel/travel'
 import {calcCargoMass} from '../capabilities/storage'
-import {getGood} from '../market/goods'
+import {getItem} from '../market/items'
 import * as schedule from './schedule'
 import {ScheduleData} from './schedule'
 
@@ -169,21 +169,21 @@ function applyFlightTask(
     }
 }
 
-function getGoodMass(good_id: UInt16 | number): UInt32 {
-    const good = getGood(good_id)
-    return good.mass
+function getItemMass(item_id: UInt16 | number): UInt32 {
+    const item = getItem(item_id)
+    return item.mass
 }
 
 function applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good_mass = getGoodMass(item.good_id)
+        const good_mass = getItemMass(item.item_id)
         projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
     }
 }
 
 function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good_mass = getGoodMass(item.good_id)
+        const good_mass = getItemMass(item.item_id)
         const cargoMass = good_mass.multiplying(item.quantity)
         projected.cargoMass = projected.cargoMass.gt(cargoMass)
             ? projected.cargoMass.subtracting(cargoMass)
@@ -206,7 +206,7 @@ function applyExtractTask(
     }
 
     for (const item of task.cargo) {
-        const good_mass = getGoodMass(item.good_id)
+        const good_mass = getItemMass(item.item_id)
         projected.cargoMass = projected.cargoMass.adding(good_mass.multiplying(item.quantity))
     }
 }

package/src/trading/collect.ts

@@ -1,7 +1,7 @@
 import {Checksum256Type, Int64, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {Ship} from '../entities/ship'
 import {Location} from '../entities/location'
-import {Coordinates, GoodPrice, ShipLike} from '../types'
+import {Coordinates, ItemPrice, ShipLike} from '../types'
 import {Deal, findDealsForShip} from './deal'
 
 import {EntityInventory} from '../entities/entity-inventory'
@@ -11,7 +11,7 @@ import {
     EstimatedTravelTime,
     estimateTravelTime,
 } from '../travel/travel'
-import {getGood, getGoods} from '../market/goods'
+import {getItem, getItems} from '../market/items'
 import {getRarity, Rarities} from '../market/market'
 import {ServerContract} from '../contracts'
 
@@ -23,7 +23,7 @@ function calculateCargoMass(cargo: EntityInventory[]): UInt32 {
     let mass = UInt32.from(0)
     for (const c of cargo) {
         if (UInt64.from(c.quantity).gt(UInt64.zero)) {
-            const goodMass = getGood(c.good_id).mass
+            const goodMass = getItem(c.item_id).mass
             mass = mass.adding(goodMass.multiplying(c.quantity))
         }
     }
@@ -102,7 +102,7 @@ export interface CollectOption {
     /** Detailed breakdown of travel time components */
     travelTimeBreakdown?: EstimatedTravelTime
     /** Info about a discounted good at the destination (for explore options) */
-    discountedGood?: DiscountedGoodInfo
+    discountedGood?: DiscountedItemInfo
     /** Top potential deals available at destination (for explore options) */
     potentialDeals?: PotentialDeal[]
     /** Details of cargo being sold (if selling cargo) */
@@ -190,7 +190,7 @@ export function analyzeCargoSale(
     for (const c of cargo) {
         if (UInt64.from(c.quantity).equals(UInt64.zero)) continue
 
-        const goodId = Number(c.good_id)
+        const goodId = Number(c.item_id)
         const salePrice = prices.get(goodId)
 
         if (salePrice) {
@@ -219,7 +219,7 @@ export function buildCargoSaleItems(
     for (const c of cargo) {
         if (UInt64.from(c.quantity).equals(UInt64.zero)) continue
 
-        const goodId = Number(c.good_id)
+        const goodId = Number(c.item_id)
         const salePrice = prices.get(goodId)
         const pricePerUnit = salePrice ? UInt32.from(salePrice) : UInt32.zero
         const revenue = UInt64.from(pricePerUnit).multiplying(c.quantity)
@@ -227,8 +227,8 @@ export function buildCargoSaleItems(
         const profit = Int64.from(revenue).subtracting(cost)
 
         items.push({
-            goodId: c.good_id,
-            goodName: c.good?.name ?? `Good #${goodId}`,
+            goodId: c.item_id,
+            goodName: c.item?.name ?? `Item #${goodId}`,
             quantity: UInt32.from(c.quantity),
             pricePerUnit,
             revenue,
@@ -271,10 +271,10 @@ export function createSellAndTradeOption(
         : undefined
 
     return {
-        id: `sell-trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.good.id}`,
+        id: `sell-trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.item.id}`,
         type: 'sell-and-trade',
-        title: `Trade ${deal.good.good.name}`,
-        description: `Sell cargo, buy ${deal.maxQuantity} ${deal.good.good.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
+        title: `Trade ${deal.item.item.name}`,
+        description: `Sell cargo, buy ${deal.maxQuantity} ${deal.item.item.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
         reason: `${deal.marginPercent.toFixed(0)}% margin, ${deal.profitPerSecond.toFixed(
             1
         )}/s profit rate`,
@@ -363,7 +363,7 @@ export function createSellAndRepositionOption(
         id: `sell-reposition-${reposition.location.coordinates.x}-${reposition.location.coordinates.y}`,
         type: 'sell-and-reposition',
         title: 'Sell & Move',
-        description: `Sell cargo here, travel empty to buy ${deal.good.good.name}`,
+        description: `Sell cargo here, travel empty to buy ${deal.item.item.name}`,
         reason: `No good trades here — ${deal.marginPercent.toFixed(
             0
         )}% margin trade available at destination`,
@@ -455,7 +455,7 @@ export interface CargoSaleItem {
 /**
  * Info about a discounted good for explore options
  */
-export interface DiscountedGoodInfo {
+export interface DiscountedItemInfo {
     goodId: number
     name: string
     rarity: string
@@ -479,7 +479,7 @@ export interface PotentialDeal {
 export function createExploreOption(
     destination: Location,
     travelTime?: UInt32,
-    discountedGood?: DiscountedGoodInfo,
+    discountedGood?: DiscountedItemInfo,
     travelTimeBreakdown?: EstimatedTravelTime,
     potentialDeals?: PotentialDeal[]
 ): CollectOption {
@@ -536,7 +536,7 @@ export function createExploreOption(
  */
 export interface CollectAnalysisCallbacks {
     getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>
-    getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>
+    getMarketPrices: (location: Coordinates) => Promise<ItemPrice[]>
     getGameSeed?: () => Checksum256Type
     getState?: () => ServerContract.Types.state_row
 }
@@ -582,10 +582,10 @@ export async function analyzeCollectOptions(
     )
 
     if (hasCargo && dealsAtOrigin.length > 0) {
-        const cargoGoodIds = new Set(cargo.map((c) => Number(c.good_id)))
+        const cargoGoodIds = new Set(cargo.map((c) => Number(c.item_id)))
 
         for (const deal of dealsAtOrigin.slice(0, 3)) {
-            const dealGoodId = Number(deal.good.id)
+            const dealGoodId = Number(deal.item.id)
             if (cargoGoodIds.has(dealGoodId)) {
                 continue
             }
@@ -767,10 +767,10 @@ export async function analyzeCollectOptions(
     if (!hasCargo && dealsAtOrigin.length > 0) {
         for (const deal of dealsAtOrigin.slice(0, 3)) {
             const option: CollectOption = {
-                id: `trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.good.id}`,
+                id: `trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.item.id}`,
                 type: 'sell-and-trade',
-                title: `Trade ${deal.good.good.name}`,
-                description: `Buy ${deal.maxQuantity} ${deal.good.good.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
+                title: `Trade ${deal.item.item.name}`,
+                description: `Buy ${deal.maxQuantity} ${deal.item.item.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
                 reason: `${deal.marginPercent.toFixed(0)}% margin, ${deal.profitPerSecond.toFixed(
                     1
                 )}/s profit rate`,
@@ -804,7 +804,7 @@ export async function analyzeCollectOptions(
             dest: Location
             travelTime: UInt32
             travelTimeBreakdown: EstimatedTravelTime
-            discountedGood?: DiscountedGoodInfo
+            discountedGood?: DiscountedItemInfo
             bestDiscount: number
             potentialDeals?: PotentialDeal[]
             score: number
@@ -821,11 +821,11 @@ export async function analyzeCollectOptions(
                 unloadMass,
             })
 
-            let discountedGood: DiscountedGoodInfo | undefined
+            let discountedGood: DiscountedItemInfo | undefined
             let bestDiscount = 0
 
             if (gameSeed && state) {
-                const allGoods = getGoods()
+                const allGoods = getItems()
                 for (const good of allGoods) {
                     const rarity = getRarity(gameSeed, state.seed, dest.coordinates, good.id)
                     if (rarity.minMultiplier < 1.0) {
@@ -862,8 +862,8 @@ export async function analyzeCollectOptions(
             )
 
             const potentialDeals: PotentialDeal[] = destDeals.map((d) => ({
-                goodId: Number(d.good.id),
-                goodName: d.good.good.name,
+                goodId: Number(d.item.id),
+                goodName: d.item.item.name,
                 destinationCoords: d.destination.coordinates,
                 marginPercent: d.marginPercent,
                 profitPerSecond: d.profitPerSecond,

package/src/trading/deal.ts

@@ -1,5 +1,5 @@
 import {Int64, UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
-import {Coordinates, GoodPrice, PRECISION, ShipLike} from '../types'
+import {Coordinates, ItemPrice, PRECISION, ShipLike} from '../types'
 import {Location} from '../entities/location'
 import {Ship} from '../entities/ship'
 import {
@@ -17,8 +17,8 @@ export interface Deal {
     origin: Location
     /** Destination location */
     destination: Location
-    /** Good to trade */
-    good: GoodPrice
+    /** Item to trade */
+    item: ItemPrice
     /** Distance between origin and destination */
     distance: UInt64
     /** Available supply at origin */
@@ -68,7 +68,7 @@ export async function findDealsForShip(
     ship: Ship,
     originLocation: Coordinates,
     getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>,
-    getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>,
+    getMarketPrices: (location: Coordinates) => Promise<ItemPrice[]>,
     options: FindDealsOptions = {}
 ): Promise<Deal[]> {
     const {
@@ -123,7 +123,7 @@ export async function findDealsForShip(
                 balance !== undefined
                     ? balance.dividing(originGood.price)
                     : UInt64.from(Number.MAX_SAFE_INTEGER)
-            const canHaul = effectiveAvailableMass.dividing(originGood.good.mass)
+            const canHaul = effectiveAvailableMass.dividing(originGood.item.mass)
             const supplyLimit = UInt64.from(originGood.supply)
 
             // Find minimum of canAfford, canHaul, supplyLimit
@@ -134,7 +134,7 @@ export async function findDealsForShip(
             if (maxQuantity.equals(UInt64.zero)) continue
 
             // Calculate travel time with cargo (includes recharge + load time)
-            const cargoMass = originGood.good.mass.multiplying(maxQuantity)
+            const cargoMass = originGood.item.mass.multiplying(maxQuantity)
             const availableSpaceUInt = UInt64.from(availableSpace)
             const baseMass =
                 availableSpace !== undefined
@@ -161,7 +161,7 @@ export async function findDealsForShip(
             deals.push({
                 origin,
                 destination: destLocation,
-                good: originGood,
+                item: originGood,
                 distance,
                 supply: originGood.supply,
                 buyPrice: originGood.price,
@@ -190,7 +190,7 @@ export async function findBestDeal(
     ship: Ship,
     originLocation: Coordinates,
     getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>,
-    getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>,
+    getMarketPrices: (location: Coordinates) => Promise<ItemPrice[]>,
     options: FindDealsOptions = {}
 ): Promise<Deal | undefined> {
     const deals = await findDealsForShip(

package/src/trading/trade.ts

@@ -1,7 +1,7 @@
 import {Int64, Int64Type, UInt32, UInt32Type, UInt64} from '@wharfkit/antelope'
 import {Ship} from '../entities/ship'
 import {Player} from '../entities/player'
-import {GoodPrice} from '../types'
+import {ItemPrice} from '../types'
 
 /**
  * Trade calculation result
@@ -53,10 +53,10 @@ export function calculateUpdatedCargoCost(
 export function calculateMaxTradeQuantity(
     ship: Ship,
     player: Player,
-    goodPrice: GoodPrice
+    goodPrice: ItemPrice
 ): TradeCalculation {
     const pricePerUnit = UInt32.from(goodPrice.price)
-    const massPerUnit = UInt32.from(goodPrice.good.mass)
+    const massPerUnit = UInt32.from(goodPrice.item.mass)
 
     const spaceForQuantity = ship.availableCapacity.dividing(massPerUnit)
     const affordableQuantity = player.balance.dividing(pricePerUnit)
@@ -128,21 +128,21 @@ export function calculateProfitPerSecond(profit: Int64Type, travelTimeSeconds: U
 /**
  * Find the best good to trade between two locations
  */
-export function findBestGoodToTrade(
+export function findBestItemToTrade(
     ship: Ship,
     player: Player,
-    originPrices: GoodPrice[],
-    destPrices: GoodPrice[],
+    originPrices: ItemPrice[],
+    destPrices: ItemPrice[],
     travelTimeSeconds: UInt32Type
 ): {
-    good: GoodPrice
+    item: ItemPrice
     quantity: number
     profit: number
     profitPerSecond: number
     margin: number
 } | null {
     let bestTrade: {
-        good: GoodPrice
+        item: ItemPrice
         quantity: number
         profit: number
         profitPerSecond: number
@@ -169,7 +169,7 @@ export function findBestGoodToTrade(
         if (profitPerSecond > bestProfitPerSecond) {
             bestProfitPerSecond = profitPerSecond
             bestTrade = {
-                good: originPrice,
+                item: originPrice,
                 quantity: calc.maxQuantity,
                 profit: Number(tradeResult.profit),
                 profitPerSecond,

package/src/travel/travel.ts

@@ -31,7 +31,7 @@ import {
     ShipLike,
     TaskType,
 } from '../types'
-import {getGood} from '../market/goods'
+import {getItem} from '../market/items'
 import {hasSystem} from '../utils/system'
 
 export function calc_orbital_altitude(mass: number): number {
@@ -165,7 +165,7 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
     }
 
     for (const cargo of cargos) {
-        mass.add(getGood(cargo.good_id).mass.multiplying(cargo.quantity))
+        mass.add(getItem(cargo.item_id).mass.multiplying(cargo.quantity))
     }
 
     return mass
@@ -183,9 +183,9 @@ export function calculateTransferTime(
     let mass = UInt64.from(0)
 
     for (const cargo of cargos) {
-        const qty = quantities?.get(Number(cargo.good_id)) ?? 0
+        const qty = quantities?.get(Number(cargo.item_id)) ?? 0
         if (qty > 0) {
-            const good_mass = getGood(cargo.good_id).mass
+            const good_mass = getItem(cargo.item_id).mass
             const cargo_mass = good_mass.multiplying(qty)
             mass = UInt64.from(mass).adding(cargo_mass)
         }
@@ -231,12 +231,12 @@ export function calculateLoadTimeBreakdown(
     let mass_load = UInt64.from(0)
 
     for (const cargo of cargos) {
-        const goodId = Number(cargo.good_id)
+        const goodId = Number(cargo.item_id)
         const loadQty = loadQuantities?.get(goodId) ?? 0
         const unloadQty = unloadQuantities?.get(goodId) ?? 0
 
         if (loadQty > 0 || unloadQty > 0) {
-            const good = getGood(cargo.good_id)
+            const good = getItem(cargo.item_id)
 
             if (loadQty > 0) {
                 const cargo_mass = good.mass.multiplying(loadQty)