adyxax/spacetraders
1
0
Fork 0
Code Issues Activity

[node] implemented basic procurement trading loop

Browse source
This commit is contained in:
Julien Dessaux 2024-03-31 09:44:49 +02:00
parent 8819cf9c67
commit a34e4fbed4
Signed by: adyxax
GPG key ID: F92E51B86E07177E
5 changed files with 132 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

148
nodejs/automation/contracting.ts
View file

@ -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<void> {
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<void> {
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<Ship>) {
// TODO check if contract is fulfilled!
async function runOreProcurement(contract: Contract, ship: Ship): Promise<void> {
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<void> {
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";
}

7
nodejs/automation/init.ts
View file

@ -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<void> {
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;

7
nodejs/database/ships.ts
View file

@ -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<Ship> {
const data = getShipsStatement.all() as Array<DbData>;
return data.map(elt => JSON.parse(elt.data));
}
export function getShipsAt(symbol: string): Array<Ship> {
const data = getShipsAtStatement.all(symbol) as Array<DbData>;
return data.map(elt => JSON.parse(elt.data));
}
export function setShip(data: Ship): void {
const changes = updateShipStatement.run({
data: JSON.stringify(data),

14
nodejs/lib/ships.ts
View file

@ -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<void> {
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<void> {
ship = await getShip(ship);
if (ship.nav.status === 'DOCKED') return;

2
nodejs/main.ts
View file

@ -6,5 +6,5 @@ import * as autoInit from './automation/init.ts';
await autoInit.init();
autoContracting.init();
await autoContracting.init();
//autoExploring.init();