From a34e4fbed4b6c2eb2440361178bc6cf213e6657c Mon Sep 17 00:00:00 2001 From: Julien Dessaux Date: Sun, 31 Mar 2024 09:44:49 +0200 Subject: [node] implemented basic procurement trading loop --- nodejs/automation/contracting.ts | 148 ++++++++++++++++++++++++++++----------- nodejs/automation/init.ts | 7 +- nodejs/database/ships.ts | 7 +- nodejs/lib/ships.ts | 14 ++++ nodejs/main.ts | 2 +- 5 files changed, 132 insertions(+), 46 deletions(-) diff --git a/nodejs/automation/contracting.ts b/nodejs/automation/contracting.ts index 7fc8877..02715c8 100644 --- a/nodejs/automation/contracting.ts +++ b/nodejs/automation/contracting.ts @@ -7,64 +7,132 @@ import * as dbShips from '../database/ships.ts'; import * as api from '../lib/api.ts'; import * as contracts from '../lib/contracts.ts'; import * as libShips from '../lib/ships.ts'; +import * as libSystems from '../lib/systems.ts'; import * as systems from '../lib/systems.ts'; import * as utils from '../lib/utils.ts'; -export async function init() { - const cs = dbContracts.getContracts().filter(c => !c.fulfilled); - cs.forEach(contract => run(contract)); +export async function init(): Promise { + const ship = dbShips.getShips()[0]; // This should always be the command ship + while(true) { // we use the fact that there can only be at most one active contract at a time + const contracts = dbContracts.getContracts().filter(c => !c.fulfilled); + let contract: Contract; + if (contracts.length === 0) { + contract = await libShips.negotiate(ship); + } else { + contract = contracts[0]; + } + await run(contract, ship); + await libShips.negotiate(ship); + } } -async function run(contract: Contract) { +async function run(contract: Contract, ship: Ship): Promise { await contracts.accept(contract); - const contractSystem = utils.systemFromWaypoint(contract.terms.deliver[0].destinationSymbol); - let ships = dbShips.getShipsAt(contractSystem); - ships = ships.filter(ship => ship.registration.role !== 'SATELLITE'); // filter out probes - switch(contract.type) { case 'PROCUREMENT': - await runProcurement(contract, ships); + if (contract.terms.deliver[0].tradeSymbol.match(/_ORE$/)) { + await runOreProcurement(contract, ship); + } else { + await runTradeProcurement(contract, ship); + } break; default: throw `Handling of contract type ${contract.type} is not implemented yet`; } } -async function runProcurement(contract: Contract, ships: Array) { - // TODO check if contract is fulfilled! +async function runOreProcurement(contract: Contract, ship: Ship): Promise { const wantedCargo = contract.terms.deliver[0].tradeSymbol; const deliveryPoint = contract.terms.deliver[0].destinationSymbol; - const asteroids = await systems.type(ships[0].nav.systemSymbol, 'ENGINEERED_ASTEROID'); + const asteroids = await systems.type(ship.nav.systemSymbol, 'ENGINEERED_ASTEROID'); const asteroidSymbol = asteroids[0].symbol; - ships.forEach(async function(ship) { - while (true) { - while (!contract.fulfilled) { - ship = dbShips.getShip(ship.symbol); - let goodCargo = ship.cargo.inventory.filter(i => i.symbol === wantedCargo)[0] - // If we are in transit, we wait until we arrive - const delay = new Date(ship.nav.route.arrival).getTime() - new Date().getTime(); - if (delay > 0) await api.sleep(delay); - // Then it depends on where we are - switch (ship.nav.waypointSymbol) { - case asteroidSymbol: - await mining.mineUntilFullFor(contract, ship, asteroidSymbol); - await libShips.navigate(ship, deliveryPoint); - break; - case deliveryPoint: - if (goodCargo !== undefined) { // we could be here if a client restart happens right after selling before we navigate away - contract = await contracts.deliver(contract, ship); - if (contract.fulfilled) break; - } - await libShips.navigate(ship, asteroidSymbol); - break; - default: - if (await libShips.isFull(ship)) { - await selling.sell(ship, wantedCargo); - } - await libShips.navigate(ship, asteroidSymbol); + while (!contract.fulfilled) { + ship = dbShips.getShip(ship.symbol); + const goodCargo = ship.cargo.inventory.filter(i => i.symbol === wantedCargo)[0] + // what we do depends on where we are + switch (ship.nav.waypointSymbol) { + case asteroidSymbol: + await mining.mineUntilFullFor(contract, ship, asteroidSymbol); + await libShips.navigate(ship, deliveryPoint); + break; + case deliveryPoint: + if (goodCargo !== undefined) { // we could be here if a client restart happens right after selling before we navigate away + contract = await contracts.deliver(contract, ship); + if (contract.fulfilled) return; + } + await libShips.navigate(ship, asteroidSymbol); + break; + default: + await selling.sell(ship, wantedCargo); + await libShips.navigate(ship, asteroidSymbol); + } + } +} + +async function runTradeProcurement(contract: Contract, ship: Ship): Promise { + const deliver = contract.terms.deliver[0]; + const deliveryPoint = deliver.destinationSymbol; + const wantedCargo = deliver.tradeSymbol; + while (!contract.fulfilled) { + ship = dbShips.getShip(ship.symbol); + const goodCargo = ship.cargo.inventory.filter(i => i.symbol === wantedCargo)[0] + // make sure we are not carrying useless stuff + await selling.sell(ship, wantedCargo); + // go buy what we need + const rawMarkets = await libSystems.trait(ship.nav.systemSymbol, 'MARKETPLACE'); + // sorted by distance from where we are + const markets = rawMarkets.map(function (m) { return { + data: m, + distance: (m.x - ship.nav.route.destination.x) ** 2 + (m.y - ship.nav.route.destination.y) ** 2, + }}); + markets.sort(function(a, b) { + if (a.distance < b.distance) { + return -1; + } else if (a.distance > b.distance) { + return 1; + } + return 0; + }); + // check from the closest one that exports what we need + let buyingPoint: string = null; + outer: for (let i = 0; i < markets.length; i++) { + const waypointSymbol = markets[i].data.symbol; + const market = await libSystems.market(waypointSymbol); + for (let j = 0; j < market.exports; j++) { + if (market.exports[j].symbol === wantedCargo) { + buyingPoint = market.symbol; + break outer; } } - contract = await libShips.negotiate(ship); // TODO that's not correct, the procurement type can change } - }); + // if we did not find an exporting market we look for an exchange + if (buyingPoint === null) { + outer: for (let i = 0; i < markets.length; i++) { + const waypointSymbol = markets[i].data.symbol; + const market = await libSystems.market(waypointSymbol); + for (let j = 0; j < market.exchanges; j++) { + if (market.exports[j].symbol === wantedCargo) { + buyingPoint = market.symbol; + break outer; + } + } + } + } + if (buyingPoint === null) { + throw `runTradeProcurement failed, no market exports or exchanges ${wantedCargo}`; + } + // go buy what we need + await libShips.navigate(ship, buyingPoint); + const units = Math.min( + deliver.unitsRequired - deliver.unitsFulfilled, + ship.cargo.capacity - ship.cargo.units, + ); + await libShips.buy(ship, wantedCargo, units); + // then make a delivery + await libShips.navigate(ship, deliveryPoint); + contract = await contracts.deliver(contract, ship); + if (contract.fulfilled) return; + } + console.log("runTradeProcurement not implemented"); + throw "not implemented"; } diff --git a/nodejs/automation/init.ts b/nodejs/automation/init.ts index 74f42fb..79c5e39 100644 --- a/nodejs/automation/init.ts +++ b/nodejs/automation/init.ts @@ -8,6 +8,7 @@ import { Response } from '../model/api.ts'; import { Contract } from '../model/contract.ts'; import { Ship } from '../model/ship.ts'; import * as api from '../lib/api.ts'; +//import * as agents from '../lib/angent.ts'; import * as libContracts from '../lib/contracts.ts'; import * as libShips from '../lib/ships.ts'; @@ -30,10 +31,8 @@ export async function init(): Promise { switch(json.error?.code) { case 4111: // 4111 means the agent symbol has already been claimed so no server reset happened // TODO await agents.agents(); - const contracts = await libContracts.getContracts(); - const ongoing = contracts.filter(c => !c.fulfilled); - const ships = await libShips.getShips(); - if (ongoing.length === 0) libShips.negotiate(ships[0]); + await libContracts.getContracts(); + await libShips.getShips(); return; default: throw json; diff --git a/nodejs/database/ships.ts b/nodejs/database/ships.ts index 5ea2ffa..c827db8 100644 --- a/nodejs/database/ships.ts +++ b/nodejs/database/ships.ts @@ -5,6 +5,7 @@ import { Fuel, Nav, Ship } from '../model/ship.ts'; const addShipStatement = db.prepare(`INSERT INTO ships(data) VALUES (json(?));`); const getShipStatement = db.prepare(`SELECT data FROM ships WHERE data->>'symbol' = ?;`); const getShipsAtStatement = db.prepare(`SELECT data FROM ships WHERE data->>'$.nav.systemSymbol' = ?;`); +const getShipsStatement = db.prepare(`SELECT data FROM ships;`); const setShipCargoStatement = db.prepare(`UPDATE ships SET data = (SELECT json_set(data, '$.cargo', json(:cargo)) FROM ships WHERE data->>'symbol' = :symbol) WHERE data->>'symbol' = :symbol;`); const setShipFuelStatement = db.prepare(`UPDATE ships SET data = (SELECT json_set(data, '$.fuel', json(:fuel)) FROM ships WHERE data->>'symbol' = :symbol) WHERE data->>'symbol' = :symbol;`); const setShipNavStatement = db.prepare(`UPDATE ships SET data = (SELECT json_set(data, '$.nav', json(:nav)) FROM ships WHERE data->>'symbol' = :symbol) WHERE data->>'symbol' = :symbol;`); @@ -16,12 +17,16 @@ export function getShip(symbol: string): Ship { return JSON.parse(data.data); } +export function getShips(): Array { + const data = getShipsStatement.all() as Array; + return data.map(elt => JSON.parse(elt.data)); +} + export function getShipsAt(symbol: string): Array { const data = getShipsAtStatement.all(symbol) as Array; return data.map(elt => JSON.parse(elt.data)); } - export function setShip(data: Ship): void { const changes = updateShipStatement.run({ data: JSON.stringify(data), diff --git a/nodejs/lib/ships.ts b/nodejs/lib/ships.ts index 8fd3a6f..83b2e86 100644 --- a/nodejs/lib/ships.ts +++ b/nodejs/lib/ships.ts @@ -9,6 +9,20 @@ import * as dbShips from '../database/ships.ts'; //import * as dbSurveys from '../database/surveys.ts'; import * as systems from '../lib/systems.ts'; +export async function buy(ship: Ship, tradeSymbol: string, units: number): Promise { + if (units <= 0) return; + ship = await getShip(ship); + await dock(ship); + // TODO take into account the tradevolume, we might need to buy in multiple steps + const response = await api.send<{agent: Agent, cargo: Cargo}>({endpoint: `/my/ships/${ship.symbol}/purchase`, method: 'POST', payload: { symbol: tradeSymbol, units: units }}); // TODO transaction field + if (response.error) { + api.debugLog(response); + throw response; + } + dbShips.setShipCargo(ship.symbol, response.data.cargo); + dbAgents.setAgent(response.data.agent); +} + export async function dock(ship: Ship): Promise { ship = await getShip(ship); if (ship.nav.status === 'DOCKED') return; diff --git a/nodejs/main.ts b/nodejs/main.ts index e07f331..dfb7d89 100755 --- a/nodejs/main.ts +++ b/nodejs/main.ts @@ -6,5 +6,5 @@ import * as autoInit from './automation/init.ts'; await autoInit.init(); -autoContracting.init(); +await autoContracting.init(); //autoExploring.init(); -- cgit v1.2.3