siphoning and hauling

nullptr/missions/__init__.py

@@ -4,7 +4,8 @@ from nullptr.missions.trade import TradeMission
 from nullptr.missions.travel import TravelMission
 from nullptr.missions.probe import ProbeMission
 from nullptr.missions.idle import IdleMission
-
+from nullptr.missions.siphon import SiphonMission
+from nullptr.missions.haul import HaulMission
 
 def get_mission_class( mtype):
   types = {
@@ -13,7 +14,10 @@ def get_mission_class( mtype):
     'trade': TradeMission,
     'travel': TravelMission,
     'probe': ProbeMission,
-    'idle': IdleMission
+    'idle': IdleMission,
+    'siphon': SiphonMission,
+    'haul': HaulMission,
+    
   }
   if mtype not in types:
     raise ValueError(f'invalid mission type {mtype}')

nullptr/missions/base.py

@@ -51,9 +51,14 @@ class Mission:
     self.ship = ship
     self.store = store
     self.api = api
+    self.wait_for = None
     self.next_step = 0
     self.analyzer = Analyzer(self.store)
+    self.setup()
 
+  def setup(self):
+    pass
+    
   def sts(self, nm, v):
     if issubclass(type(v), Base):
       v = v.symbol
@@ -74,7 +79,17 @@ class Mission:
     if nw is None:
       return self.ship.mission_status
     else:
-      self.ship.mission_status = nw
+      steps = self.steps()
+      if nw in ['init','done', 'error']:
+        self.ship.mission_status = nw 
+        return
+      elif nw not in steps:
+        self.ship.log(f"Invalid mission status {nw}", 1)
+        self.ship.mission_status = 'error'
+        return 
+      wait_for = steps[nw][2] if len(steps[nw]) > 2 else None
+      self.wait_for = wait_for
+      self.ship.mission_status = nw 
       
   def start_state(self):
     return 'done'
@@ -96,10 +111,19 @@ class Mission:
     }
   
   def step_done(self):
-    self.ship.log(f'mission finished', 3)
+    self.ship.log(f'mission finished with balance {self.balance()}', 3)
     
   def is_waiting(self):
-    return self.next_step > time() or self.ship.cooldown > time() or self.ship.arrival > time()
+    if self.next_step > time() or self.ship.cooldown > time() or self.ship.arrival > time():
+      return True
+    if self.wait_for is not None:
+      if self.wait_for():
+        self.wait_for = None
+        return False      
+      else:
+        return True
+    return False
+      
   
   def is_finished(self):
     return self.status() in ['done','error']
@@ -116,7 +140,10 @@ class Mission:
       self.ship.log(f"Invalid mission status {status}", 1)
       self.status('error')
       return
-    handler, next_step = steps[status]
+    
+    handler = steps[status][0]
+    next_step = steps[status][1]
+    
     try:
       result = handler()
     except Exception as e:
@@ -136,6 +163,15 @@ class Mission:
     self.ship.log(f'{status} {result} -> {self.status()}', 8)
 
 class BaseMission(Mission):
+  def balance(self, amt=0):
+    if type(amt) == dict:
+      amt = self.api.transaction_cost(amt)
+    balance = self.st('balance')
+    if balance is None: balance = 0
+    balance += amt
+    self.sts('balance', balance)
+    return balance
+  
   def step_go_dest(self):
     destination = self.rst(Waypoint, 'destination')
     if self.ship.location() == destination:
@@ -179,8 +215,8 @@ class BaseMission(Mission):
     amt_cargo = self.ship.get_cargo(resource)
   
     amount = min(amt_cargo, volume)
-    self.api.sell(self.ship, resource, amount)
-    
+    res = self.api.sell(self.ship, resource, amount)
+    self.balance(res)
     if len(sellables) == 1 and amt_cargo == amount:
       return 'done'
     else:
@@ -228,7 +264,7 @@ class BaseMission(Mission):
     if dest_sys == loc_sys:
       result = self.analyzer.find_nav_path(loc, dest, self.ship.range())
       self.sts('traject', result)
-      return
+      return 'done' if len(result) == 0 else 'more'
     path = self.analyzer.find_path(loc_sys, dest_sys)
     result = []
     if loc.symbol != loc_jg.symbol:
@@ -238,7 +274,7 @@ class BaseMission(Mission):
       result.append(dest)
     self.sts('traject', result)
     print(result)
-    return result
+    return 'more'
     
   def step_dock(self):
     if self.ship.status == 'DOCKED':
