395 lines
12 KiB
Python
395 lines
12 KiB
Python
from nullptr.command_line import CommandLine
|
|
from nullptr.store import Store
|
|
from nullptr.analyzer import Analyzer
|
|
import argparse
|
|
from nullptr.models import *
|
|
from nullptr.api import Api
|
|
from .util import *
|
|
from time import sleep, time
|
|
from threading import Thread
|
|
from nullptr.atlas_builder import AtlasBuilder
|
|
from nullptr.central_command import CentralCommand
|
|
class CommandError(Exception):
|
|
pass
|
|
|
|
class Commander(CommandLine):
|
|
def __init__(self, store_file='data/store.npt'):
|
|
self.store = Store(store_file)
|
|
self.agent = self.select_agent()
|
|
self.api = Api(self.store, self.agent)
|
|
self.atlas_builder = AtlasBuilder(self.store, self.api)
|
|
self.centcom = CentralCommand(self.store, self.api)
|
|
self.analyzer = Analyzer(self.store)
|
|
self.ship = None
|
|
|
|
self.stop_auto= False
|
|
super().__init__()
|
|
|
|
def prompt(self):
|
|
if self.ship:
|
|
return f'{self.ship.symbol}> '
|
|
else:
|
|
return '> '
|
|
|
|
def has_ship(self):
|
|
if self.ship is not None:
|
|
return True
|
|
else:
|
|
print('set a ship')
|
|
|
|
def ask_obj(self, typ, prompt):
|
|
obj = None
|
|
while obj is None:
|
|
symbol = input(prompt).strip()
|
|
obj = self.store.get(typ, symbol.upper())
|
|
if obj is None:
|
|
print('not found')
|
|
return obj
|
|
|
|
def select_agent(self):
|
|
agents = self.store.all(Agent)
|
|
agent = next(agents, None)
|
|
if agent is None:
|
|
symbol = input('agent name: ')
|
|
agent = self.store.get(Agent, symbol, create=True)
|
|
api = Api(self.store, agent)
|
|
faction = input('faction: ')
|
|
api.register(faction.upper().strip())
|
|
self.store.flush()
|
|
return agent
|
|
|
|
def resolve(self, typ, arg):
|
|
arg = arg.upper()
|
|
matches = [c for c in self.store.all(typ) if c.symbol.startswith(arg)]
|
|
if len(matches) == 1:
|
|
return matches[0]
|
|
elif len(matches) > 1:
|
|
raise CommandError('multiple matches')
|
|
else:
|
|
raise CommandError('not found')
|
|
|
|
def after_cmd(self):
|
|
self.store.flush()
|
|
|
|
def do_info(self, arg=''):
|
|
if arg.startswith('r'):
|
|
self.api.info()
|
|
|
|
pprint(self.agent, 100)
|
|
|
|
def do_auto(self):
|
|
self.centcom.run_interactive()
|
|
|
|
def print_mission(self):
|
|
print(f'mission: {self.ship.mission} ({self.ship.mission_status})')
|
|
pprint(self.ship.mission_state)
|
|
|
|
def do_mission(self, arg=''):
|
|
if not self.has_ship(): return
|
|
if arg:
|
|
self.centcom.init_mission(self.ship, arg)
|
|
self.print_mission()
|
|
|
|
def do_mreset(self):
|
|
if not self.has_ship(): return
|
|
self.ship.mission_state = {}
|
|
|
|
def do_mset(self, nm, val):
|
|
if not self.has_ship(): return
|
|
self.centcom.set_mission_param(self.ship, nm, val)
|
|
|
|
def active_contract(self):
|
|
for c in self.store.all('Contract'):
|
|
if c.accepted and not c.fulfilled: return c
|
|
raise CommandError('no active contract')
|
|
|
|
def do_cmine(self):
|
|
if not self.has_ship(): return
|
|
site = self.ship.location
|
|
contract = self.active_contract()
|
|
delivery = contract.unfinished_delivery()
|
|
if delivery is None:
|
|
raise CommandError('no delivery')
|
|
resource = delivery['trade_symbol']
|
|
destination = delivery['destination']
|
|
self.centcom.init_mission(self.ship, 'mine')
|
|
self.centcom.set_mission_param(self.ship, 'site', site)
|
|
self.centcom.set_mission_param(self.ship, 'resource', resource)
|
|
self.centcom.set_mission_param(self.ship, 'dest', destination)
|
|
self.centcom.set_mission_param(self.ship, 'contract', contract)
|
|
self.print_mission()
|
|
|
|
def do_chaul(self):
|
|
if not self.has_ship(): return
|
|
if len(self.ship.cargo) > 0:
|
|
raise CommandError('please dump cargo first')
|
|
contract = self.active_contract()
|
|
delivery = contract.unfinished_delivery()
|
|
if delivery is None:
|
|
raise CommandError('no delivery')
|
|
resource = delivery['trade_symbol']
|
|
destination = delivery['destination']
|
|
m = self.analyzer.find_closest_markets(resource, 'buy', destination)
|
|
if len(m) == 0:
|
|
m = self.analyzer.find_closest_markets(resource, 'exchange', destination)
|
|
if len(m) == 0:
|
|
print('no market found')
|
|
return
|
|
_, m, _, _ = m[0]
|
|
site = self.store.get(Waypoint, m.symbol)
|
|
self.centcom.init_mission(self.ship, 'haul')
|
|
self.centcom.set_mission_param(self.ship, 'site', site)
|
|
self.centcom.set_mission_param(self.ship, 'resource', resource)
|
|
self.centcom.set_mission_param(self.ship, 'dest', destination)
|
|
self.centcom.set_mission_param(self.ship, 'contract', contract)
|
|
self.print_mission()
|
|
|
|
def do_cprobe(self):
|
|
if not self.has_ship(): return
|
|
contract = self.active_contract()
|
|
delivery = contract.unfinished_delivery()
|
|
if delivery is None:
|
|
raise CommandError('no delivery')
|
|
resource = delivery['trade_symbol']
|
|
destination = delivery['destination']
|
|
m = self.analyzer.find_closest_markets(resource, 'buy,exchange', destination)
|
|
if len(m) is None:
|
|
print('no market found')
|
|
return
|
|
markets = [ mkt[1] for mkt in m]
|
|
markets = self.analyzer.solve_tsp(markets)
|
|
self.centcom.init_mission(self.ship, 'probe')
|
|
self.centcom.set_mission_param(self.ship, 'hops', markets)
|
|
self.print_mission()
|
|
|
|
def do_travel(self, dest):
|
|
dest = self.resolve('Waypoint', dest)
|
|
self.centcom.init_mission(self.ship, 'travel')
|
|
self.centcom.set_mission_param(self.ship, 'dest', dest)
|
|
self.print_mission()
|
|
|
|
def do_register(self, faction):
|
|
self.api.register(faction.upper())
|
|
pprint(self.api.agent)
|
|
|
|
def do_universe(self, page=1):
|
|
self.atlas_builder.run(page)
|
|
|
|
def do_systems(self, page=1):
|
|
r = self.api.list_systems(int(page))
|
|
pprint(self.api.last_meta)
|
|
|
|
def do_stats(self):
|
|
total = 0
|
|
for t in self.store.data:
|
|
num = len(self.store.data[t])
|
|
nam = t.__name__
|
|
total += num
|
|
print(f'{num:5d} {nam}')
|
|
print(f'{total:5d} total')
|
|
|
|
def do_waypoints(self, system_str=''):
|
|
if system_str == '':
|
|
if not self.has_ship(): return
|
|
system = self.ship.location.system
|
|
else:
|
|
system = self.store.get(System, system_str)
|
|
r = self.store.all_members(system, 'Waypoint')
|
|
for w in r:
|
|
traits = []
|
|
if 'MARKETPLACE' in w.traits:
|
|
traits.append('MARKET')
|
|
if 'SHIPYARD' in w.traits:
|
|
traits.append('SHIPYARD')
|
|
if w.type == 'JUMP_GATE':
|
|
traits.append('JUMP')
|
|
if w.type == 'ASTEROID_FIELD':
|
|
traits.append('ASTROIDS')
|
|
print(w.symbol.split('-')[2], ', '.join(traits))
|
|
|
|
def do_wp(self, s=''):
|
|
self.do_waypoints(s)
|
|
|
|
def do_marketplace(self, waypoint_str):
|
|
waypoint = self.store.get(Waypoint, waypoint_str.upper())
|
|
r = self.api.marketplace(waypoint)
|
|
|
|
def do_jumps(self, waypoint_str=None):
|
|
if waypoint_str is None:
|
|
if not self.has_ship(): return
|
|
waypoint = self.ship.location
|
|
else:
|
|
waypoint = self.store.get(Waypoint, waypoint_str.upper())
|
|
r = self.api.jumps(waypoint)
|
|
pprint(r)
|
|
|
|
def do_query(self, resource):
|
|
if not self.has_ship(): return
|
|
location = self.ship.location
|
|
resource = resource.upper()
|
|
print('Found markets:')
|
|
for typ, m, d, plen in self.analyzer.find_closest_markets(resource, 'buy,exchange',location):
|
|
price = '?'
|
|
if resource in m.prices:
|
|
price = m.prices[resource]['buy']
|
|
print(m, typ[0], f'{plen-1:3} hops {price}')
|
|
|
|
def do_path(self):
|
|
orig = self.ask_obj(System, 'from: ')
|
|
dest = self.ask_obj(System, 'to: ')
|
|
# orig = self.store.get(System, 'X1-KS52')
|
|
# dest = self.store.get(System, 'X1-DA90')
|
|
path = self.analyzer.find_path(orig, dest)
|
|
pprint(path)
|
|
|
|
def do_ships(self, arg=''):
|
|
if arg.startswith('r'):
|
|
r = self.api.list_ships()
|
|
else:
|
|
r = list(self.store.all('Ship'))
|
|
pprint(r)
|
|
|
|
def do_contracts(self, arg=''):
|
|
if arg.startswith('r'):
|
|
r = self.api.list_contracts()
|
|
else:
|
|
r = list(self.store.all('Contract'))
|
|
pprint(r)
|
|
|
|
def do_deliver(self):
|
|
if not self.has_ship(): return
|
|
site = self.ship.location
|
|
contract = self.active_contract()
|
|
delivery = contract.unfinished_delivery()
|
|
if delivery is None:
|
|
raise CommandError('no delivery')
|
|
resource = delivery['trade_symbol']
|
|
self.api.deliver(self.ship, resource, contract)
|
|
pprint(contract)
|
|
|
|
def do_fulfill(self):
|
|
contract = self.active_contract()
|
|
self.api.fulfill(contract)
|
|
|
|
def do_ship(self, arg=''):
|
|
if arg != '':
|
|
symbol = f'{self.agent.symbol}-{arg}'
|
|
ship = self.store.get('Ship', symbol)
|
|
if ship is None:
|
|
print('not found')
|
|
return
|
|
else:
|
|
self.ship = ship
|
|
pprint(self.ship)
|
|
|
|
def do_pp(self):
|
|
pprint(self.api.last_result)
|
|
|
|
def do_go(self, arg):
|
|
if not self.has_ship(): return
|
|
system = self.ship.location.system
|
|
symbol = f'{system}-{arg}'
|
|
dest = self.resolve('Waypoint', symbol)
|
|
self.api.navigate(self.ship, dest)
|
|
pprint(self.ship)
|
|
|
|
def do_dock(self):
|
|
if not self.has_ship(): return
|
|
self.api.dock(self.ship)
|
|
pprint(self.ship)
|
|
|
|
def do_orbit(self):
|
|
if not self.has_ship(): return
|
|
self.api.orbit(self.ship)
|
|
pprint(self.ship)
|
|
|
|
def do_negotiate(self):
|
|
if not self.has_ship(): return
|
|
r = self.api.negotiate(self.ship)
|
|
pprint(r)
|
|
|
|
def do_refuel(self):
|
|
if not self.has_ship(): return
|
|
r = self.api.refuel(self.ship)
|
|
pprint(self.ship)
|
|
|
|
def do_accept(self, c):
|
|
contract = self.resolve('Contract', c)
|
|
r = self.api.accept_contract(contract)
|
|
pprint(r)
|
|
|
|
def do_market(self, arg=''):
|
|
if arg == '':
|
|
if not self.has_ship(): return
|
|
waypoint = self.ship.location
|
|
else:
|
|
waypoint = self.resolve('Waypoint', arg)
|
|
r = self.api.marketplace(waypoint)
|
|
pprint(r)
|
|
|
|
def do_cargo(self):
|
|
if not self.has_ship(): return
|
|
for c, units in self.ship.cargo.items():
|
|
print(f'{units:4d} {c}')
|
|
|
|
def do_buy(self, resource, amt=None):
|
|
if not self.has_ship(): return
|
|
if amt is None:
|
|
amt = self.ship.cargo_capacity - self.ship.cargo_units
|
|
self.api.buy(self.ship, resource.upper(), amt)
|
|
self.do_cargo()
|
|
|
|
def do_sell(self, resource):
|
|
if not self.has_ship(): return
|
|
self.api.sell(self.ship, resource.upper())
|
|
self.do_cargo()
|
|
|
|
def do_dump(self, resource):
|
|
if not self.has_ship(): return
|
|
self.api.jettison(self.ship, resource.upper())
|
|
self.do_cargo()
|
|
|
|
def do_shipyard(self):
|
|
if not self.has_ship(): return
|
|
location = self.ship.location
|
|
data = self.api.shipyard(location)
|
|
for s in must_get(data, 'ships'):
|
|
print(s['type'], s['purchasePrice'])
|
|
|
|
def do_jump(self, system_str):
|
|
if not self.has_ship(): return
|
|
if '-' not in system_str:
|
|
sector = self.ship.location.system.sector.symbol
|
|
system_str = f'{sector}-{system_str}'
|
|
system = self.resolve('System', system_str)
|
|
self.api.jump(self.ship, system)
|
|
pprint(self.ship)
|
|
|
|
def do_purchase(self, ship_type):
|
|
if not self.has_ship(): return
|
|
location = self.ship.location
|
|
ship_type = ship_type.upper()
|
|
if not ship_type.startswith('SHIP'):
|
|
ship_type = 'SHIP_' + ship_type
|
|
s = self.api.purchase(ship_type, location)
|
|
pprint(s)
|
|
|
|
def do_survey(self):
|
|
if not self.has_ship(): return
|
|
r = self.api.survey(self.ship)
|
|
pprint(r)
|
|
|
|
def do_surveys(self):
|
|
pprint(list(self.store.all('Survey')))
|
|
|
|
def do_extract(self, survey_str=''):
|
|
if not self.has_ship(): return
|
|
survey = None
|
|
if survey_str != '':
|
|
survey = self.resolve('Survey', survey_str)
|
|
result = self.api.extract(self.ship, survey)
|
|
|
|
symbol = mg(result,'extraction.yield.symbol')
|
|
units = mg(result,'extraction.yield.units')
|
|
print(units, symbol)
|