Update base.py

nullptr/analyzer.py

@@ -1,6 +1,7 @@
 from nullptr.models.marketplace import Marketplace
 from nullptr.models.jumpgate import Jumpgate
 from nullptr.models.system import System
+from nullptr.models.waypoint import Waypoint
 from dataclasses import dataclass
 
 @dataclass
@@ -29,15 +30,43 @@ class Analyzer:
 
   def find_markets(self, resource, sellbuy):
     for m in self.store.all(Marketplace):
-      resources = m.imports if sellbuy == 'sell' else m.exports
-      if resource in resources:
-        yield m
+      if 'sell' in sellbuy and resource in m.imports:
+        yield ('sell', m)
+      
+      elif 'buy' in sellbuy and resource in m.exports:
+        yield ('buy', m)
+      
+      elif 'exchange' in sellbuy and resource in m.exchange:
+        yield ('exchange', m)
+        
+  def find_closest_markets(self, resource, sellbuy, location):
+    if type(location) == str:
+      location = self.store.get(Waypoint, location)
+    mkts = self.find_markets(resource, sellbuy)
+    candidates = []
+    origin = self.store.get(System, location.system())
+    for typ, m in mkts:
+      system = self.store.get(System, m.system())
+      d = origin.distance(system)
+      candidates.append((typ, m, d))
+    possibles = sorted(candidates, key=lambda m: m[2])
+    possibles = possibles[:10]
+    results = []
+    for typ,m,d in possibles:
+      system = self.store.get(System, m.system())
+      p = self.find_path(origin, system)
+      if p is None: continue
+      results.append((typ,m,d,len(p)))
+    return results
+    
+  def solve_tsp(self, waypoints):
+    # todo actually try to solve it
+    return waypoints
  
   def get_jumpgate(self, system):
     gates = self.store.all_members(system, Jumpgate)
     return next(gates, None)
    
-   
   def find_path(self, orig, to, depth=100, seen=None):
     if depth < 1: return None
     if seen is None:

nullptr/api.py

@@ -31,7 +31,7 @@ class Api:
   def request(self, method, path, data=None, need_token=True, params={}):
     try:
       return self.request_once(method, path, data, need_token, params)
-    except ApiLimitError:
+    except (ApiLimitError, requests.exceptions.Timeout):
       print('oops, hit the limit. take a break')
       sleep(10)
       return self.request_once(method, path, data, need_token, params)
@@ -221,8 +221,10 @@ class Api:
       return ship
     
   def jump(self, ship, system):
+    if type(system) == System:
+      system = system.symbol
     data = {
-      "systemSymbol": system.symbol
+      "systemSymbol": system
     }
     data = self.request('post', f'my/ships/{ship}/jump', data)
     if 'nav' in data:

nullptr/central_command.py

@@ -1,10 +1,13 @@
 from nullptr.store import Store
 from nullptr.models.ship import Ship
-from nullptr.mission import *
+from nullptr.missions import create_mission, get_mission_class
 from random import choice
 from time import sleep
 from threading import Thread
 
+class CentralCommandError(Exception):
+  pass
+  
 class CentralCommand:
   def __init__(self, store, api):
     self.missions = {}
@@ -86,6 +89,21 @@ class CentralCommand:
         m = self.missions[s]
         m.next_step = max(s.cooldown, s.arrival)
   
+  def init_mission(self, s, mtyp):
+    if mtyp == 'none':
+      s.mission_state = {}
+      s.mission_status = None
+      s.mission = None
+      return
+    try:
+      mclass = get_mission_class(mtyp)
+    except ValueError:
+      raise CentralCommandError('no such mission')
+    s.mission = mtyp
+    s.mission_status = 'init'
+    s.mission_state = {k: v.default for k,v in mclass.params().items()}
+    self.start_mission(s)
+    
   def start_mission(self, s):
     mtype = s.mission
     m = create_mission(mtype, s, self.store, self.api)

nullptr/command_line.py

