From 2665e657edf5b17e06224abeceb34c5432de7bf7 Mon Sep 17 00:00:00 2001 From: ewandor Date: Wed, 30 Aug 2023 23:13:34 +0200 Subject: [PATCH] Trying to reach a working mini model --- console.py | 1 - lib.py | 10 ++- main.py | 149 ++++++++++++++++++++++++++++++++---------- maneuver_scheduler.py | 31 +++++---- maneuvers/__init__.py | 36 ++++++++-- maneuvers/approach.py | 10 ++- maneuvers/comsat.py | 25 ++++--- maneuvers/docking.py | 4 +- 8 files changed, 189 insertions(+), 77 deletions(-) diff --git a/console.py b/console.py index 1217b94..c92be32 100644 --- a/console.py +++ b/console.py @@ -5,7 +5,6 @@ import krpc conn = krpc.connect() sc = conn.space_center vessel = sc.active_vessel -docking_part = vessel.parts.root.children[0].children[10].children[0].children[0].children[0].children[0] target = sc.target_vessel mj = conn.mech_jeb diff --git a/lib.py b/lib.py index a9360f7..8673059 100644 --- a/lib.py +++ b/lib.py @@ -22,4 +22,12 @@ def get_rescuee_vessel(rescuee_name): if rescuee_name in v.name: return v - raise LookupError("Rescuee {} vessel not found".format(rescuee_name)) \ No newline at end of file + raise LookupError("Rescuee {} vessel not found".format(rescuee_name)) + + +def get_body(name): + bodies = get_connexion().space_center.bodies + if name in bodies: + return bodies[name] + + raise LookupError("Celestial body {} not found".format(name)) diff --git a/main.py b/main.py index 8335946..c63cade 100644 --- a/main.py +++ b/main.py @@ -7,9 +7,16 @@ from maneuver_scheduler import ManeuverScheduler from maneuvers.rendezvous import RendezvousManeuver from maneuvers.approach import ApproachManeuver from maneuvers.docking import DockingManeuver +from maneuvers.comsat import ComsatManeuver from connector import get_connexion -from lib import get_contract, get_vessel, get_rescuee_vessel +from lib import get_contract, get_vessel, get_rescuee_vessel, get_body + + +class MissionType(Enum): + transport = 1 + rescue = 2 + comsat = 3 class MissionStatus(Enum): @@ -33,12 +40,16 @@ class Mission: class TransportMission(Mission): + type = MissionType.transport + def __init__(self, kerbal_name, destination): self.kerbal_name = kerbal_name self.destination = destination class RescueMission(Mission): + type = MissionType.rescue + def __init__(self, contract_title): self.contract_title = contract_title self.contract = get_contract(contract_title) @@ -47,59 +58,89 @@ class RescueMission(Mission): self.rescuee_vessel_name = self.rescuee_vessel.name self.rescuee_name = self.rescuee_vessel.crew[0].name - def execute(self, vessel): + def execute(self, mission_control): conn = get_connexion() sc = conn.space_center - if sc.active_vessel.name != vessel.name: - sc.active_vessel = vessel + if sc.active_vessel.name != mission_control.vessel.name: + sc.active_vessel = mission_control.vessel if sc.target_vessel is None or sc.target_vessel.name != self.rescuee_vessel.name: sc.target_vessel = self.rescuee_vessel - rendezvous_done = RendezvousManeuver(conn, vessel).execute() + rendezvous_done = RendezvousManeuver(conn, mission_control).execute() if rendezvous_done: reference_frame = sc.ReferenceFrame.create_relative( self.rescuee_vessel.reference_frame, rotation=(1., 0., 0., 0.) ) - approach_done = ApproachManeuver(conn, vessel, reference_frame).start() + sc.active_vessel.parts.controlling = mission_control.get_grappling() + approach_done = ApproachManeuver(conn, mission_control, reference_frame).start() if approach_done: - docking_part = vessel.parts.root.children[0].children[10].children[0].children[0].children[0].children[ - 0] - docking_done = DockingManeuver(conn, vessel, docking_part, reference_frame).start() + mission_control.toggle_grappling(True) + docking_done = DockingManeuver(conn, + mission_control, + mission_control.get_grappling(), + reference_frame).start() # Find new creat member name # sc.transfer_crew(self.rescuee_name, target_part) # Release Grapple # Destroy Capsule - MissionReport.mission_status = MissionStatus.Done - MissionReport.new_missions.append( + report = MissionReport() + report.mission_status = MissionStatus.Done + report.new_missions.append( TransportMission(self.rescuee_name, 'kerbin_orbit') ) + return report -class ShuttleKerbin: - def __init__(self, vessel_name): - self.vessel_name = vessel_name - self.vessel = get_vessel(vessel_name) +class ComSatNetworkMission: + type = MissionType.comsat - self.current_orbit_missions = [] + def __init__(self, body_name): + self.body = get_body(body_name) + + def execute(self, mission_control): + conn = get_connexion() + sc = conn.space_center + + if sc.active_vessel.name != mission_control.vessel.name: + sc.active_vessel = mission_control.vessel + + mission_control.toggle_engines(True) + + comsat_done = ComsatManeuver(conn, mission_control, self.body).execute() + if comsat_done: + report = MissionReport() + report.mission_status = MissionStatus.Done + + return report + + +class MissionControl: + mission_types = [] + + def __init__(self): self.current_mission = None + def pick_missions(self, backlog): + current_body_name = self.vessel.orbit.body.name + for i, mission in enumerate(backlog.missions[current_body_name]): + if mission.type in self.mission_types: + if self.current_mission is None: + self.plan_mission(mission) + else: + self.current_orbit_missions.append(mission) + del (backlog.missions[current_body_name][i]) + def plan_mission(self, mission): self.current_mission = mission - planning_duration = (5*60) - ut = ManeuverScheduler.next_free_timeslot(duration=planning_duration) - ManeuverScheduler.book_timeslot(ut, self.vessel) - - def pick_missions(self, backlog): - for i, mission in enumerate(backlog.kerbin_orbit_rescue): - if self.current_mission is None: - self.plan_mission(mission) - else: - self.current_orbit_missions.append(mission) - del(backlog.kerbin_orbit_rescue[i]) + planning_duration = 60 + ut = ManeuverScheduler.next_free_timeslot( + from_ut=get_connexion().space_center.ut + planning_duration, + duration=planning_duration) + ManeuverScheduler.book_timeslot(ut, self.vessel, duration=planning_duration) def execute_mission(self, alarm): if self.current_mission is None: @@ -107,11 +148,54 @@ class ShuttleKerbin: self.current_mission = self.current_orbit_missions.pop(0) else: return - self.current_mission.execute(self.vessel) + report = self.current_mission.execute(self) + if report and report.mission_status == MissionStatus.Done: + self.current_mission = None + + +class ShuttleKerbin(MissionControl): + mission_types = [MissionType.rescue, MissionType.transport] + PISTON_MAX_EXTENSION = 2.4 + + def __init__(self, vessel_name): + super().__init__() + self.vessel_name = vessel_name + self.vessel = get_vessel(vessel_name) + for e in self.vessel.parts.engines: + e.active = True + + self.current_orbit_missions = [] + + def toggle_grappling(self, value=True): + piston = self.vessel.parts.robotic_pistons[0] + piston.target_extension = self.PISTON_MAX_EXTENSION if value else 0 + + arm = piston.part.children[0] + if arm.modules[1].has_event('Arm') and not value \ + or arm.modules[1].has_event('Disarm') and value: + arm.modules[1].set_action_by_id('ToggleAction', True) + + def get_grappling(self): + piston = self.vessel.parts.robotic_pistons[0] + return piston.part.children[0] + + +class ComsatKerbin(MissionControl): + mission_types = [MissionType.comsat] + + def __init__(self, vessel_name): + super().__init__() + self.vessel_name = vessel_name + self.vessel = get_vessel(vessel_name) + + def toggle_engines(self, value=True): + self.vessel.parts.engines[0].active = value class Backlog: - kerbin_orbit_rescue = [] + missions = { + 'Kerbin': [RescueMission('Rescue Rossby from orbit of Kerbin.'), ] # ComSatNetworkMission('Kerbin')] + } kerbin_to_orbit = [] kerbin_to_ground = [] @@ -125,10 +209,8 @@ if __name__ == '__main__': signal.signal(signal.SIGINT, signal_handler) ships = [] - m = RescueMission('Rescue Rossby from orbit of Kerbin.') - Backlog.kerbin_orbit_rescue.append(m) - ships.append(ShuttleKerbin('KKS Gagarin')) + ships.append(ComsatKerbin('KKR Shepard')) conn = get_connexion() # conn.space_center.GameMode @@ -161,6 +243,3 @@ if __name__ == '__main__': current_ship.execute_mission(alarm) alarm.remove() print("turn") - - - diff --git a/maneuver_scheduler.py b/maneuver_scheduler.py index 15a296e..73d5f8c 100644 --- a/maneuver_scheduler.py +++ b/maneuver_scheduler.py @@ -2,8 +2,6 @@ from connector import get_connexion import json import math -from maneuvers import ManeuverAlarmType - class Timeslot: def __init__(self, ut_start, duration): @@ -35,14 +33,11 @@ class ManeuverScheduler: return sorted(cls.alarm_manager.alarms, key=lambda el: el.time) @classmethod - def book_timeslot_for_node(cls, vessel, node, maneuver, duration=None): + def book_timeslot_for_node(cls, vessel, node, maneuver, alarm_start=None, duration=None): time_required = (node.delta_v * vessel.mass) / vessel.available_thrust if duration is None: duration = math.floor(2 * cls.node_offsets + time_required) - if not cls.timeslot_is_free(node.ut, duration): - raise - description = { 'duration': duration, 'vessel_name': vessel.name @@ -58,7 +53,12 @@ class ManeuverScheduler: # vessel, # vessel.control.nodes[0], # **arg_dict) - alarm_start = node.ut - (duration / 2 + cls.node_offsets) + if alarm_start is None: + alarm_start = node.ut - (duration / 2 + cls.node_offsets) + + if not cls.timeslot_is_free(alarm_start, duration): + raise + alarm = cls.alarm_manager.create_alarm( cls.alarm_manager.AlarmType.maneuver, "{}' Maneuver: {}".format(vessel.name, maneuver.name), @@ -93,7 +93,6 @@ class ManeuverScheduler: alarm.action = cls.alarm_manager.AlarmAction.kill_warp_only - @classmethod def book_timeslot_for_soi(cls, vessel, maneuver, duration=None): if duration is None: @@ -107,7 +106,7 @@ class ManeuverScheduler: if not cls.timeslot_is_free(ut_start, duration): raise - note = { + notes = { 'duration': duration, 'vessel_name': vessel.name } @@ -119,7 +118,7 @@ class ManeuverScheduler: ) alarm.vessel = vessel alarm.margin = cls.node_offsets - alarm.notes = json.dumps(note) + alarm.notes = json.dumps(notes) alarm.action = cls.alarm_manager.AlarmAction.kill_warp_only @classmethod @@ -127,9 +126,9 @@ class ManeuverScheduler: ut_end = ut_start + duration for a in cls.get_ordered_alarms(): try: - note = json.loads(a.note) + notes = json.loads(a.notes) alarm_start = a.time - alarm_end = a.time + note['duration'] + alarm_end = a.time + notes['duration'] if alarm_end < ut_start: continue elif alarm_start <= ut_start <= alarm_end: @@ -155,10 +154,10 @@ class ManeuverScheduler: for a in cls.get_ordered_alarms(): try: - note = json.loads(a.note) - alarm_end = a.time + int(note['duration']) - if cls.timeslot_is_free(alarm_end, duration): - return alarm_end + notes = json.loads(a.notes) + alarm_end = a.time + int(notes['duration']) + if cls.timeslot_is_free(alarm_end + 1, duration): + return alarm_end + 1 except json.JSONDecodeError: continue diff --git a/maneuvers/__init__.py b/maneuvers/__init__.py index 56b33ad..73e07d1 100644 --- a/maneuvers/__init__.py +++ b/maneuvers/__init__.py @@ -1,5 +1,9 @@ +import math + from enum import Enum +from maneuver_scheduler import ManeuverScheduler + class ManeuverAlarmType(Enum): ManeuverNode = 1, @@ -7,8 +11,9 @@ class ManeuverAlarmType(Enum): class Maneuver: - def __init__(self, conn, vessel): - self.vessel = vessel + def __init__(self, conn, mission_control): + self.mission_control = mission_control + self.vessel = mission_control.vessel self.conn = conn def plan_next_maneuver(self): @@ -18,8 +23,8 @@ class Maneuver: class NodeManeuver(Maneuver): alarm_type = ManeuverAlarmType.ManeuverNode - def __init__(self, conn, vessel): - super().__init__(conn, vessel) + def __init__(self, conn, mission_control): + super().__init__(conn, mission_control) self.mech_jeb = conn.mech_jeb self.node_executor = self.mech_jeb.node_executor @@ -42,9 +47,28 @@ class NodeManeuver(Maneuver): while enabled(): enabled.wait() + def book_timeslot_for_node(self, node, maneuver, duration=None): + if node.time_to < 0: + node.remove() + planning_duration = 60 + ut = ManeuverScheduler.next_free_timeslot(self.conn.space_center.ut + planning_duration, planning_duration) + ManeuverScheduler.book_timeslot(ut, self.vessel, duration=planning_duration) + + time_required = (node.delta_v * self.vessel.mass) / self.vessel.available_thrust + duration = math.floor(2 * ManeuverScheduler.node_offsets + time_required) + alarm_start = node.ut - (duration / 2 + ManeuverScheduler.node_offsets) + + if ManeuverScheduler.timeslot_is_free(alarm_start, duration): + ManeuverScheduler.book_timeslot_for_node(self.vessel, node, self, alarm_start=alarm_start, duration=duration) + else: + node.remove() + planning_duration = 60 + ut = ManeuverScheduler.next_free_timeslot(alarm_start, planning_duration) + ManeuverScheduler.book_timeslot(ut, self.vessel, duration=planning_duration) + class MechJebManeuver(NodeManeuver): - def __init__(self, conn, vessel): - super().__init__(conn, vessel) + def __init__(self, conn, mission_control): + super().__init__(conn, mission_control) self.maneuver_planner = self.mech_jeb.maneuver_planner diff --git a/maneuvers/approach.py b/maneuvers/approach.py index b37f784..96388c7 100644 --- a/maneuvers/approach.py +++ b/maneuvers/approach.py @@ -10,8 +10,8 @@ from . import Maneuver class ApproachManeuver(Maneuver): - def __init__(self, conn, vessel_id, reference_frame): - super().__init__(conn, vessel_id) + def __init__(self, conn, mission_control, reference_frame): + super().__init__(conn, mission_control) self.reference_frame = reference_frame def start(self): @@ -64,10 +64,8 @@ def point_toward_direction(vessel, direction, reference_frame): ap.target_roll = 0 ap.sas = False ap.engage() - sleep(.1) - - while magnitude(vessel.angular_velocity(reference_frame)) > .1: - sleep(.1) + sleep(1) + ap.wait() ap.disengage() ap.sas_mode = SASMode.stability_assist diff --git a/maneuvers/comsat.py b/maneuvers/comsat.py index d3d3cea..0a79c7f 100644 --- a/maneuvers/comsat.py +++ b/maneuvers/comsat.py @@ -6,14 +6,14 @@ from . import MechJebManeuver class ComsatManeuver(MechJebManeuver): - def __init__(self, conn, vessel, target_body): - super().__init__(conn, vessel) + def __init__(self, conn, mission_control, target_body): + super().__init__(conn, mission_control) self.target_body = target_body body = self.target_body if body.satellites: lowest_sat = min(body.satellites, key=lambda sat: sat.orbit.periapsis) - max_orbit = lowest_sat.orbit.periapsis - lowest_sat.sphere_of_influence + max_orbit = lowest_sat.orbit.periapsis_altitude - lowest_sat.sphere_of_influence else: max_orbit = body.sphere_of_influence @@ -29,11 +29,11 @@ class ComsatManeuver(MechJebManeuver): if vessel.orbit.body.name != self.target_body.name: raise NotImplementedError - if not math.isclose(vessel.orbit.apoapsis, self.target_altitude, rel_tol=.01): - SetOrbitApoapsis(self.conn, vessel, self.target_altitude).prepare_maneuver() - elif not math.isclose(vessel.orbit.eccentricity, 0, rel_tol=.01): - CircularizeOrbitAndDeliver(self.conn, vessel, self.target_altitude).prepare_maneuver() - elif self.vessel.control.current_stage == 0: + if not math.isclose(vessel.orbit.apoapsis_altitude, self.target_altitude, rel_tol=.01): + SetOrbitApoapsis(self.conn, vessel, self.target_body).prepare_maneuver() + elif not math.isclose(vessel.orbit.eccentricity, 0, abs_tol=.001) or self.vessel.control.current_stage > 1: + CircularizeOrbitAndDeliver(self.conn, vessel, self.target_body).prepare_maneuver() + elif self.vessel.control.current_stage <= 1: return True return False @@ -73,8 +73,13 @@ class CircularizeOrbitAndDeliver(ComsatManeuver): while self.vessel.control.nodes: self._execute_node() - if self.vessel.control.current_stage > 0: - self.vessel.control.activate_next_stage() + current_stage = self.vessel.control.current_stage + if current_stage > 1: + relay = self.vessel.control.activate_next_stage() + sc.active_vessel = relay[0] + sc.active_vessel.name = self.vessel.name + " " + current_stage + sc.active_vessel.control.solar_panels = True + sc.active_vessel = self.vessel oro = self.maneuver_planner.operation_resonant_orbit oro.resonance_numerator = 2 diff --git a/maneuvers/docking.py b/maneuvers/docking.py index bef8da6..0703c99 100644 --- a/maneuvers/docking.py +++ b/maneuvers/docking.py @@ -6,8 +6,8 @@ from . import Maneuver class DockingManeuver(Maneuver): - def __init__(self, conn, vessel_id, docking_part, reference_frame): - super().__init__(conn, vessel_id) + def __init__(self, conn, mission_control, docking_part, reference_frame): + super().__init__(conn, mission_control) self.docking_part = docking_part self.reference_frame = reference_frame