--wip-- [skip ci]

crates/control/src/game_controller_state_filter.rs

@@ -9,7 +9,7 @@ use coordinate_systems::{Field, Ground};
 use framework::{AdditionalOutput, MainOutput};
 use linear_algebra::{distance, Isometry2, Point2, Vector2};
 use serde::{Deserialize, Serialize};
-use spl_network_messages::{GamePhase, GameState, Penalty, PlayerNumber, Team};
+use spl_network_messages::{GamePhase, GameState, Penalty, Team};
 use types::{
     ball_position::BallPosition, cycle_time::CycleTime, field_dimensions::FieldDimensions,
     filtered_game_controller_state::FilteredGameControllerState,
@@ -38,7 +38,7 @@ pub struct CycleContext {
     game_controller_state: RequiredInput<Option<GameControllerState>, "game_controller_state?">,
     config: Parameter<GameStateFilterParameters, "game_state_filter">,
     field_dimensions: Parameter<FieldDimensions, "field_dimensions">,
-    player_number: Parameter<PlayerNumber, "player_number">,
+    jersey_number: Parameter<usize, "jersey_number">,
 
     ground_to_field: CyclerState<Isometry2<Ground, Field>, "ground_to_field">,
 
@@ -89,7 +89,7 @@ impl GameControllerStateFilter {
             context.filtered_whistle,
             context.cycle_time,
             *context.visual_referee_proceed_to_ready,
-            *context.player_number,
+            *context.jersey_number,
             did_receive_motion_in_set_penalty,
         );
         let filtered_game_controller_state = FilteredGameControllerState {
@@ -107,6 +107,8 @@ impl GameControllerStateFilter {
                 .hulks_team_is_home_after_coin_toss,
             new_own_penalties_last_cycle,
             new_opponent_penalties_last_cycle,
+            field_player_penalties: todo!(),
+            goalkeeper_penalties: todo!(),
         };
         context
             .whistle_in_set_ball_position
@@ -129,7 +131,7 @@ impl GameControllerStateFilter {
         filtered_whistle: &FilteredWhistle,
         cycle_time: &CycleTime,
         visual_referee_proceed_to_ready: bool,
-        player_number: PlayerNumber,
+        jersey_number: usize,
         did_receive_motion_in_set_penalty: bool,
     ) -> FilteredGameStates {
         let ball_detected_far_from_any_goal = ball_detected_far_from_any_goal(
@@ -166,7 +168,7 @@ impl GameControllerStateFilter {
             }
         }
         let motion_in_set = matches!(
-            game_controller_state.penalties[player_number],
+            game_controller_state.penalties[jersey_number],
             Some(Penalty::IllegalMotionInSet { .. })
         );
         if matches!(self.state, State::Playing { .. }) || motion_in_set {
@@ -503,17 +505,20 @@ impl State {
 fn penalty_diff(
     last: Players<Option<Penalty>>,
     current: Players<Option<Penalty>>,
-) -> HashMap<PlayerNumber, Penalty> {
-    let current_penalties = current
+) -> HashMap<usize, Penalty> {
+    let current_penalties =
+        current
+            .inner
+            .iter()
+            .fold(HashMap::new(), |mut map, (player, penalty)| {
+                if let Some(penalty) = penalty {
+                    map.insert(player, *penalty);
+                }
+                map
+            });
+    last.inner
         .iter()
-        .fold(HashMap::new(), |mut map, (player, penalty)| {
-            if let Some(penalty) = penalty {
-                map.insert(player, *penalty);
-            }
-            map
-        });
-    last.iter()
-        .fold(current_penalties, |mut map, (player, penalty)| {
+        .fold(current_penalties, |mut map, (penalty)| {
             if penalty.is_some() {
                 map.remove(&player);
             }

crates/control/src/primary_state_filter.rs

@@ -5,7 +5,6 @@ use context_attribute::context;
 use framework::MainOutput;
 use hardware::{RecordingInterface, SpeakerInterface};
 use serde::{Deserialize, Serialize};
-use spl_network_messages::PlayerNumber;
 use types::{
     audio::{Sound, SpeakerRequest},
     buttons::Buttons,
@@ -28,7 +27,7 @@ pub struct CycleContext {
     filtered_game_controller_state:
         Input<Option<FilteredGameControllerState>, "filtered_game_controller_state?">,
 
-    player_number: Parameter<PlayerNumber, "player_number">,
+    jersey_number: Parameter<usize, "jersey_number">,
     recorded_primary_states: Parameter<HashSet<PrimaryState>, "recorded_primary_states">,
 
     hardware_interface: HardwareInterface,
@@ -53,7 +52,7 @@ impl PrimaryStateFilter {
     ) -> Result<MainOutputs> {
         let is_penalized = match context.filtered_game_controller_state {
             Some(game_controller_state) => {
-                game_controller_state.penalties[*context.player_number].is_some()
+                game_controller_state.penalties[*context.jersey_number].is_some()
             }
             None => false,
         };

crates/control/src/referee_pose_detection_filter.rs

@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 use context_attribute::context;
 use framework::{AdditionalOutput, MainOutput, PerceptionInput};
 use hardware::NetworkInterface;
-use spl_network_messages::{HulkMessage, PlayerNumber, VisualRefereeMessage};
+use spl_network_messages::{HulkMessage, VisualRefereeMessage};
 use types::{
     cycle_time::CycleTime,
     messages::{IncomingMessage, OutgoingMessage},
@@ -46,7 +46,7 @@ pub struct CycleContext {
         Parameter<Duration, "referee_pose_detection_filter.initial_message_grace_period">,
     minimum_above_head_arms_detections:
         Parameter<usize, "referee_pose_detection_filter.minimum_above_head_arms_detections">,
-    player_number: Parameter<PlayerNumber, "player_number">,
+    jersey_number: Parameter<usize, "jersey_number">,
     referee_pose_queue_length: Parameter<usize, "pose_detection.referee_pose_queue_length">,
     minimum_number_poses_before_message:
         Parameter<usize, "pose_detection.minimum_number_poses_before_message">,
@@ -113,7 +113,7 @@ impl RefereePoseDetectionFilter {
             unpack_message_tree(&context.network_message.persistent);
 
         for (time, message) in time_tagged_persistent_messages {
-            self.detection_times[message.player_number] = Some(time);
+            self.detection_times[message.jersey_number] = Some(time);
         }
         let own_detected_pose_times =
             unpack_own_detection_tree(&context.referee_pose_kind.persistent);
@@ -137,9 +137,9 @@ impl RefereePoseDetectionFilter {
             .count();
 
         if detected_referee_pose_count >= *context.minimum_number_poses_before_message {
-            self.detection_times[*context.player_number] = Some(context.cycle_time.start_time);
+            self.detection_times[*context.jersey_number] = Some(context.cycle_time.start_time);
 
-            send_own_detection_message(context.hardware_interface.clone(), *context.player_number)?;
+            send_own_detection_message(context.hardware_interface.clone(), *context.jersey_number)?;
         }
 
         Ok((
@@ -157,7 +157,7 @@ fn decide(
 ) -> bool {
     let detected_above_head_arms_poses = pose_detection_times
         .iter()
-        .filter(|(_, detection_time)| match detection_time {
+        .filter(|(detection_time)| match detection_time {
             Some(detection_time) => is_in_grace_period(
                 cycle_start_time,
                 *detection_time,
@@ -210,9 +210,9 @@ fn unpack_own_detection_tree(
 
 fn send_own_detection_message<T: NetworkInterface>(
     hardware_interface: Arc<T>,
-    player_number: PlayerNumber,
+    jersey_number: usize,
 ) -> Result<()> {
     hardware_interface.write_to_network(OutgoingMessage::Spl(HulkMessage::VisualReferee(
-        VisualRefereeMessage { player_number },
+        VisualRefereeMessage { jersey_number },
     )))
 }

crates/spl_network/src/message_filter.rs

@@ -2,7 +2,7 @@ use color_eyre::{eyre::Ok, Result};
 use context_attribute::context;
 use framework::MainOutput;
 use serde::{Deserialize, Serialize};
-use spl_network_messages::{HulkMessage, PlayerNumber, StrikerMessage, VisualRefereeMessage};
+use spl_network_messages::{HulkMessage, StrikerMessage, VisualRefereeMessage};
 use types::messages::IncomingMessage;
 
 #[derive(Deserialize, Serialize)]
@@ -14,7 +14,7 @@ pub struct CreationContext {}
 #[context]
 pub struct CycleContext {
     message: Input<IncomingMessage, "message">,
-    player_number: Parameter<PlayerNumber, "player_number">,
+    jersey_number: Parameter<usize, "jersey_number">,
 }
 
 #[context]
@@ -33,11 +33,11 @@ impl MessageFilter {
                 IncomingMessage::GameController(*source_address, message.clone()),
             ),
             IncomingMessage::Spl(
-                message @ (HulkMessage::Striker(StrikerMessage { player_number, .. })
+                message @ (HulkMessage::Striker(StrikerMessage { jersey_number, .. })
                 | HulkMessage::VisualReferee(VisualRefereeMessage {
-                    player_number, ..
+                    jersey_number, ..
                 })),
-            ) if player_number != context.player_number => Some(IncomingMessage::Spl(*message)),
+            ) if jersey_number != context.jersey_number => Some(IncomingMessage::Spl(*message)),
             _ => None,
         };
         Ok(MainOutputs {

crates/spl_network_messages/src/lib.rs

@@ -32,15 +32,15 @@ impl Default for HulkMessage {
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, Serialize)]
 pub struct StrikerMessage {
-    pub player_number: PlayerNumber,
+    pub jersey_number: usize,
     pub pose: Pose2<Field>,
     pub ball_position: Option<BallPosition<Field>>,
     pub time_to_reach_kick_position: Option<Duration>,
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, Serialize)]
 pub struct VisualRefereeMessage {
-    pub player_number: PlayerNumber,
+    pub jersey_number: usize,
 }
 
 #[derive(
@@ -110,12 +110,12 @@ mod tests {
 
     use linear_algebra::{Point, Pose2};
 
-    use crate::{BallPosition, HulkMessage, PlayerNumber, StrikerMessage, VisualRefereeMessage};
+    use crate::{BallPosition, HulkMessage, StrikerMessage, VisualRefereeMessage};
 
     #[test]
     fn hulk_striker_message_size() {
         let test_message = HulkMessage::Striker(StrikerMessage {
-            player_number: PlayerNumber::Seven,
+            jersey_number: 7,
             pose: Pose2::default(),
             ball_position: Some(BallPosition {
                 position: Point::origin(),
@@ -128,9 +128,7 @@ mod tests {
 
     #[test]
     fn hulk_visual_referee_message_size() {
-        let test_message = HulkMessage::VisualReferee(VisualRefereeMessage {
-            player_number: PlayerNumber::Four,
-        });
+        let test_message = HulkMessage::VisualReferee(VisualRefereeMessage { jersey_number: 4 });
         assert!(bincode::serialize(&test_message).unwrap().len() <= 128)
     }
 }

crates/types/src/filtered_game_controller_state.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use path_serde::{PathIntrospect, PathSerialize};
 use serde::{Deserialize, Serialize};
-use spl_network_messages::{GamePhase, Penalty, PlayerNumber, SubState, Team};
+use spl_network_messages::{GamePhase, Penalty, SubState, Team};
 
 use crate::{filtered_game_state::FilteredGameState, players::Players};
 
@@ -16,10 +16,12 @@ pub struct FilteredGameControllerState {
     pub game_phase: GamePhase,
     pub kicking_team: Team,
     pub penalties: Players<Option<Penalty>>,
+    pub field_player_penalties: Players<Option<Penalty>>,
+    pub goalkeeper_penalties: Option<Penalty>,
     pub remaining_number_of_messages: u16,
     pub sub_state: Option<SubState>,
     pub own_team_is_home_after_coin_toss: bool,
 
-    pub new_own_penalties_last_cycle: HashMap<PlayerNumber, Penalty>,
-    pub new_opponent_penalties_last_cycle: HashMap<PlayerNumber, Penalty>,
+    pub new_own_penalties_last_cycle: HashMap<usize, Penalty>,
+    pub new_opponent_penalties_last_cycle: HashMap<usize, Penalty>,
 }

crates/types/src/game_controller_state.rs

@@ -1,14 +1,12 @@
 use std::time::SystemTime;
 
+use crate::players::Players;
+
 use path_serde::{PathDeserialize, PathIntrospect, PathSerialize};
 use serde::{Deserialize, Serialize};
 use spl_network_messages::{GamePhase, GameState, Penalty, SubState, Team};
 
-use crate::players::Players;
-
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, PathSerialize, PathDeserialize, PathIntrospect,
-)]
+#[derive(Clone, Debug, Serialize, Deserialize, PathSerialize, PathDeserialize, PathIntrospect)]
 pub struct GameControllerState {
     pub game_state: GameState,
     pub game_phase: GamePhase,

crates/types/src/jerseys.rs

@@ -0,0 +1,14 @@
+#[derive(
+    Clone,
+    Copy,
+    Default,
+    Debug,
+    Deserialize,
+    Serialize,
+    PathSerialize,
+    PathIntrospect,
+    PathDeserialize,
+    PartialEq,
+)]
+
+pub struct Jerseys {}

crates/types/src/last_filtered_game_controller_state_change.rs

@@ -4,7 +4,7 @@ use crate::players::Players;
 use path_serde::{PathIntrospect, PathSerialize};
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PathSerialize, PathIntrospect, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PathSerialize, PathIntrospect, PartialEq)]
 
 pub struct LastFilteredGameControllerStateChanges {
     pub game_state: SystemTime,
@@ -22,15 +22,7 @@ impl Default for LastFilteredGameControllerStateChanges {
             opponent_game_state: SystemTime::now(),
             game_phase: SystemTime::now(),
             kicking_team: SystemTime::now(),
-            penalties: Players {
-                one: None,
-                two: None,
-                three: None,
-                four: None,
-                five: None,
-                six: None,
-                seven: None,
-            },
+            penalties: Players::new(),
             sub_state: None,
         }
     }