@@ -41,7 +41,7 @@ class CommandLine:
     print(f'command not found; {c}')
   
   def handle_error(self, cmd, args, e):
-    logging.error(e, exc_info=type(e).__name__ not in ['ApiError','CommandError'])
+    logging.error(e, exc_info=type(e).__name__ not in ['ApiError','CommandError', 'CentralCommandError'])
   
   def handle_empty(self):
     pass
@@ -90,5 +90,8 @@ class CommandLine:
       except EOFError:
         self.handle_eof()
         break
+      try:
         self.handle_cmd(c)
+      except Exception as e:
+        logging.error(e, exc_info=True)
       

nullptr/commander.py

@@ -82,13 +82,6 @@ class Commander(CommandLine):
   def do_auto(self):
     self.centcom.run_interactive()
   
-  def set_mission(self, arg=''):
-    if arg == 'none':
-      arg = None
-    self.ship.mission = arg
-    self.ship.mission_status = 'init'
-    self.centcom.start_mission(self.ship)
-  
   def print_mission(self):
     print(f'mission: {self.ship.mission} ({self.ship.mission_status})')
     pprint(self.ship.mission_state)
@@ -96,12 +89,15 @@ class Commander(CommandLine):
   def do_mission(self, arg=''):
     if not self.has_ship(): return 
     if arg:
-      self.set_mission(arg)
+      self.centcom.init_mission(self.ship, arg)
     self.print_mission()
   
-  def do_mset(self, args):
+  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
-    nm, val = args.split(' ')
     self.centcom.set_mission_param(self.ship, nm, val)
   
   def active_contract(self):
@@ -118,20 +114,64 @@ class Commander(CommandLine):
       raise CommandError('no delivery')
     resource = delivery['trade_symbol']
     destination = delivery['destination']
-    self.set_mission('mine')
+    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, 'destination', destination)
+    self.centcom.set_mission_param(self.ship, 'dest', destination)
     self.centcom.set_mission_param(self.ship, 'contract', contract.symbol)
     self.print_mission()
   
+  def do_chaul(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', 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.symbol)
+    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.symbol)
+    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)
+    hops = ','.join([m.symbol for m in markets])
+    self.centcom.init_mission(self.ship, 'probe')
+    self.centcom.set_mission_param(self.ship, 'hops', hops)
+    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.symbol)
+    self.print_mission()
+    
   def do_register(self, faction):
     self.api.register(faction.upper())
-    site = self.ship.location_str
-    contract = self.active_contract()
-    self.do_mission('mine')
-    self.centcom.set_mission_param(self.ship, 'site', site)
-    self.centcom.set_mission_param(self.ship, 'contract', contract)
+    pprint(self.api.agent)
     
   def do_universe(self, page=1):
     self.atlas_builder.run(page)
@@ -184,16 +224,16 @@ class Commander(CommandLine):
     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?')
+  def do_query(self, resource):
+    if not self.has_ship(): return
+    location = self.ship.location()
+    resource = resource.upper()
     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')
+    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: ')
@@ -228,6 +268,10 @@ class Commander(CommandLine):
     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}'
@@ -309,7 +353,9 @@ class Commander(CommandLine):
   def do_shipyard(self):
     if not self.has_ship(): return
     location = self.ship.location()