@@ -264,7 +300,10 @@ class BaseMission(Mission):
     calc = partial(self.step_calculate_traject, destination)
     steps = {
       
-      f'travel-{nm}': (calc, f'dock-{nm}'),
+      f'travel-{nm}': (calc, {
+      'more': f'dock-{nm}',
+      'done': next_step
+      }),
       f'dock-{nm}': (self.step_dock, f'refuel-{nm}'),
       f'refuel-{nm}': (self.step_refuel, f'orbit-{nm}'),
       f'orbit-{nm}': (self.step_orbit, f'go-{nm}'),

nullptr/missions/haul.py

@@ -0,0 +1,73 @@
+from nullptr.missions.base import BaseMission, MissionParam
+from nullptr.models.waypoint import Waypoint
+
+class HaulMission(BaseMission):
+  def start_state(self):
+    return 'travel-to'
+  
+  def step_turn(self):
+    self.ship.log('starting haul load')
+  
+  def wait_turn(self):
+    for s in self.store.all('Ship'):
+      if s.mission != 'haul': continue
+      if s.location != self.ship.location:
+        continue
+      if s.mission_state['dest'] != self.st('dest'):
+        continue
+      if s.mission_status != 'load':
+        continue
+      return False
+    return True
+  
+  def wait_cargo(self):
+    dmkt = self.store.get('Marketplace', self.st('dest'))
+    sellables = dmkt.prices.keys()
+    for s in self.store.all("Ship"):
+      if s.location != self.ship.location: continue
+      if s.mission not in ['mine','siphon']: continue
+      for r, a in s.cargo.items():
+        if r not in sellables: continue
+        return True
+    return False
+    
+  def step_load(self):
+    cargo_space = self.ship.cargo_capacity - self.ship.cargo_units
+    dmkt = self.store.get('Marketplace', self.st('dest'))
+    sellables = dmkt.prices.keys()
+    for s in self.store.all("Ship"):
+      if s.location != self.ship.location: continue
+      if s.mission not in ['mine','siphon']: continue
+      for r, a in s.cargo.items():
+        if r not in sellables: continue
+        amount = min(cargo_space, a)
+      
+        res = self.api.transfer(s, self.ship, r, amount)
+      
+        return 'done' if amount == cargo_space else 'more'
+    return 'more'
+  
+  @classmethod
+  def params(cls):
+    return {
+      'site': MissionParam(Waypoint, True),
+      'dest': MissionParam(Waypoint, True),
+    }
+  
+  def steps(self):
+    return {
+      **self.travel_steps('to', 'site', 'wait-turn'),
+       'wait-turn': (self.step_turn, 'load', self.wait_turn),
+      'load': (self.step_load, {
+        'more': 'load',
+        'done': 'travel-back'
+      }, self.wait_cargo),
+      **self.travel_steps('back', 'dest', 'dock-dest'),
+      'dock-dest': (self.step_dock, 'unload'),
+      'unload': (self.step_sell, {
+         'more': 'unload',
+         'done': 'market-dest'
+        }),
+      'market-dest': (self.step_market, 'report'),
+      'report': (self.step_done, 'done')
+    }

nullptr/missions/siphon.py

@@ -0,0 +1,25 @@
+from nullptr.missions.base import BaseMission, MissionParam
+from nullptr.models.waypoint import Waypoint
+
+class SiphonMission(BaseMission):
+  def start_state(self):
+    return 'travel-to'
+    
+  @classmethod
+  def params(cls):
+    return {
+      'site': MissionParam(Waypoint, True),
+    }
+    
+  def steps(self):
+    return {
+      **self.travel_steps('to', 'site', 'siphon'),
+      'siphon': (self.step_siphon, 'done', self.cargo_full)
+    }
+  
+  def cargo_full(self):
+    return self.ship.cargo_capacity - self.ship.cargo_units > 5
+  
+  def step_siphon(self):
+    result = self.api.siphon(self.ship)
+    self.next_step = self.ship.cooldown

nullptr/missions/trade.py

@@ -20,7 +20,8 @@ class TradeMission(BaseMission):
     amount = min(cargo_space, affordable, volume)
     if amount == 0:
       return 'done'
-    self.api.buy(self.ship, resource, amount)
+    res = self.api.buy(self.ship, resource, amount)
+    self.balance(res)
     return 'done' if amount == cargo_space else 'more'
   
   @classmethod
@@ -46,5 +47,6 @@ class TradeMission(BaseMission):
          'more': 'unload',
          'done': 'market-dest'
         }),
-      'market-dest': (self.step_market, 'done'),
+      'market-dest': (self.step_market, 'report'),
+      'report': (self.step_done, 'done')
     }