reintroduce node.rs (HULKs#2217)

* add noders to worldstate

Co-authored-by: JackyBlox <90517319+JackyBloxx@users.noreply.github.com>

* trying to make clippy happy

---------

Co-authored-by: JackyBlox <90517319+JackyBloxx@users.noreply.github.com>

Author: pejotejo

crates/hulk_manifest/src/lib.rs

@@ -52,7 +52,7 @@ pub fn collect_hulk_cyclers(root: impl AsRef<Path>) -> Result<Cyclers, Error> {
                 nodes: vec![
                     "world_state::ball_filter",
                     "world_state::ball_projector",
-                    "world_state::behavior::walk_to_ball",
+                    "world_state::behavior::node",
                     "world_state::camera_matrix_calculator",
                     "world_state::game_controller_filter",
                     "world_state::game_controller_state_filter",

crates/types/src/action.rs

@@ -1,8 +1,6 @@
 use path_serde::{PathDeserialize, PathIntrospect, PathSerialize};
 use serde::{Deserialize, Serialize};
 
-use crate::field_dimensions::Side;
-
 #[derive(
     Debug,
     Clone,
@@ -16,34 +14,5 @@ use crate::field_dimensions::Side;
     Eq,
 )]
 pub enum Action {
-    Animation,
-    Calibrate,
-    DefendGoal,
-    DefendKickOff,
-    DefendLeft,
-    DefendPenaltyKick,
-    DefendRight,
-    DefendOpponentCornerKick { side: Side },
-    Dribble,
-    FallSafely,
-    Initial,
-    InterceptBall,
-    Jump,
-    LookAround,
-    LookAtReferee,
-    NoGroundContact,
-    Penalize,
-    PrepareJump,
-    Search,
-    SearchForLostBall,
-    SitDown,
-    Stand,
-    StandUp,
-    KeeperMotion,
-    SupportLeft,
-    SupportRight,
-    SupportStriker,
-    Unstiff,
-    WalkToKickOff,
-    WalkToPenaltyKick,
+    WalkToBall,
 }

crates/world_state/src/behavior/mod.rs

@@ -1 +1,2 @@
+pub mod node;
 pub mod walk_to_ball;

crates/world_state/src/behavior/node.rs

@@ -0,0 +1,64 @@
+use color_eyre::Result;
+use serde::{Deserialize, Serialize};
+
+use context_attribute::context;
+use coordinate_systems::Ground;
+use framework::{AdditionalOutput, MainOutput};
+use types::{
+    action::Action, ball_position::BallPosition, motion_command::MotionCommand,
+    parameters::WalkWithVelocityParameters,
+};
+
+use crate::behavior::walk_to_ball;
+
+#[derive(Deserialize, Serialize)]
+pub struct Behavior {}
+
+#[context]
+pub struct CreationContext {}
+
+#[context]
+pub struct CycleContext {
+    ball_position: Input<Option<BallPosition<Ground>>, "ball_position?">,
+    walk_with_velocity_parameter:
+        Parameter<WalkWithVelocityParameters, "behavior.walk_with_velocity">,
+    active_action_output: AdditionalOutput<Action, "active_action">,
+    last_motion_command: CyclerState<MotionCommand, "last_motion_command">,
+}
+
+#[context]
+#[derive(Default)]
+pub struct MainOutputs {
+    pub motion_command: MainOutput<MotionCommand>,
+}
+
+impl Behavior {
+    pub fn new(_context: CreationContext) -> Result<Self> {
+        Ok(Self {})
+    }
+
+    pub fn cycle(&mut self, mut context: CycleContext) -> Result<MainOutputs> {
+        #[allow(clippy::useless_vec, unused_mut)]
+        let mut actions = vec![Action::WalkToBall];
+
+        let (action, motion_command) = actions
+            .iter()
+            .find_map(|action| {
+                let motion_command = match action {
+                    Action::WalkToBall => walk_to_ball::execute(
+                        context.ball_position.copied(),
+                        context.walk_with_velocity_parameter.clone(),
+                    ),
+                }?;
+                Some((action, motion_command))
+            })
+            .unwrap_or_else(|| panic!("there has to be at least one action available",));
+        context.active_action_output.fill_if_subscribed(|| *action);
+
+        *context.last_motion_command = motion_command.clone();
+
+        Ok(MainOutputs {
+            motion_command: motion_command.into(),
+        })
+    }
+}

crates/world_state/src/behavior/walk_to_ball.rs

@@ -1,74 +1,40 @@
 use std::f32::consts::PI;
 
-use color_eyre::Result;
-use context_attribute::context;
 use coordinate_systems::Ground;
-use framework::MainOutput;
 use linear_algebra::{Rotation2, Vector2};
-use serde::{Deserialize, Serialize};
-use types::ball_position::BallPosition;
-use types::motion_command::{HeadMotion, ImageRegion, MotionCommand};
-use types::parameters::WalkWithVelocityParameters;
-
-#[derive(Deserialize, Serialize)]
-pub struct WalkToBall {}
-
-#[context]
-pub struct CreationContext {}
-
-#[context]
-pub struct CycleContext {
-    ball_position: Input<Option<BallPosition<Ground>>, "ball_position?">,
-
-    walk_with_velocity_parameter:
-        Parameter<WalkWithVelocityParameters, "behavior.walk_with_velocity">,
-}
-
-#[context]
-#[derive(Default)]
-pub struct MainOutputs {
-    pub motion_command: MainOutput<MotionCommand>,
-}
-
-impl WalkToBall {
-    pub fn new(_context: CreationContext) -> Result<Self> {
-        Ok(Self {})
-    }
-
-    pub fn cycle(&mut self, context: CycleContext) -> Result<MainOutputs> {
-        let next_motion_command = match context.ball_position {
-            Some(ball_position) => {
-                let ball_coordinates_in_ground = ball_position.position.coords();
-                let head = HeadMotion::LookAt {
-                    target: ball_position.position,
-                    image_region_target: ImageRegion::Center,
-                };
-                let max_angular_velocity_abs = context
-                    .walk_with_velocity_parameter
-                    .max_angular_velocity
-                    .abs();
-                let normalized_angle_to_ball =
-                    Rotation2::rotation_between(Vector2::x_axis(), ball_coordinates_in_ground)
-                        .angle()
-                        / (0.5 * PI);
-                MotionCommand::WalkWithVelocity {
-                    head,
-                    velocity: ball_coordinates_in_ground.normalize()
-                        * context.walk_with_velocity_parameter.max_velocity,
-                    angular_velocity: (normalized_angle_to_ball
-                        * context
-                            .walk_with_velocity_parameter
-                            .angular_velocity_scaling_factor)
-                        .clamp(-max_angular_velocity_abs, max_angular_velocity_abs),
-                }
+use types::{
+    ball_position::BallPosition,
+    motion_command::{HeadMotion, ImageRegion, MotionCommand},
+    parameters::WalkWithVelocityParameters,
+};
+
+pub fn execute(
+    ball_position: Option<BallPosition<Ground>>,
+    walk_with_velocity_parameter: WalkWithVelocityParameters,
+) -> Option<MotionCommand> {
+    let next_motion_command = match ball_position {
+        Some(ball_position) => {
+            let ball_coordinates_in_ground = ball_position.position.coords();
+            let head = HeadMotion::LookAt {
+                target: ball_position.position,
+                image_region_target: ImageRegion::Center,
+            };
+            let max_angular_velocity_abs = walk_with_velocity_parameter.max_angular_velocity.abs();
+            let normalized_angle_to_ball =
+                Rotation2::rotation_between(Vector2::x_axis(), ball_coordinates_in_ground).angle()
+                    / (0.5 * PI);
+            MotionCommand::WalkWithVelocity {
+                head,
+                velocity: ball_coordinates_in_ground.normalize()
+                    * walk_with_velocity_parameter.max_velocity,
+                angular_velocity: (normalized_angle_to_ball
+                    * walk_with_velocity_parameter.angular_velocity_scaling_factor)
+                    .clamp(-max_angular_velocity_abs, max_angular_velocity_abs),
             }
-            None => MotionCommand::Stand {
-                head: HeadMotion::Center,
-            },
-        };
-
-        Ok(MainOutputs {
-            motion_command: next_motion_command.into(),
-        })
-    }
+        }
+        None => MotionCommand::Stand {
+            head: HeadMotion::Center,
+        },
+    };
+    Some(next_motion_command)
 }