570 lines
15 KiB
Python
570 lines
15 KiB
Python
from nullptr.command_line import CommandLine
|
|
from nullptr.store import Store
|
|
from nullptr.analyzer import Analyzer, Point, path_dist
|
|
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.central_command import CentralCommand
|
|
import readline
|
|
import os
|
|
from copy import copy
|
|
|
|
|
|
class CommandError(Exception):
|
|
pass
|
|
|
|
class Commander(CommandLine):
|
|
def __init__(self, data_dir='data'):
|
|
store_file = os.path.join(data_dir, 'store.npt')
|
|
hist_file = os.path.join(data_dir, 'cmd.hst')
|
|
self.cred_file = os.path.join(data_dir, 'creds.txt')
|
|
self.hist_file = hist_file
|
|
if os.path.isfile(hist_file):
|
|
readline.read_history_file(hist_file)
|
|
self.store = Store(store_file, True)
|
|
self.agent = self.select_agent()
|
|
self.api = Api(self.store, self.agent)
|
|
self.centcom = CentralCommand(self.store, self.api)
|
|
self.api.info()
|
|
self.do_create_crews()
|
|
self.analyzer = Analyzer(self.store)
|
|
self.ship = None
|
|
|
|
self.stop_auto= False
|
|
super().__init__()
|
|
|
|
######## INFRA #########
|
|
def handle_eof(self):
|
|
self.store.close()
|
|
readline.write_history_file(self.hist_file)
|
|
print("Goodbye!")
|
|
|
|
def do_pp(self):
|
|
pprint(self.api.last_result)
|
|
|
|
def prompt(self):
|
|
if self.ship:
|
|
return f'{self.ship.symbol}> '
|
|
else:
|
|
return '> '
|
|
|
|
def after_cmd(self):
|
|
self.store.flush()
|
|
|
|
def do_auto(self):
|
|
self.centcom.run_interactive()
|
|
|
|
def do_log(self, level):
|
|
ship = self.has_ship()
|
|
ship._log_level = int(level)
|
|
|
|
######## Resolvers #########
|
|
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 has_ship(self):
|
|
if self.ship is not None:
|
|
return self.ship
|
|
else:
|
|
raise CommandError('set a ship')
|
|
|
|
def select_agent(self):
|
|
agents = self.store.all(Agent)
|
|
agent = next(agents, None)
|
|
if agent is None:
|
|
agent = self.agent_setup()
|
|
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(f'{arg} not found')
|
|
|
|
def resolve_system(self, system_str):
|
|
if type(system_str) == System:
|
|
return system_str
|
|
if system_str == '':
|
|
ship = self.has_ship()
|
|
system = ship.location.system
|
|
else:
|
|
system = self.store.get(System, system_str)
|
|
return system
|
|
|
|
def resolve_waypoint(self, w):
|
|
if type(w) == Waypoint:
|
|
return w
|
|
if w == '':
|
|
ship = self.has_ship()
|
|
return ship.location
|
|
p = w.split('-')
|
|
if len(p) == 1:
|
|
ship = self.has_ship()
|
|
s = ship.location.system
|
|
w = f'{s}-{w}'
|
|
r = self.store.get(Waypoint, w)
|
|
if r is None:
|
|
raise CommandError(f'{w} not found')
|
|
return r
|
|
|
|
def resolve_ship(self, arg):
|
|
symbol = f'{self.agent.symbol}-{arg}'
|
|
ship = self.store.get('Ship', symbol)
|
|
if ship is None:
|
|
raise CommandError(f'ship {arg} not found')
|
|
return ship
|
|
|
|
######## First run #########
|
|
def agent_setup(self):
|
|
symbol = input('agent name: ')
|
|
agent = self.store.get(Agent, symbol, create=True)
|
|
self.agent = agent
|
|
api = Api(self.store, agent)
|
|
self.api = api
|
|
faction = input('faction or token: ')
|
|
if len(faction) > 50:
|
|
self.agent.token = faction
|
|
else:
|
|
self.do_register(faction)
|
|
print('=== agent:')
|
|
print(agent)
|
|
print('=== ships')
|
|
self.do_ships('r')
|
|
|
|
print('=== contracts')
|
|
self.do_contracts('r')
|
|
ship = self.store.get(Ship, symbol.upper() + '-2')
|
|
print("=== catalog initial system")
|
|
self.do_catalog(ship.location.system)
|
|
self.do_stats()
|
|
self.store.flush()
|
|
return agent
|
|
|
|
def do_token(self):
|
|
print(self.agent.token)
|
|
|
|
def do_register(self, faction):
|
|
self.api.register(faction.upper())
|
|
with open(self.cred_file, 'w') as f:
|
|
f.write(self.api.agent.symbol)
|
|
f.write('\n')
|
|
f.write(self.api.agent.token)
|
|
pprint(self.api.agent)
|
|
|
|
def do_reset(self, really):
|
|
if really != 'yes':
|
|
print('really? type: reset yes')
|
|
self.api.list_ships()
|
|
for s in self.store.all('Ship'):
|
|
self.dump(s, 'all')
|
|
self.centcom.init_mission(s, 'none')
|
|
|
|
######## Fleet #########
|
|
def do_info(self, arg=''):
|
|
if arg.startswith('r'):
|
|
self.api.info()
|
|
pprint(self.agent, 100)
|
|
|
|
def do_ships(self, arg=''):
|
|
if arg.startswith('r'):
|
|
r = self.api.list_ships()
|
|
else:
|
|
r = sorted(list(self.store.all('Ship')))
|
|
pprint(r)
|
|
|
|
def do_ship(self, arg=''):
|
|
if arg != '':
|
|
ship = self.resolve_ship(arg)
|
|
|
|
self.ship = ship
|
|
pprint(self.ship, 5)
|
|
|
|
######## Atlas #########
|
|
def do_systems(self, page=1):
|
|
r = self.api.list_systems(int(page))
|
|
pprint(self.api.last_meta)
|
|
|
|
def do_catalog(self, system_str=''):
|
|
system = self.resolve_system(system_str)
|
|
r = self.api.list_waypoints(system)
|
|
for w in r:
|
|
if 'MARKETPLACE' in w.traits:
|
|
self.api.marketplace(w)
|
|
if w.type == 'JUMP_GATE':
|
|
self.api.jumps(w)
|
|
|
|
def do_system(self, system_str):
|
|
system = self.store.get(System, system_str)
|
|
r = self.api.list_waypoints(system)
|
|
pprint(r)
|
|
|
|
def do_waypoints(self, grep=''):
|
|
loc = None
|
|
ship = self.has_ship()
|
|
loc = ship.location
|
|
system = loc.system
|
|
print(f'=== waypoints in {system}')
|
|
r = self.store.all_members(system, 'Waypoint')
|
|
for w in r:
|
|
|
|
wname = w.symbol.split('-')[2]
|
|
traits = ", ".join(w.itraits())
|
|
typ = w.type[0]
|
|
if typ not in ['F','J'] and len(traits) == 0:
|
|
continue
|
|
output = ''
|
|
if loc:
|
|
dist = loc.distance(w)
|
|
output = f'{wname:4} {typ} {dist:6} {traits}'
|
|
else:
|
|
output = f'{wname:4} {typ} {traits}'
|
|
if grep == '' or grep.lower() in output.lower():
|
|
print(output)
|
|
|
|
def do_members(self):
|
|
ship = self.has_ship()
|
|
system = ship.location.system
|
|
pprint(list(self.store.all_members(system)))
|
|
|
|
def do_wp(self, grep=''):
|
|
self.do_waypoints(grep)
|
|
|
|
######## Specials #########
|
|
def do_market(self, arg=''):
|
|
waypoint = self.resolve_waypoint(arg)
|
|
r = self.api.marketplace(waypoint)
|
|
pprint(r, 3)
|
|
|
|
def do_atlas(self, state=None):
|
|
atlas = self.store.get(Atlas, 'ATLAS')
|
|
if state is not None:
|
|
atlas.enabled = True if state == 'on' else 'off'
|
|
pprint(atlas, 5)
|
|
|
|
def do_jumps(self, waypoint_str=None):
|
|
if waypoint_str is None:
|
|
ship = self.has_ship()
|
|
waypoint = ship.location
|
|
else:
|
|
waypoint = self.store.get(Waypoint, waypoint_str.upper())
|
|
r = self.api.jumps(waypoint)
|
|
pprint(r)
|
|
|
|
def do_shipyard(self, w=''):
|
|
location = self.resolve_waypoint(w)
|
|
if location is None:
|
|
raise CommandError(f'waypoint {w} not found')
|
|
data = self.api.shipyard(location)
|
|
if 'ships' in data:
|
|
for s in must_get(data, 'ships'):
|
|
print(s['type'], s['purchasePrice'])
|
|
else:
|
|
for s in must_get(data, 'shipTypes'):
|
|
print(s['type'])
|
|
|
|
######## Commerce #########
|
|
def do_refuel(self, source='market'):
|
|
ship = self.has_ship()
|
|
from_cargo = source != 'market'
|
|
r = self.api.refuel(ship, from_cargo=from_cargo)
|
|
pprint(r)
|
|
|
|
def do_cargo(self):
|
|
ship = self.has_ship()
|
|
print(f'== Cargo {ship.cargo_units}/{ship.cargo_capacity} ==')
|
|
for c, units in ship.cargo.items():
|
|
print(f'{units:4d} {c}')
|
|
|
|
def do_buy(self, resource, amt=None):
|
|
ship = self.has_ship()
|
|
if amt is None:
|
|
amt = ship.cargo_capacity - ship.cargo_units
|
|
self.api.buy(ship, resource.upper(), amt)
|
|
self.do_cargo()
|
|
|
|
def do_sell(self, resource, amt=None):
|
|
ship = self.has_ship()
|
|
self.api.sell(ship, resource.upper(), amt)
|
|
self.do_cargo()
|
|
|
|
def dump(self, ship, resource):
|
|
if resource == 'all':
|
|
for r in ship.cargo.keys():
|
|
self.api.jettison(ship, r)
|
|
else:
|
|
self.api.jettison(ship, resource.upper())
|
|
|
|
def do_dump(self, resource):
|
|
ship = self.has_ship()
|
|
self.dump(ship, resource)
|
|
self.do_cargo()
|
|
|
|
def do_transfer(self, resource, dship, amount=None):
|
|
ship = self.has_ship()
|
|
resource = resource.upper()
|
|
avail = ship.get_cargo(resource)
|
|
if amount is None: amount = avail
|
|
amount = int(amount)
|
|
if avail < amount:
|
|
raise CommandError('resource not in cargo')
|
|
dship = self.resolve_ship(dship)
|
|
self.api.transfer(ship, dship, resource, amount)
|
|
|
|
|
|
def do_purchase(self, ship_type):
|
|
ship = self.has_ship()
|
|
location = 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)
|
|
|
|
######## Mining #########
|
|
def do_siphon(self):
|
|
ship = self.has_ship()
|
|
data = self.api.siphon(ship)
|
|
|
|
def do_survey(self):
|
|
ship = self.has_ship()
|
|
r = self.api.survey(ship)
|
|
pprint(r)
|
|
|
|
def do_surveys(self):
|
|
pprint(list(self.store.all('Survey')))
|
|
|
|
def do_extract(self, survey_str=''):
|
|
ship = self.has_ship()
|
|
survey = None
|
|
if survey_str != '':
|
|
survey = self.resolve('Survey', survey_str)
|
|
result = self.api.extract(ship, survey)
|
|
|
|
symbol = mg(result,'extraction.yield.symbol')
|
|
units = mg(result,'extraction.yield.units')
|
|
print(units, symbol)
|
|
|
|
|
|
######## Missions #########
|
|
def print_mission(self):
|
|
print(f'mission: {self.ship.mission} ({self.ship.mission_status})')
|
|
pprint(self.ship.mission_state)
|
|
|
|
def do_role(self, role):
|
|
roles = [None, 'trader', 'probe', 'siphon', 'hauler', 'surveyor', 'miner']
|
|
ship = self.has_ship()
|
|
if role == 'none':
|
|
role = None
|
|
if role not in roles:
|
|
print(f'role {role} not found. Choose from {roles}')
|
|
return
|
|
ship.role = role
|
|
|
|
def do_mission(self, arg=''):
|
|
ship = self.has_ship()
|
|
if arg:
|
|
self.centcom.init_mission(ship, arg)
|
|
self.print_mission()
|
|
|
|
def do_mrestart(self, status='init'):
|
|
ship = self.has_ship()
|
|
self.centcom.restart_mission(ship, status)
|
|
self.print_mission()
|
|
|
|
def do_mstep(self):
|
|
ship = self.has_ship()
|
|
self.centcom.single_step(ship)
|
|
self.print_mission()
|
|
|
|
def do_mreset(self):
|
|
ship = self.has_ship()
|
|
ship.mission_state = {}
|
|
|
|
def do_mset(self, nm, val):
|
|
ship = self.has_ship()
|
|
self.centcom.set_mission_param(ship, nm, val)
|
|
|
|
def do_crew(self, arg):
|
|
ship = self.has_ship()
|
|
crew = self.resolve('Crew', arg)
|
|
ship.crew = crew
|
|
pprint(ship)
|
|
|
|
######## Crews #########
|
|
def do_create_crews(self):
|
|
crews = self.centcom.create_default_crews()
|
|
for c in crews:
|
|
print(f'{c.symbol:15s} {c.site}')
|
|
|
|
######## Contracts #########
|
|
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_contracts(self, arg=''):
|
|
if arg.startswith('r'):
|
|
r = self.api.list_contracts()
|
|
else:
|
|
r = list(self.store.all('Contract'))
|
|
pprint(r)
|
|
|
|
def do_negotiate(self):
|
|
ship = self.has_ship()
|
|
r = self.api.negotiate(ship)
|
|
pprint(r)
|
|
|
|
def do_accept(self, c):
|
|
contract = self.resolve('Contract', c)
|
|
r = self.api.accept_contract(contract)
|
|
pprint(r)
|
|
|
|
def do_deliver(self):
|
|
ship = self.has_ship()
|
|
site = 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(ship, resource, contract)
|
|
pprint(contract)
|
|
|
|
def do_fulfill(self):
|
|
contract = self.active_contract()
|
|
self.api.fulfill(contract)
|
|
|
|
######## Travel #########
|
|
def do_travel(self, dest):
|
|
ship = self.has_ship()
|
|
dest = self.resolve('Waypoint', dest)
|
|
self.centcom.init_mission(ship, 'travel')
|
|
self.centcom.set_mission_param(ship, 'dest', dest)
|
|
self.print_mission()
|
|
|
|
def do_go(self, arg):
|
|
ship = self.has_ship()
|
|
system = ship.location.system
|
|
symbol = f'{system}-{arg}'
|
|
dest = self.resolve('Waypoint', symbol)
|
|
self.api.navigate(ship, dest)
|
|
pprint(ship)
|
|
|
|
def do_dock(self):
|
|
ship = self.has_ship()
|
|
self.api.dock(ship)
|
|
pprint(ship)
|
|
|
|
def do_orbit(self):
|
|
ship = self.has_ship()
|
|
self.api.orbit(ship)
|
|
pprint(ship)
|
|
|
|
def do_speed(self, speed):
|
|
ship = self.has_ship()
|
|
speed = speed.upper()
|
|
speeds = ['DRIFT', 'STEALTH','CRUISE','BURN']
|
|
if speed not in speeds:
|
|
print('please choose from:', speeds)
|
|
self.api.flight_mode(ship, speed)
|
|
|
|
def do_jump(self, waypoint_str):
|
|
ship = self.has_ship()
|
|
w = self.resolve('Waypoint', waypoint_str)
|
|
self.api.jump(ship, w)
|
|
pprint(ship)
|
|
|
|
######## Analysis #########
|
|
def do_server(self):
|
|
data = self.api.status()
|
|
pprint(data)
|
|
|
|
def do_highscore(self):
|
|
data = self.api.status()
|
|
leaders = mg(data, 'leaderboards.mostCredits')
|
|
for l in leaders:
|
|
a = mg(l,'agentSymbol')
|
|
c = mg(l, 'credits')
|
|
print(f'{a:15s} {c}')
|
|
|
|
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_defrag(self):
|
|
self.store.defrag()
|
|
|
|
def do_obj(self, oid):
|
|
if not '.' in oid:
|
|
print('Usage: obj SYMBOL.ext')
|
|
return
|
|
symbol, ext = oid.split('.')
|
|
symbol = symbol.upper()
|
|
if not ext in self.store.extensions:
|
|
raise CommandError('unknown extension')
|
|
typ = self.store.extensions[ext]
|
|
obj = self.store.get(typ, symbol)
|
|
if obj is None:
|
|
raise CommandError('object not found')
|
|
pprint(obj.__getstate__())
|
|
print('=== store ===')
|
|
h = self.store.get_header(obj)
|
|
if h:
|
|
pprint(h, 3)
|
|
else:
|
|
print('Not stored')
|
|
print('Dirty: ', obj in self.store.dirty_objects)
|
|
|
|
def do_query(self, resource):
|
|
ship = self.has_ship()
|
|
location = 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_findtrade(self):
|
|
ship = self.has_ship()
|
|
system = ship.location.system
|
|
t = self.analyzer.find_trade(system)
|
|
pprint(t)
|
|
|
|
def do_prices(self, resource=None):
|
|
ship = self.has_ship()
|
|
system = ship.location.system
|
|
prices = self.analyzer.prices(system)
|
|
if resource is not None:
|
|
prices = {resource: prices[resource.upper()]}
|
|
|
|
for res, p in prices.items():
|
|
print('==' + res)
|
|
for m in p:
|
|
print(f"{m['wp'].symbol:12s} {m['category']} {m['volume']:5d} {m['buy']:5d} {m['sell']:5d}")
|
|
|
|
def do_path(self, waypoint_str):
|
|
ship = self.has_ship()
|
|
w = self.resolve('Waypoint', waypoint_str)
|
|
p = self.analyzer.find_nav_path(ship.location, w, ship.fuel_capacity)
|
|
pprint(p)
|