improve jettison

src/features/actors/mining-drone.ts

@@ -1,22 +1,27 @@
+import { TradeSymbol } from '../../../api'
 import { log } from '../../logging/configure-logging'
 import { ShipEntity } from '../ship/ship.entity'
 import { IWaypoint } from '../status/actions/IWaypoint'
 import { getActor } from '../status/actions/getActor'
+import { AgentEntity } from '../status/agent.entity'
 import { decisionMaker } from '../status/decisionMaker'
 import { WaypointEntity } from '../status/waypoint.entity'
 
 export const miningDroneActorFactory = (
   miningDrone: ShipEntity,
+  agent: AgentEntity,
   act: Awaited<ReturnType<typeof getActor>>,
   waypoints: WaypointEntity[],
   miningLocation: IWaypoint,
+  keep: TradeSymbol[],
 ) =>
-  decisionMaker(miningDrone, act, async (ship: ShipEntity) => {
+  decisionMaker(miningDrone, agent, act, async (ship: ShipEntity, agent: AgentEntity) => {
     await act.refuelShip(ship)
+    await act.jettisonUnwanted(miningDrone, keep)
     if (ship.nav.waypointSymbol !== miningLocation.symbol) {
       await act.navigateShip(ship, miningLocation, waypoints)
     } else if (ship.cargo.units < ship.cargo.capacity) {
-      await act.beginMining(ship)
+      await act.beginMining(ship, keep)
     } else {
       log.info('ship', `${ship.label} will wait 1 minutes, cargo hold full`)
       await act.wait(1000 * 60)

src/features/actors/shuttle.ts

@@ -8,14 +8,14 @@ import { WaypointEntity } from '../status/waypoint.entity'
 
 export const shuttleActorFactory = (
   shuttle: ShipEntity,
-  act: Awaited<ReturnType<typeof getActor>>,
   agent: AgentEntity,
+  act: Awaited<ReturnType<typeof getActor>>,
   markets: WaypointEntity[],
   miningLocation: IWaypoint,
   ships: ShipEntity[],
   sell: TradeSymbol[],
 ) =>
-  decisionMaker(shuttle, act, async (ship: ShipEntity) => {
+  decisionMaker(shuttle, agent, act, async (ship: ShipEntity, agent: AgentEntity) => {
     await act.refuelShip(ship)
     await act.jettisonUnwanted(ship, sell)
     const currentAction = ship.action?.type
@@ -31,9 +31,9 @@ export const shuttleActorFactory = (
         const dronesAtMiningLocation = ships.filter(
           (s) => s.nav.waypointSymbol === miningLocation.symbol && s.frame.symbol === 'FRAME_DRONE' && s.nav.status !== 'IN_TRANSIT',
         )
-        const droneWithCargo = dronesAtMiningLocation.find((s) => s.cargo.units > 0)
-        if (droneWithCargo) {
-          await act.transferGoods(droneWithCargo, ship, capacity)
+        const droneWithWantedCargo = dronesAtMiningLocation.find((s) => s.cargo.inventory.find((p) => sell.includes(p.symbol)))
+        if (droneWithWantedCargo) {
+          await act.transferGoods(droneWithWantedCargo, ship, capacity, sell)
           return
         }
       }

src/features/status/actions/getActor.ts

@@ -163,8 +163,10 @@ export const getActor = async (agent: AgentEntity, api: ReturnType<typeof apiFac
     )
   }
 
+  const toKeep = (keep: TradeSymbol[]) => [...keep, agent.contract?.terms.deliver?.[0].tradeSymbol].filter(Boolean) as TradeSymbol[]
+
   const jettisonUnwanted = async (ship: ShipEntity, keep: TradeSymbol[]) => {
-    const excessCargo = ship.cargo.inventory.filter((p) => !keep.includes(p.symbol))
+    const excessCargo = ship.cargo.inventory.filter((p) => !toKeep(keep).includes(p.symbol))
     await Promise.all(
       excessCargo.map(async ({ symbol, units }) => {
         log.warn('ship', `${ship.label} is jettisoning ${units}x${symbol} because it is unwanted`)
@@ -178,7 +180,7 @@ export const getActor = async (agent: AgentEntity, api: ReturnType<typeof apiFac
     )
   }
 
-  const transferGoods = async (from: ShipEntity, to: ShipEntity, units: number) => {
+  const transferGoods = async (from: ShipEntity, to: ShipEntity, units: number, wanted: TradeSymbol[]) => {
     if (from.nav.status !== to.nav.status) {
       if (from.nav.status === 'DOCKED') {
         await dockShip(to)
@@ -189,10 +191,13 @@ export const getActor = async (agent: AgentEntity, api: ReturnType<typeof apiFac
       }
     }
 
+    const toTransfer = from.cargo.inventory.find((p) => toKeep(wanted).includes(p.symbol))
+    invariant(toTransfer, `Expected ${from.label} to have ${toKeep(wanted).join(', ')} to transfer`)
+
     const payload: Parameters<typeof api.fleet.transferCargo>[1] = {
       shipSymbol: to.symbol,
-      tradeSymbol: from.cargo.inventory[0].symbol,
-      units: Math.min(units, from.cargo.inventory[0].units),
+      tradeSymbol: toTransfer.symbol,
+      units: Math.min(units, toTransfer.units),
     }
 
     const {
@@ -288,7 +293,7 @@ export const getActor = async (agent: AgentEntity, api: ReturnType<typeof apiFac
     log.info('agent', `Fulfilled contract, current credits: $${agent.data?.credits.toLocaleString()}`)
   }
 
-  const beginMining = async (ship: ShipEntity) => {
+  const beginMining = async (ship: ShipEntity, keep: TradeSymbol[]) => {
     await orbitShip(ship)
     const { seconds, distance } = shipCooldownRemaining(ship)
     if (seconds > 0) {
@@ -304,8 +309,9 @@ export const getActor = async (agent: AgentEntity, api: ReturnType<typeof apiFac
     log.info('ship', `${ship.label} mining result: is ${extraction.yield.units}x${extraction.yield.symbol}`)
     writeExtraction(agent, extraction)
     await updateShip(ship, { cargo, cooldown })
+    await jettisonUnwanted(ship, toKeep(keep))
     if (cargo.units < cargo.capacity) {
-      await beginMining(ship)
+      await beginMining(ship, toKeep(keep))
     }
   }
 

src/features/status/decisionMaker.ts

@@ -2,6 +2,7 @@ import { log } from '../../logging/configure-logging'
 import { logError } from '../../logging/log-error'
 import { ShipEntity } from '../ship/ship.entity'
 import { getActor } from './actions/getActor'
+import { AgentEntity } from './agent.entity'
 import { shipArriving } from './utils/getCurrentFlightTime'
 
 const createDecisionRateMonitor = () => {
@@ -19,15 +20,20 @@ const createDecisionRateMonitor = () => {
   }
   return { recordTimestamp, getDecisionRate }
 }
-export const decisionMaker = async (ship: ShipEntity, act: Awaited<ReturnType<typeof getActor>>, decisions: (ship: ShipEntity) => void) => {
+export const decisionMaker = async (
+  ship: ShipEntity,
+  agent: AgentEntity,
+  act: Awaited<ReturnType<typeof getActor>>,
+  decisions: (ship: ShipEntity, agent: AgentEntity) => void,
+) => {
   const { recordTimestamp, getDecisionRate } = createDecisionRateMonitor()
   const makeNextDecision = async (ship: ShipEntity) => {
     recordTimestamp()
 
     try {
       const { seconds, distance } = shipArriving(ship)
       if (seconds <= 0) {
-        await decisions(ship)
+        await decisions(ship, agent)
       } else {
         log.info('ship', `${ship.label} is not yet in position. Waiting for arrival ${distance}`)
         await act.wait(seconds * 1000)

src/features/status/startup.ts

@@ -1,5 +1,5 @@
 import lodash from 'lodash'
-import { DefaultApiFactory } from '../../../api'
+import { DefaultApiFactory, TradeSymbol } from '../../../api'
 import { getOrPopulateMarkets } from '../../db/getOrPopulateMarkets'
 import { updateShips } from '../../db/updateShips'
 import { invariant } from '../../invariant'
@@ -39,10 +39,10 @@ export async function startup() {
     },
   } = await api.systems.getSystemWaypoints(commandShip.nav.systemSymbol, undefined, 20, 'ENGINEERED_ASTEROID')
 
-  const miningDronesToPurchase = 4
+  const miningDronesToPurchase = 5
   const shuttlesToPurchase = 1
 
-  await decisionMaker(commandShip, act, async (ship: ShipEntity) => {
+  await decisionMaker(commandShip, agent, act, async (ship: ShipEntity) => {
     if (!agent.contract || agent.contract.fulfilled) {
       await act.getOrAcceptContract(ship)
       return
@@ -53,6 +53,8 @@ export async function startup() {
       return
     }
 
+    const keep: TradeSymbol[] = ['IRON_ORE', 'COPPER_ORE', 'ALUMINUM_ORE']
+
     const miningDrones = ships.filter((s) => s.frame.symbol === 'FRAME_DRONE')
     log.info('agent', `There are ${miningDrones.length} mining drones`)
     // TODO: don't hardcode the price
@@ -64,7 +66,7 @@ export async function startup() {
       idleDrones.forEach((drone) => {
         log.warn('command', `Spawning worker for ${drone.label}`)
         drone.isCommanded = true
-        miningDroneActorFactory(drone, act, markets, engineeredAsteroid)
+        miningDroneActorFactory(drone, agent, act, markets, engineeredAsteroid, keep)
       })
     }
 
@@ -78,7 +80,7 @@ export async function startup() {
       idleShuttles.forEach((ship) => {
         log.warn('command', `Spawning worker for ${ship.label}`)
         ship.isCommanded = true
-        shuttleActorFactory(ship, act, agent, markets, engineeredAsteroid, ships, ['IRON_ORE', 'COPPER_ORE', 'ALUMINUM_ORE'])
+        shuttleActorFactory(ship, agent, act, markets, engineeredAsteroid, ships, keep)
       })
     }