Bevyhaviorsimulator parameters (HULKs#2098)

* Bevyhavior simulator: split up parameters and simulator state

* Serve parameters from currently selected robot

* Naming consistency

Author: rmburg

crates/bevyhavior_simulator/default.json

@@ -1,21 +1,4 @@
 {
   "selected_frame": 0,
-  "selected_robot": 7,
-  "field_dimensions": {
-    "ball_radius": 0.05,
-    "length": 9.0,
-    "width": 6.0,
-    "line_width": 0.05,
-    "penalty_marker_size": 0.1,
-    "goal_box_area_length": 0.6,
-    "goal_box_area_width": 2.2,
-    "penalty_area_length": 1.65,
-    "penalty_area_width": 4.0,
-    "penalty_marker_distance": 1.3,
-    "center_circle_diameter": 1.5,
-    "border_strip_width": 0.7,
-    "goal_inner_width": 1.5,
-    "goal_post_diameter": 0.1,
-    "goal_depth": 0.5
-  }
+  "selected_robot": 7
 }

crates/bevyhavior_simulator/src/recorder.rs

@@ -16,12 +16,19 @@ use tokio_util::sync::CancellationToken;
 
 use types::{ball_position::SimulatorBallState, players::Players};
 
-use crate::{ball::BallResource, cyclers::control::Database, robot::Robot, server};
+use crate::{
+    ball::BallResource, cyclers::control::Database, robot::Robot, server, structs::Parameters,
+};
 
 pub struct Frame {
     pub timestamp: SystemTime,
     pub ball: Option<SimulatorBallState>,
-    pub robots: Players<Option<Database>>,
+    pub robots: Players<Option<RobotFrame>>,
+}
+
+pub struct RobotFrame {
+    pub database: Database,
+    pub parameters: Parameters,
 }
 
 #[derive(Resource)]
@@ -37,9 +44,12 @@ pub fn frame_recorder(
     recording: ResMut<Recording>,
     time: Res<Time>,
 ) {
-    let mut players = Players::<Option<Database>>::default();
+    let mut players = Players::<Option<RobotFrame>>::default();
     for robot in &robots {
-        players[robot.parameters.player_number] = Some(robot.database.clone())
+        players[robot.parameters.player_number] = Some(RobotFrame {
+            database: robot.database.clone(),
+            parameters: robot.parameters.clone(),
+        })
     }
     recording
         .frame_sender

crates/bevyhavior_simulator/src/server.rs

@@ -8,17 +8,16 @@ use tokio_util::sync::CancellationToken;
 
 use hula_types::hardware::Ids;
 use path_serde::{PathDeserialize, PathIntrospect, PathSerialize};
-use types::{
-    ball_position::SimulatorBallState, field_dimensions::FieldDimensions, players::Players,
-};
+use types::{ball_position::SimulatorBallState, players::Players};
 
-use crate::{cyclers::control::Database, recorder::Frame, robot::to_player_number};
+use crate::{
+    cyclers::control::Database, recorder::Frame, robot::to_player_number, structs::Parameters,
+};
 
 #[derive(Clone, Serialize, Deserialize, PathSerialize, PathDeserialize, PathIntrospect)]
-pub struct Parameters {
+pub struct SimulatorState {
     selected_frame: usize,
     selected_robot: usize,
-    pub field_dimensions: FieldDimensions,
 }
 
 #[derive(Clone, Default, Serialize, PathSerialize, PathIntrospect)]
@@ -35,9 +34,10 @@ struct BehaviorSimulatorDatabase {
 
 async fn timeline_server(
     keep_running: CancellationToken,
-    mut parameters_reader: buffered_watch::Receiver<(SystemTime, Parameters)>,
+    mut simulator_state_reader: buffered_watch::Receiver<(SystemTime, SimulatorState)>,
     mut outputs_writer: buffered_watch::Sender<(SystemTime, BehaviorSimulatorDatabase)>,
     mut control_writer: buffered_watch::Sender<(SystemTime, Database)>,
+    mut parameter_writer: buffered_watch::Sender<(SystemTime, Parameters)>,
     mut frame_receiver: UnboundedReceiver<Frame>,
 ) {
     let mut frames = Vec::<Frame>::new();
@@ -61,26 +61,46 @@ async fn timeline_server(
                     }
                 }
             }
-            _ = parameters_reader.wait_for_change() => { }
+            _ = simulator_state_reader.wait_for_change() => { }
             _ = keep_running.cancelled() => {
                 break
             }
         }
 
-        let (_, parameters) = &*parameters_reader.borrow_and_mark_as_seen();
-        if let Some(frame) = &frames.get(parameters.selected_frame) {
+        let (_, simulator_state) = &*simulator_state_reader.borrow_and_mark_as_seen();
+        if let Some(frame) = &frames.get(simulator_state.selected_frame) {
             {
                 let (time, outputs) = &mut *outputs_writer.borrow_mut();
                 outputs.main_outputs.frame_count = frames.len();
                 outputs.main_outputs.ball.clone_from(&frame.ball);
-                outputs.main_outputs.databases = frame.robots.clone();
+                outputs.main_outputs.databases = frame.robots.as_ref().map(|maybe_robot_frame| {
+                    maybe_robot_frame
+                        .as_ref()
+                        .map(|robot_frame| robot_frame.database.clone())
+                });
                 *time = frame.timestamp;
             }
             {
                 let (time, control) = &mut *control_writer.borrow_mut();
-                *control = to_player_number(parameters.selected_robot)
+                *control = to_player_number(simulator_state.selected_robot)
+                    .ok()
+                    .and_then(|player_number| {
+                        frame.robots[player_number]
+                            .as_ref()
+                            .map(|robot_frame| robot_frame.database.clone())
+                    })
+                    .unwrap_or_default();
+                *time = frame.timestamp;
+            }
+            {
+                let (time, parameters) = &mut *parameter_writer.borrow_mut();
+                *parameters = to_player_number(simulator_state.selected_robot)
                     .ok()
-                    .and_then(|player_number| frame.robots[player_number].clone())
+                    .and_then(|player_number| {
+                        frame.robots[player_number]
+                            .as_ref()
+                            .map(|robot_frame| robot_frame.parameters.clone())
+                    })
                     .unwrap_or_default();
                 *time = frame.timestamp;
             }
@@ -97,12 +117,12 @@ pub async fn run(
         body_id: "behavior_simulator".to_string(),
         head_id: "behavior_simulator".to_string(),
     };
-    let parameters_from_disk: Parameters =
+    let initial_simulator_state: SimulatorState =
         parameters::directory::deserialize("crates/bevyhavior_simulator", &ids, true)
             .wrap_err("failed to parse initial parameters")?;
-    let initial_parameters = parameters_from_disk;
-    let (parameters_sender, parameters_receiver) =
-        buffered_watch::channel((std::time::SystemTime::now(), initial_parameters));
+
+    let (simulator_state_sender, simulator_state_receiver) =
+        buffered_watch::channel((std::time::SystemTime::now(), initial_simulator_state));
 
     let (outputs_sender, outputs_receiver) =
         buffered_watch::channel((UNIX_EPOCH, Default::default()));
@@ -113,32 +133,38 @@ pub async fn run(
     let (control_writer, control_reader) =
         buffered_watch::channel((UNIX_EPOCH, Default::default()));
 
-    let (subscribed_control_writer, _subscribed_control_reader) =
-        buffered_watch::channel(Default::default());
+    let (parameter_writer, parameter_reader) =
+        buffered_watch::channel((UNIX_EPOCH, Default::default()));
 
     let mut communication_server = communication::server::Server::default();
+
+    let (control_subscriptions, _) = buffered_watch::channel(Default::default());
     let (parameters_subscriptions, _) = buffered_watch::channel(Default::default());
+    let (simulator_state_subscriptions, _) = buffered_watch::channel(Default::default());
+
     communication_server.expose_source(
         "BehaviorSimulator",
         outputs_receiver,
         subscribed_outputs_sender,
     )?;
-    communication_server.expose_source("Control", control_reader, subscribed_control_writer)?;
+    communication_server.expose_source("Control", control_reader, control_subscriptions)?;
+    communication_server.expose_source("parameters", parameter_reader, parameters_subscriptions)?;
     communication_server.expose_source(
-        "parameters",
-        parameters_receiver.clone(),
-        parameters_subscriptions,
+        "simulator",
+        simulator_state_receiver.clone(),
+        simulator_state_subscriptions,
     )?;
-    communication_server.expose_sink("parameters", parameters_sender)?;
+    communication_server.expose_sink("simulator", simulator_state_sender)?;
 
     {
         let keep_running = keep_running.clone();
         tokio::spawn(async {
             timeline_server(
                 keep_running,
-                parameters_receiver,
+                simulator_state_receiver,
                 outputs_sender,
                 control_writer,
+                parameter_writer,
                 frame_receiver,
             )
             .await

crates/bevyhavior_simulator/src/simulator.rs

@@ -24,8 +24,8 @@ use crate::{
     game_controller::{game_controller_plugin, GameController},
     recorder::Recording,
     robot::{cycle_robots, move_robots, Messages},
-    server::Parameters,
     soft_error::{soft_error_plugin, SoftErrorResource},
+    structs::Parameters,
     test_rules::check_robots_dont_walk_into_rule_obstacles,
     time::{update_time, Ticks},
     visual_referee::VisualRefereeResource,
@@ -127,7 +127,7 @@ fn load_parameters() -> Result<Parameters> {
     let current_directory = current_dir().wrap_err("failed to get current directory")?;
     let repository =
         Repository::find_root(current_directory).wrap_err("failed to get repository root")?;
-    let parameters_path = repository.root.join("crates/bevyhavior_simulator");
+    let parameters_path = repository.root.join("etc/parameters");
 
     parameters::directory::deserialize(parameters_path, &ids, true)
         .wrap_err("failed to parse initial parameters")

crates/types/src/players.rs

@@ -28,6 +28,20 @@ pub struct Players<T> {
     pub seven: T,
 }
 
+impl<T> Players<T> {
+    pub fn as_ref(&self) -> Players<&T> {
+        Players {
+            one: &self.one,
+            two: &self.two,
+            three: &self.three,
+            four: &self.four,
+            five: &self.five,
+            six: &self.six,
+            seven: &self.seven,
+        }
+    }
+}
+
 impl<From> Players<From> {
     pub fn map<To>(self, mut f: impl FnMut(From) -> To) -> Players<To> {
         Players {

tools/twix/src/panels/behavior_simulator.rs

@@ -23,7 +23,7 @@ impl Panel for BehaviorSimulatorPanel {
     const NAME: &'static str = "Behavior Simulator";
 
     fn new(nao: Arc<Nao>, value: Option<&Value>) -> Self {
-        let selected_frame_updater = nao.subscribe_value("parameters.selected_frame");
+        let selected_frame_updater = nao.subscribe_value("simulator.selected_frame");
 
         let frame_count = nao.subscribe_value("BehaviorSimulator.main_outputs.frame_count");
         let selected_frame = value
@@ -117,7 +117,7 @@ impl Widget for &mut BehaviorSimulatorPanel {
                         .ui(ui);
                         if response.changed() {
                             self.nao.write(
-                                "parameters.selected_robot",
+                                "simulator.selected_robot",
                                 TextOrBinary::Text(robots[self.selected_robot].into()),
                             );
                         };
@@ -138,7 +138,7 @@ impl Widget for &mut BehaviorSimulatorPanel {
         if let Some(new_frame) = new_frame {
             self.selected_frame = (new_frame + frame_count as f64) % frame_count as f64;
             self.nao.write(
-                "parameters.selected_frame",
+                "simulator.selected_frame",
                 TextOrBinary::Text((self.selected_frame as usize).into()),
             );
         }