-    pprint(self.api.shipyard(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

nullptr/missions/__init__.py

@@ -0,0 +1,23 @@
+from nullptr.missions.survey import SurveyMission
+from nullptr.missions.mine import MiningMission
+from nullptr.missions.haul import HaulMission
+from nullptr.missions.travel import TravelMission
+from nullptr.missions.probe import ProbeMission
+
+def get_mission_class( mtype):
+  types = {
+    'survey': SurveyMission,
+    'mine': MiningMission,
+    'haul': HaulMission,
+    'travel': TravelMission,
+    'probe': ProbeMission
+  }
+  if mtype not in types:
+    raise ValueError(f'invalid mission type {mtype}')
+  return types[mtype]
+  
+def create_mission(mtype, ship, store, api):
+  typ = get_mission_class(mtype)
+  m = typ(ship, store, api)
+  return m
+

nullptr/missions/base.py

@@ -2,9 +2,12 @@ from nullptr.store import Store
 from nullptr.models.base import Base
 from nullptr.models.waypoint import Waypoint
 from nullptr.models.contract import Contract
+from nullptr.models.system import System
 from nullptr.models.survey import Survey
 from nullptr.models.ship import Ship
+from nullptr.analyzer import Analyzer
 from time import time
+from functools import partial
 import logging
 from nullptr.util import *
 
@@ -22,6 +25,8 @@ class MissionParam:
       return str(val)
     elif self.cls == int:
       return int(val)
+    elif self.cls == list:
+      return [i.strip() for i in val.split(',')]
     elif issubclass(self.cls, Base):
       data = store.get(self.cls, val)
       if data is None:
@@ -42,6 +47,7 @@ class Mission:
     self.store = store
     self.api = api
     self.next_step = 0
+    self.analyzer = Analyzer(self.store)
 
   def sts(self, nm, v):
     if issubclass(type(v), Base):
@@ -121,85 +127,7 @@ class Mission:
         self.status(next_step[result])
     print(f'{self.ship} {status} -> {self.status()}')
 
-
-class MiningMission(Mission): 
-  @classmethod
-  def params(cls):
-    return {
-      'site': MissionParam(Waypoint, True),
-      'resource': MissionParam(str, True),
-      'destination': MissionParam(Waypoint, True),
-      'delivery': MissionParam(str, True, 'deliver'),
-      'contract': MissionParam(Contract, False)
-    }
-  
-  def start_state(self):
-    return 'go_site'
-    
-  def steps(self):
-    return {
-      'extract': (self.step_extract, {
-        'done': 'dock',
-        'more': 'extract'
-      }),
-      'dock': (self.step_dock, 'sell'),
-      'sell': (self.step_sell, {
-        'more': 'sell',
-        'done': 'orbit',
-      }),
-      'orbit': (self.step_orbit, 'jettison'),
-      'jettison': (self.step_dispose, {
-        'more': 'jettison',
-        'done': 'extract',
-        'full': 'go_dest'
-      }),
-      'go_dest': (self.step_go_dest, 'dock_dest'),
-      'dock_dest': (self.step_dock, 'unload'),
-      'unload': (self.step_unload, {
-        'done': 'refuel',
-        'more': 'unload'
-      }),
-      'refuel': (self.step_refuel, 'orbit_dest'),
-      'orbit_dest': (self.step_orbit, 'go_site'),
-      'go_site': (self.step_go_site, 'extract')
-    }
-  
-  def get_survey(self):
-    resource = self.st('resource')
-    site = self.rst(Waypoint,'site')
-    # todo optimize
-    for s in self.store.all(Survey):
-      if resource in s.deposits and site.symbol == s.waypoint():
-        return s
-    return None
-    
-  def step_extract(self):
-    survey = self.get_survey()
-    print('using survey:', str(survey)) 
-    result = self.api.extract(self.ship, survey)
-    symbol = sg(result,'extraction.yield.symbol')
-    units  = sg(result,'extraction.yield.units')
-    print('extracted:', units, symbol)
-    self.next_step = self.ship.cooldown
-    if self.ship.cargo_units < self.ship.cargo_capacity:
-      return 'more'
-    else:
-      return 'done'
-    
-  def step_sell(self, except_resource=True):
-    target = self.st('resource')
-    market = self.store.get('Marketplace', self.ship.location_str)
-    sellables = market.sellable_items(self.ship.cargo.keys())
-    if target in sellables and except_resource:
-      sellables.remove(target)
-    if len(sellables) == 0:
-      return 'done'
-    self.api.sell(self.ship, sellables[0])
-    if len(sellables) == 1:
-      return 'done'
-    else:
-      return 'more'
-      
+class BaseMission(Mission):
   def step_go_dest(self):
     destination = self.rst(Waypoint, 'destination')
     if self.ship.location() == destination:
@@ -207,8 +135,12 @@ class MiningMission(Mission):
     self.api.navigate(self.ship, destination)
     self.next_step = self.ship.arrival
   
-  def step_dock(self):
-    self.api.dock(self.ship)
+  def step_go_site(self):
+    site = self.rst(Waypoint,'site')
+    if self.ship.location() == site:
+      return
+    self.api.navigate(self.ship, site)
+    self.next_step = self.ship.arrival
     
   def step_unload(self):
     contract = self.rst(Contract, 'contract')
@@ -224,54 +156,95 @@ class MiningMission(Mission):
     else:
       return 'more'
 
-  def step_refuel(self):
-    self.api.refuel(self.ship)
-    
-  def step_dispose(self):
-    contract = self.rst(Contract, 'contract')
-    typs = self.ship.nondeliverable_cargo(contract)
-    if len(typs) > 0:
-      self.api.jettison(self.ship, typs[0])
-    if len(typs) > 1:
-      return 'more'
-    elif self.ship.cargo_units > self.ship.cargo_capacity - 3:
-      return 'full'
-    else:
+  def step_sell(self, except_resource=True):
+    target = self.st('resource')
+    market = self.store.get('Marketplace', self.ship.location_str)
+    sellables = market.sellable_items(self.ship.cargo.keys())
+    if target in sellables and except_resource:
+      sellables.remove(target)
+    if len(sellables) == 0:
       return 'done'
+    self.api.sell(self.ship, sellables[0])
+    if len(sellables) == 1:
+      return 'done'
+    else:
+      return 'more'
   
+  def step_load(self):
+    cargo_space = self.ship.cargo_capacity - self.ship.cargo_units
+    resource = self.st('resource')
+    self.api.buy(self.ship, resource, cargo_space)
+  
+  def step_travel(self):
+    traject = self.st('traject')
+    if traject is None or traject == []:
+      return 'done'
+    dest = self.store.get(Waypoint, traject[-1])
+    loc = self.ship.location()
+    print(dest, loc)
+    if dest == loc:
+      self.sts('traject', None)
+      return 'done'
+    hop = traject.pop(0)
+    if len(hop.split('-')) == 3:
+      self.api.navigate(self.ship, hop)
+      self.next_step = self.ship.arrival
+    else:
+      self.api.jump(self.ship, hop)
+      self.next_step = self.ship.cooldown
+    if traject == []:
+      traject= None
+    self.sts('traject', traject)
+    return 'more'
+  
+  def step_calculate_traject(self, dest):
+    if type(dest) == str:
+      dest = self.store.get(Waypoint, dest)
+    loc = self.ship.location()
+    loc_sys = self.store.get(System, loc.system())
+    loc_jg = self.analyzer.get_jumpgate(loc_sys)
+    dest_sys = self.store.get(System, dest.system())
+    dest_jg = self.analyzer.get_jumpgate(dest_sys)
+    if dest_sys == loc_sys:
+      result = [dest.symbol]
+      self.sts('traject', result)
+      return
+    path = self.analyzer.find_path(loc_sys, dest_sys)
+    result = []
+    if loc.symbol != loc_jg.symbol:
+      result.append(loc_jg.symbol)
+    result += [s.symbol for s in path[1:]]
+    if dest_jg.symbol != dest.symbol:
+      result.append(dest.symbol)
+    self.sts('traject', result)
+    print(result)
+    return result
+    
+  def step_dock(self):
+    self.api.dock(self.ship)
+ 
+  def step_refuel(self):
+    if self.ship.fuel_capacity == 0:
+      return
+    if self.ship.fuel_current / self.ship.fuel_capacity < 0.5:
+      try:
+        self.api.refuel(self.ship)
+      except Exception as e:
+        pass
        
   def step_orbit(self):
     self.api.orbit(self.ship)
   
-  def step_go_site(self):
-    site = self.rst(Waypoint,'site')
-    if self.ship.location() == site:
-      return
-    self.api.navigate(self.ship, site)
-    self.next_step = self.ship.arrival
-    
-class SurveyMission(Mission):
-  def start_state(self):
-    return 'survey'
-  
-    
-  def steps(self):
+  def travel_steps(self, nm, destination, next_step):
+    destination = self.st(destination)
+    calc = partial(self.step_calculate_traject, destination)
     return {
-      'survey': (self.step_survey, 'survey')
+      f'travel-{nm}': (self.step_orbit, f'calc-trav-{nm}'),
+      f'calc-trav-{nm}': (calc, f'go-{nm}'),
+      f'go-{nm}': (self.step_travel, {
+        'done': f'dock-{nm}',
+        'more': f'go-{nm}'
+      }),
+      f'dock-{nm}': (self.step_dock, f'refuel-{nm}'),
+      f'refuel-{nm}': (self.step_refuel, next_step)
     }
-  
-  def step_survey(self):
-    result = self.api.survey(self.ship)
-    #pprint(result, 2)
-    self.next_step = self.ship.cooldown
-
-def create_mission(mtype, ship, store, api):
-  types = {
-    'survey': SurveyMission,
-    'mine': MiningMission
-  }
-  if mtype not in types:
-    logging.warning(f'invalid mission type {mtype}')
-    return
-  m = types[mtype](ship, store, api)
-  return m

nullptr/missions/haul.py

@@ -0,0 +1,25 @@
+from nullptr.missions.base import BaseMission, MissionParam
+from nullptr.models.waypoint import Waypoint
+from nullptr.models.survey import Survey
+from nullptr.models.contract import Contract
+class HaulMission(BaseMission):
+  def start_state(self):
+    return 'travel-to'
+  
+  @classmethod
+  def params(cls):
+    return {
+      'site': MissionParam(Waypoint, True),
+      'resource': MissionParam(str, True),
+      'dest': MissionParam(Waypoint, True),
+      'delivery': MissionParam(str, True, 'deliver'),
+      'contract': MissionParam(Contract, False)
+    }
+  
+  def steps(self):
+    return {
+      **self.travel_steps('to', 'site', 'load'),
+      'load': (self.step_load, 'travel-back'),
+      **self.travel_steps('back', 'dest', 'unload'),
+      'unload': (self.step_unload, 'travel-to'),
+    }

nullptr/missions/mine.py

@@ -0,0 +1,80 @@
+from nullptr.missions.base import BaseMission, MissionParam
+from nullptr.models.waypoint import Waypoint
+from nullptr.models.survey import Survey
+from nullptr.models.contract import Contract
+from nullptr.util import *
+
+class MiningMission(BaseMission): 
+  @classmethod
+  def params(cls):
+    return {
+      'site': MissionParam(Waypoint, True),
+      'resource': MissionParam(str, True),
+      'dest': MissionParam(Waypoint, True),
+      'delivery': MissionParam(str, True, 'deliver'),
+      'contract': MissionParam(Contract, False)
+    }
+  
+  def start_state(self):
+    return 'travel-to'
+    
+  def steps(self):
+    return {
+      **self.travel_steps('to', 'site', 'orbit1'),
+      'orbit1': (self.step_orbit, 'extract'),
+      'extract': (self.step_extract, {
+        'done': 'dock',
+        'more': 'extract'
+      }),
+      'dock': (self.step_dock, 'sell'),
+      'sell': (self.step_sell, {
+        'more': 'sell',
+        'done': 'orbit2',
+      }),
+      'orbit2': (self.step_orbit, 'jettison'),
+      'jettison': (self.step_dispose, {
+        'more': 'jettison',
+        'done': 'extract',
+        'full': 'travel-back'
+      }),
+      **self.travel_steps('back', 'dest', 'unload'),
+      'unload': (self.step_unload, {
+        'done': 'travel-to',
+        'more': 'unload'
+      }),
+    }
+  
+  def get_survey(self):
+    resource = self.st('resource')
+    site = self.rst(Waypoint,'site')
+    # todo optimize
+    for s in self.store.all(Survey):
+      if resource in s.deposits and site.symbol == s.waypoint():
+        return s
+    return None
+    
+  def step_extract(self):
+    survey = self.get_survey()
+    print('using survey:', str(survey)) 
+    result = self.api.extract(self.ship, survey)
+    symbol = sg(result,'extraction.yield.symbol')
+    units  = sg(result,'extraction.yield.units')
+    print('extracted:', units, symbol)
+    self.next_step = self.ship.cooldown
+    if self.ship.cargo_units < self.ship.cargo_capacity:
+      return 'more'
+    else:
+      return 'done'
+  
+  def step_dispose(self):
+    contract = self.rst(Contract, 'contract')
+    typs = self.ship.nondeliverable_cargo(contract)
+    if len(typs) > 0:
+      self.api.jettison(self.ship, typs[0])
+    if len(typs) > 1:
+      return 'more'
+    elif self.ship.cargo_units > self.ship.cargo_capacity - 3:
+      return 'full'
+    else:
+      return 'done'
+  

nullptr/missions/probe.py

@@ -0,0 +1,33 @@
+from nullptr.missions.base import BaseMission, MissionParam
+from nullptr.models.waypoint import Waypoint
+
+class ProbeMission(BaseMission):
+  def start_state(self):
+    return 'next-hop'
+  
+  @classmethod
+  def params(cls):
+    return {
+      'hops': MissionParam(list, True),
+      'next-hop': MissionParam(int, True, 0)
+    }
+  
+  def steps(self):
+    return {
+      'next-hop': (self.step_next_hop, 'travel-to'),
+      **self.travel_steps('to', 'site', 'market'),
+      'market': (self.step_market, 'next-hop'),
+ 
+    }
+  
+  def step_market(self):
+    loc = self.ship.location()
+    self.api.marketplace(loc)
+  
+  def step_next_hop(self):
+    hops = self.st('hops')
+    next_hop = self.st('next-hop')
+    hop = hops[next_hop]
+    self.sts('site', hop)
+    self.sts('next-hop', (next_hop+1) % len(hops))
+    

nullptr/missions/survey.py

@@ -0,0 +1,15 @@
+from nullptr.missions.base import BaseMission, MissionParam
+
+class SurveyMission(BaseMission):
+  def start_state(self):
+    return 'survey'
+  
+  def steps(self):
+    return {
+      'survey': (self.step_survey, 'survey')
+    }
+  
+  def step_survey(self):
+    result = self.api.survey(self.ship)
+    #pprint(result, 2)
+    self.next_step = self.ship.cooldown

nullptr/missions/travel.py

@@ -0,0 +1,16 @@
+from nullptr.missions.base import BaseMission, MissionParam
+from nullptr.models.waypoint import Waypoint
+
+class TravelMission(BaseMission):
+  def start_state(self):
+    return 'travel-to'
+  
+  @classmethod
+  def params(cls):
+    return {
+      'dest': MissionParam(Waypoint, True)
+    }
+  
+  def steps(self):
+    return self.travel_steps('to', 'dest', 'done')
+    

nullptr/models/base.py

@@ -7,10 +7,11 @@ class Base:
   store: object
   
   def __init__(self, symbol, store):
-    self.disable_dirty = False
+    self.disable_dirty = True
     self.store = store
     self.symbol = symbol
     self.define()
+    self.disable_dirty = False
     
   def define(self):
     pass

nullptr/store.py

@@ -124,6 +124,7 @@ class Store:
   
     if system not in self.system_members:
       return 
+      print('typ', typ)
     for m in self.system_members[system]:
       if typ is None or type(m) == typ:
         yield m