--WIP-- [skip ci] split player and role numbers

crates/argument_parsers/src/lib.rs

@@ -5,13 +5,13 @@ use std::{
 };
 
 use color_eyre::{
-    eyre::{bail, eyre, WrapErr},
+    eyre::{bail, WrapErr},
     Report, Result,
 };
 use regex::Regex;
 
 use nao::{Network, SystemctlAction};
-use spl_network_messages::PlayerNumber;
+use spl_network_messages::{PlayerNumber, RoleNumber};
 
 pub const SYSTEMCTL_ACTION_POSSIBLE_VALUES: &[&str] =
     &["disable", "enable", "restart", "start", "status", "stop"];
@@ -152,16 +152,18 @@ impl TryFrom<NaoAddress> for NaoNumber {
 pub struct NaoAddressPlayerAssignment {
     pub nao_address: NaoAddress,
     pub player_number: PlayerNumber,
+    pub role_number: RoleNumber,
 }
 
 impl FromStr for NaoAddressPlayerAssignment {
     type Err = Report;
 
     fn from_str(input: &str) -> Result<Self> {
-        let (prefix, player_number) = parse_assignment(input)?;
+        let (prefix, player_number, role_number) = parse_assignment(input)?;
         Ok(Self {
             nao_address: prefix.parse()?,
             player_number,
+            role_number,
         })
     }
 }
@@ -170,16 +172,18 @@ impl FromStr for NaoAddressPlayerAssignment {
 pub struct NaoNumberPlayerAssignment {
     pub nao_number: NaoNumber,
     pub player_number: PlayerNumber,
+    pub role_number: RoleNumber,
 }
 
 impl FromStr for NaoNumberPlayerAssignment {
     type Err = Report;
 
     fn from_str(input: &str) -> Result<Self> {
-        let (prefix, player_number) = parse_assignment(input)?;
+        let (prefix, player_number, role_number) = parse_assignment(input)?;
         Ok(Self {
             nao_number: prefix.parse()?,
             player_number,
+            role_number,
         })
     }
 }
@@ -190,8 +194,15 @@ impl Display for NaoNumberPlayerAssignment {
     }
 }
 
-fn parse_assignment(input: &str) -> Result<(&str, PlayerNumber)> {
-    let (prefix, player_number) = input.rsplit_once(':').ok_or_else(|| eyre!("missing `:`"))?;
+fn parse_assignment(input: &str) -> Result<(&str, PlayerNumber, RoleNumber)> {
+    let result = input.rsplitn(3, ':').collect::<Vec<_>>();
+    if result.len() > 3 || result.len() < 2 {
+        bail!("Too many or too few arguements {input}")
+    }
+    // let (prefix, player_number) = input.rsplit_once(':').ok_or_else(|| eyre!("missing `:`"))?;
+    let prefix = result[0];
+    let player_number = result[1];
+    let role_number = result.get(2).unwrap_or(&player_number);
     let player_number = match player_number {
         "1" => PlayerNumber::One,
         "2" => PlayerNumber::Two,
@@ -200,9 +211,41 @@ fn parse_assignment(input: &str) -> Result<(&str, PlayerNumber)> {
         "5" => PlayerNumber::Five,
         "6" => PlayerNumber::Six,
         "7" => PlayerNumber::Seven,
+        "8" => PlayerNumber::Eight,
+        "9" => PlayerNumber::Nine,
+        "10" => PlayerNumber::Ten,
+        "11" => PlayerNumber::Eleven,
+        "12" => PlayerNumber::Twelve,
+        "13" => PlayerNumber::Thirteen,
+        "14" => PlayerNumber::Fourteen,
+        "15" => PlayerNumber::Fifteen,
+        "16" => PlayerNumber::Sixteen,
+        "17" => PlayerNumber::Seventeen,
+        "18" => PlayerNumber::Eighteen,
+        "19" => PlayerNumber::Nineteen,
+        "20" => PlayerNumber::Twenty,
         _ => bail!("unexpected player number {player_number}"),
     };
-    Ok((prefix, player_number))
+    let role_number = match *role_number {
+        "1" => RoleNumber::One,
+        "2" => RoleNumber::Two,
+        "3" => RoleNumber::Three,
+        "4" => RoleNumber::Four,
+        "5" => RoleNumber::Five,
+        "6" => RoleNumber::Six,
+        "7" => RoleNumber::Seven,
+        _ => bail!("unexpected role number {role_number}"),
+    };
+    Ok((prefix, player_number, role_number))
+}
+#[test]
+fn test_player_assignment() {
+    let normal = "37:1";
+    let new = "37:9:1";
+    let result = normal.rsplitn(3, ':').collect::<Vec<_>>();
+    println!("{:?}", result);
+    let result_new = new.rsplitn(3, ':').collect::<Vec<_>>();
+    println!("{:?}", result_new);
 }
 
 impl TryFrom<NaoAddressPlayerAssignment> for NaoNumberPlayerAssignment {
@@ -215,6 +258,7 @@ impl TryFrom<NaoAddressPlayerAssignment> for NaoNumberPlayerAssignment {
                 .try_into()
                 .wrap_err("failed to convert NAO address into NAO number")?,
             player_number: assignment.player_number,
+            role_number: assignment.role_number,
         })
     }
 }

crates/control/src/localization.rs

@@ -16,7 +16,7 @@ use context_attribute::context;
 use coordinate_systems::{Field, Ground};
 use filtering::pose_filter::PoseFilter;
 use framework::{AdditionalOutput, HistoricInput, MainOutput, PerceptionInput};
-use spl_network_messages::{GamePhase, Penalty, PlayerNumber, Team};
+use spl_network_messages::{GamePhase, Penalty, PlayerNumber, RoleNumber, Team};
 use types::{
     cycle_time::CycleTime,
     field_dimensions::FieldDimensions,
@@ -86,6 +86,7 @@ pub struct CycleContext {
     minimum_fit_error: Parameter<f32, "localization.minimum_fit_error">,
     odometry_noise: Parameter<Vector3<f32>, "localization.odometry_noise">,
     player_number: Parameter<PlayerNumber, "player_number">,
+    role_number: Parameter<RoleNumber, "role_number">,
     penalized_distance: Parameter<f32, "localization.penalized_distance">,
     penalized_hypothesis_covariance:
         Parameter<Matrix3<f32>, "localization.penalized_hypothesis_covariance">,
@@ -140,7 +141,7 @@ impl Localization {
         match (self.last_primary_state, primary_state, game_phase) {
             (PrimaryState::Initial, PrimaryState::Ready, _) => {
                 let initial_pose = generate_initial_pose(
-                    &context.initial_poses[*context.player_number],
+                    &context.initial_poses[*context.role_number],
                     context.field_dimensions,
                 );
                 self.hypotheses = vec![ScoredPose::from_isometry(
@@ -539,7 +540,7 @@ impl Localization {
         let ground_to_field = match primary_state {
             PrimaryState::Initial => Some(
                 generate_initial_pose(
-                    &context.initial_poses[*context.player_number],
+                    &context.initial_poses[*context.role_number],
                     context.field_dimensions,
                 )
                 .as_transform(),

crates/control/src/referee_pose_detection_filter.rs

@@ -11,7 +11,7 @@ use framework::{AdditionalOutput, MainOutput, PerceptionInput};
 use hardware::NetworkInterface;
 use linear_algebra::Isometry2;
 use serde::{Deserialize, Serialize};
-use spl_network_messages::{HulkMessage, PlayerNumber};
+use spl_network_messages::{HulkMessage, PlayerNumber, RoleNumber};
 use types::{
     cycle_time::CycleTime,
     fall_state::FallState,
@@ -45,6 +45,7 @@ pub struct CycleContext {
     minimum_above_head_arms_detections:
         Parameter<usize, "referee_pose_detection_filter.minimum_above_head_arms_detections">,
     player_number: Parameter<PlayerNumber, "player_number">,
+    role_number: Parameter<RoleNumber, "role_number">,
 
     player_referee_detection_times:
         AdditionalOutput<Players<Option<SystemTime>>, "player_referee_detection_times">,
@@ -93,7 +94,7 @@ impl RefereePoseDetectionFilter {
 
         for (time, message) in time_tagged_persistent_messages {
             if message.is_referee_ready_signal_detected {
-                self.detection_times[message.player_number] = Some(time);
+                self.detection_times[message.role_number] = Some(time);
             }
         }
 
@@ -104,10 +105,11 @@ impl RefereePoseDetectionFilter {
             .into_iter()
             .find(|(_, pose_kind)| *pose_kind == PoseKind::AboveHeadArms)
         {
-            self.detection_times[*context.player_number] = Some(time);
+            self.detection_times[*context.role_number] = Some(time);
             send_own_detection_message(
                 context.hardware_interface.clone(),
                 *context.player_number,
+                *context.role_number,
                 *context.fall_state,
                 *context.time_to_reach_kick_position,
             )?;
@@ -173,11 +175,13 @@ fn unpack_own_detection_tree(
 fn send_own_detection_message<T: NetworkInterface>(
     hardware_interface: Arc<T>,
     player_number: PlayerNumber,
+    role_number: RoleNumber,
     fall_state: FallState,
     time_to_reach_kick_position: Duration,
 ) -> Result<()> {
     hardware_interface.write_to_network(OutgoingMessage::Spl(HulkMessage {
         player_number,
+        role_number,
         fallen: matches!(fall_state, FallState::Fallen { .. }),
         pose: Isometry2::<Ground, Field>::default().as_pose(),
         is_referee_ready_signal_detected: true,

crates/control/src/role_assignment.rs

@@ -101,7 +101,7 @@ impl RoleAssignment {
                 .copied()
                 .unwrap_or_else(|| match context.primary_state {
                     PrimaryState::Initial => generate_initial_pose(
-                        &context.initial_poses[*context.player_number],
+                        &context.initial_poses[*context._number],
                         context.field_dimensions,
                     )
                     .as_transform(),
@@ -113,7 +113,7 @@ impl RoleAssignment {
             || primary_state == PrimaryState::Set
         {
             #[allow(clippy::get_first)]
-            let mut player_roles = Players {
+            let mut roles = Players {
                 one: Role::Keeper,
                 two: context.optional_roles.get(0).copied().unwrap_or_default(),
                 three: context.optional_roles.get(1).copied().unwrap_or_default(),
@@ -133,10 +133,10 @@ impl RoleAssignment {
                 .into_iter()
                 .find(|player| game_controller_state.penalties[*player].is_none())
                 {
-                    player_roles[striker] = Role::Striker;
+                    roles[striker] = Role::Striker;
                 }
             }
-            role = player_roles[*context.player_number];
+            role = roles[*context.role_number];
 
             self.role_initialized = true;
             self.last_received_spl_striker_message = Some(cycle_start_time);
@@ -307,6 +307,7 @@ impl RoleAssignment {
                         .hardware
                         .write_to_network(OutgoingMessage::Spl(HulkMessage {
                             player_number: *context.player_number,
+                            role_number: *context.role_number,
                             fallen: matches!(context.fall_state, FallState::Fallen { .. }),
                             pose: ground_to_field.as_pose(),
                             is_referee_ready_signal_detected: false,
@@ -351,6 +352,7 @@ fn process_role_state_machine(
     cycle_start_time: SystemTime,
     filtered_game_controller_state: Option<&FilteredGameControllerState>,
     player_number: PlayerNumber,
+    role_number: RoleNumber,
     striker_trusts_team_ball: Duration,
     optional_roles: &[Role],
 ) -> (Role, bool, Option<BallPosition<Field>>) {
@@ -597,6 +599,7 @@ fn decide_if_claiming_striker_or_other_role(
     spl_message: &HulkMessage,
     time_to_reach_kick_position: Option<Duration>,
     player_number: PlayerNumber,
+    role_number: RoleNumber,
     cycle_start_time: SystemTime,
     filtered_game_controller_state: Option<&FilteredGameControllerState>,
     optional_roles: &[Role],

crates/control/src/world_state_composer.rs

@@ -1,10 +1,10 @@
 use color_eyre::Result;
 use context_attribute::context;
 use coordinate_systems::{Field, Ground};
-use framework::MainOutput;
+use framework::{MainOutput, Parameters};
 use linear_algebra::{Isometry2, Point2};
 use serde::{Deserialize, Serialize};
-use spl_network_messages::PlayerNumber;
+use spl_network_messages::{PlayerNumber, RoleNumber};
 use types::{
     ball_position::HypotheticalBallPosition,
     fall_state::FallState,
@@ -37,6 +37,7 @@ pub struct CycleContext {
     instant_kick_decisions: Input<Option<Vec<KickDecision>>, "instant_kick_decisions?">,
 
     player_number: Parameter<PlayerNumber, "player_number">,
+    role_number: Parameter<RoleNumber, "role_number">,
 
     fall_state: Input<FallState, "fall_state">,
     has_ground_contact: Input<bool, "has_ground_contact">,
@@ -66,6 +67,7 @@ impl WorldStateComposer {
             fall_state: *context.fall_state,
             has_ground_contact: *context.has_ground_contact,
             player_number: *context.player_number,
+            role_number: *context.role_number,
         };
 
         let world_state = WorldState {

crates/object_detection/src/pose_interpretation.rs

@@ -9,7 +9,6 @@ use linear_algebra::{center, distance, Isometry2, Point2, Transform};
 use ordered_float::NotNan;
 use projection::{camera_matrices::CameraMatrices, camera_matrix::CameraMatrix, Projection};
 use serde::{Deserialize, Serialize};
-use spl_network_messages::PlayerNumber;
 use types::{
     fall_state::FallState,
     pose_detection::{HumanPose, Keypoints, RefereePoseCandidate},
@@ -36,7 +35,6 @@ pub struct CycleContext {
         Input<Option<Point2<Field>>, "Control", "expected_referee_position?">,
     fall_state: Input<FallState, "Control", "fall_state">,
 
-    player_number: Parameter<PlayerNumber, "player_number">,
     keypoint_confidence_threshold:
         Parameter<f32, "object_detection.$cycler_instance.keypoint_confidence_threshold">,
     distance_to_referee_position_threshold:

crates/repository/src/lib.rs

@@ -21,7 +21,7 @@ use home::home_dir;
 use itertools::intersperse;
 use parameters::{
     directory::{serialize, Id, Location, Scope},
-    json::nest_value_at_path,
+    json::{merge_json, nest_value_at_path},
 };
 use semver::Version;
 use serde::Deserialize;
@@ -36,7 +36,7 @@ use tokio::{
     process::Command,
 };
 
-use spl_network_messages::PlayerNumber;
+use spl_network_messages::{PlayerNumber, RoleNumber};
 
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(5);
 
@@ -253,23 +253,30 @@ impl Repository {
         Ok(())
     }
 
-    pub async fn set_player_number(
+    pub async fn set_player_and_role_number(
         &self,
         head_id: &str,
         player_number: PlayerNumber,
+        role_number: RoleNumber,
     ) -> Result<()> {
-        let path = "player_number";
-        let parameters = nest_value_at_path(
-            path,
+        let player_number_path = "player_number";
+        let mut parameters = nest_value_at_path(
+            player_number_path,
             to_value(player_number).wrap_err("failed to serialize player number")?,
         );
+        let role_number_path = "role_number";
+        let role_parameter = nest_value_at_path(
+            role_number_path,
+            to_value(role_number).wrap_err("failed to serialize role number")?,
+        );
+        merge_json(&mut parameters, &role_parameter);
         serialize(
             &parameters,
             Scope {
                 location: Location::All,
                 id: Id::Head,
             },
-            path,
+            player_number_path,
             self.parameters_root(),
             "unknown_body_id",
             head_id,

crates/spl_network_messages/src/game_controller_return_message.rs

@@ -123,6 +123,19 @@ impl From<GameControllerReturnMessage> for RoboCupGameControlReturnData {
                 PlayerNumber::Five => 5,
                 PlayerNumber::Six => 6,
                 PlayerNumber::Seven => 7,
+                PlayerNumber::Eight => 8,
+                PlayerNumber::Nine => 9,
+                PlayerNumber::Ten => 10,
+                PlayerNumber::Eleven => 11,
+                PlayerNumber::Twelve => 12,
+                PlayerNumber::Thirteen => 13,
+                PlayerNumber::Fourteen => 14,
+                PlayerNumber::Fifteen => 15,
+                PlayerNumber::Sixteen => 16,
+                PlayerNumber::Seventeen => 17,
+                PlayerNumber::Eighteen => 18,
+                PlayerNumber::Nineteen => 19,
+                PlayerNumber::Twenty => 20,
             },
             teamNum: HULKS_TEAM_NUMBER,
             fallen: u8::from(message.fallen),