class Game:
def __init__(self, scr: CursesWindow) -> None:
self.delay = 0
self.gui = Gui(scr)
self.game = Gameplay(self.gui, self.gui.center)
def load(self) -> bool:
try:
with open(filename, "rb") as f:
self.game = pickle.load(f)
return True
except IOError:
self.game = Gameplay(self.gui, self.gui.center)
return False
def save(self) -> None:
with open(filename, "wb") as f:
self.game.gui = None # type: ignore
pickle.dump(self.game, f)
def pause(self) -> None:
self.gui.pause()
def loop(self, d: Optional[Pair]) -> int:
self.delay = self.game.direct(d)
if self.game.step():
self.gui.flash()
self.pause()
self.game.reset()
return self.delay
def play(self) -> None:
self.init()
self.gui.do_loop(self.loop)
self.save()
def init(self) -> None:
self.delay = 0
self.gui = Gui(self.gui.scr)
ok = self.load()
self.game.gui = self.gui
if not ok:
self.game.reset()
assert self.game.snake is not None
class GameplayNode(messenger.Node):
def __init__(self, mock=False, run=True, **kwargs) -> None:
super().__init__('gameplay', existing_loggers=['gameplay'], **kwargs)
self.mock = mock
# ConfigManager.set_value('game|global|gameplay status', 'disabled')
self.config = ConfigManager.get_value('game')
self.gameplay = Gameplay(self.config, Controller(), self.logger)
self.strategy_publisher = messenger.Publisher('/strategy', messenger.Messages.string)
self.settings_listener = messenger.Listener(
'/settings_changed', messenger.Messages.string, callback=self.refresh_settings)
self.recognition_listener = messenger.Listener(
'/recognition', messenger.Messages.string, callback=self.callback)
self.command_listener = messenger.Listener(
'/command', messenger.Messages.string, callback=self.command_callback)
self.kicker_listener = messenger.Listener(
'/canbus_message', messenger.Messages.string, callback=self.kicker_callback)
self.realsense_distance_listener = messenger.Listener(
'/distance/realsense', messenger.Messages.float, callback=self.realsense_distance_callback)
self.tfmini_distance_listener = messenger.Listener(
'/distance/tfmini', messenger.Messages.float, callback=self.tfmini_distance_callback)
self.realsense_active = time()
self.logger.info("Start gameplay")
if run:
self.spin()
def refresh_settings(self, settings_topic):
self.loginfo("Settings refreshed")
self.config = ConfigManager.get_value('game')
self.gameplay.config = Settings(self.config)
def get_recognition(self):
package = self.recognition_listener.package
if package:
return RecognitionState.from_dict(package)
def kicker_callback(self, *_):
package = self.kicker_listener.package
if package:
self.gameplay.kicker_speed = package.get('rpm', 0)
def realsense_distance_callback(self, *_):
self.realsense_active = time()
distance = self.realsense_distance_listener.last_reading.data
if not isnan(distance):
self.gameplay.real_distance = distance
def tfmini_distance_callback(self, *_):
angle = self.gameplay.target_goal_angle
distance = float(self.tfmini_distance_listener.last_reading.data)
# if angle and abs(angle) <= 3.5:
# timeout = time() - self.realsense_active > 1
# self.loginfo_throttle(1, f"TF-MINI is setting DISTANCE, RS:{not timeout} ANGLE:{angle}")
# self.loginfo_throttle(1, f"TF-MINI is setting DISTANCE, RS:{distance:.0f} ANGLE:{angle:.1f} {self.gameplay.get_desired_kicker_speed()}")
# if timeout:
# self.gameplay.target_goal_distance = distance
# self.gameplay.real_distance = distance
pass
def command_callback(self, *_):
package = self.command_listener.package
if package:
self.gameplay.motors.reset()
r_state = self.get_recognition()
self.gameplay.recognition = r_state
self.gameplay.update_recent_closest_balls()
self.gameplay.set_target_goal_distance()
self.gameplay.set_target_goal_angle_adjust()
for function_name, arguments in package.items():
try:
func = getattr(self.gameplay, function_name)
func(**(arguments or {}))
self.logger.info_throttle(1, 'command success')
except Exception as e:
self.logger.error('Gameplay command failed: %s %s\n %s', function_name, arguments, e)
self.gameplay.motors.apply()
def callback(self, *_):
r_state = self.get_recognition()
if r_state:
self.gameplay.step(r_state)
gp = self.gameplay
self.strategy_publisher.command(
is_enabled=gp.is_enabled,
target_goal_angle=gp.target_goal_angle,
goal=gp.config_goal,
field=gp.field_id,
robot=gp.robot_id,
state=str(gp.state),
dist=gp.target_goal_distance,
angle=gp.target_goal_angle,
average_closest_ball=gp.average_closest_ball and gp.average_closest_ball.serialize(),
closest_ball=gp.closest_ball and gp.closest_ball.serialize(),
id_balls=[bi.serialize() for bi in gp.sorted_id_balls],
pwm=gp.get_desired_kicker_speed(),
real_distance=gp.real_distance,
)