0ptr/nullptr/commander.py

from nullptr.command_line import CommandLine
from nullptr.store import Store
from nullptr.analyzer import  Analyzer
import argparse
from nullptr.models.agent import Agent
from nullptr.models.system import System
from nullptr.models.waypoint import Waypoint
from nullptr.models.marketplace import Marketplace
from nullptr.models.jumpgate import Jumpgate
from nullptr.api import Api
from .util import *
from time import sleep, time
from threading import Thread
from nullptr.atlas_builder import  AtlasBuilder

class Commander(CommandLine):
  def __init__(self, store_dir='data'):
    self.store_dir = store_dir
    self.store = Store(store_dir)
    self.store.load()
    self.agent = self.select_agent()
    self.api = Api(self.store, self.agent)
    self.atlas_builder = AtlasBuilder(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)
      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)
    return agent
      
  def after_cmd(self):
    self.store.flush()
      
  def do_info(self):
    pprint(self.api.info(), 100)
    
  def do_register(self, faction):
    self.api.register(faction.upper())
  
  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_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 = ','.join(w.traits)
      print(w.symbol, traits)

  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):
    waypoint = self.store.get(Waypoint, waypoint_str.upper())
    r = self.api.jumps(waypoint)
    pprint(r)
  
  def do_query(self):
    location = self.ask_obj(System, 'Where are you? ')
    resource = input('what resource?').upper()
    sellbuy = self.ask_multichoice(['sell','buy'], 'do you want to sell or buy?')
    print('Found markets:')
    for m in self.analyzer.find_markets(resource, sellbuy):
      system = self.store.get(System, m.system())
      p = self.analyzer.find_path(location, system)
      if p is None: continue
      print(m, f'{len(p)-1} hops')
      
  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_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(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.store.get('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)