make paddles move

Author: juan-medina

config/bindings.ron

@@ -0,0 +1,7 @@
+(
+  axes: {
+    "left_paddle": Emulated(pos: Key(W), neg: Key(S)),
+    "right_paddle": Emulated(pos: Key(Up), neg: Key(Down)),
+  },
+  actions: {},
+)

src/main.rs

@@ -1,17 +1,17 @@
-//! Pong Tutorial 1
-
 use amethyst::{
+    core::transform::TransformBundle,
+    input::{InputBundle, StringBindings},
     prelude::*,
     renderer::{
         plugins::{RenderFlat2D, RenderToWindow},
         types::DefaultBackend,
         RenderingBundle,
     },
     utils::application_root_dir,
-    core::transform::TransformBundle,
 };
 
 mod pong;
+mod systems;
 
 use crate::pong::PongGame;
 
@@ -21,6 +21,10 @@ fn main() -> amethyst::Result<()> {
     let app_root = application_root_dir()?;
     let display_config_path = app_root.join("config").join("display.ron");
 
+    let binding_path = app_root.join("config").join("bindings.ron");
+    let input_bundle =
+        InputBundle::<StringBindings>::new().with_bindings_from_file(binding_path)?;
+
     let game_data = GameDataBuilder::default()
         .with_bundle(
             RenderingBundle::<DefaultBackend>::new()
@@ -34,7 +38,9 @@ fn main() -> amethyst::Result<()> {
                 .with_plugin(RenderFlat2D::default()),
         )?
         // Add the transform bundle which handles tracking entity positions
-        .with_bundle(TransformBundle::new())?;
+        .with_bundle(TransformBundle::new())?
+        .with_bundle(input_bundle)?
+        .with(systems::PaddleSystem, "paddle_system", &["input_system"]);
 
     let assets_dir = app_root.join("assets");
     let mut game = Application::new(assets_dir, PongGame, game_data)?;

src/pong.rs

@@ -1,5 +1,5 @@
 use amethyst::{
-    assets::{AssetStorage, Loader, Handle},
+    assets::{AssetStorage, Handle, Loader},
     core::transform::Transform,
     ecs::prelude::{Component, DenseVecStorage},
     prelude::*,
@@ -12,7 +12,7 @@ const IDENTITY: f32 = 1.0;
 const Z_FRONT: f32 = 0.0;
 
 const ARENA_WIDTH: f32 = 100.0;
-const ARENA_HEIGHT: f32 = 100.0;
+pub const ARENA_HEIGHT: f32 = 100.0;
 const HALVE_WIDTH: f32 = ARENA_WIDTH * 0.5;
 const HALVE_HEIGHT: f32 = ARENA_HEIGHT * 0.5;
 
@@ -135,8 +135,6 @@ impl SimpleState for PongGame {
         // Load the spritesheet necessary to render the graphics.
         let sprite_sheet_handle = load_sprite_sheet(world);
 
-        world.register::<Paddle>();
-
         initialise_paddles(world, sprite_sheet_handle);
         initialise_camera(world);
     }

src/systems/mod.rs

@@ -0,0 +1,3 @@
+pub use self::paddle::PaddleSystem;
+
+mod paddle;

src/systems/paddle.rs

@@ -0,0 +1,40 @@
+use amethyst::{
+    core::Transform,
+    derive::SystemDesc,
+    ecs::{Join, Read, ReadStorage, System, SystemData, WriteStorage},
+    input::{InputHandler, StringBindings},
+};
+
+// You'll have to mark PADDLE_HEIGHT as public in pong.rs
+use crate::pong::{Paddle, Side, ARENA_HEIGHT};
+
+#[derive(SystemDesc)]
+pub struct PaddleSystem;
+
+impl<'s> System<'s> for PaddleSystem {
+    type SystemData = (
+        WriteStorage<'s, Transform>,
+        ReadStorage<'s, Paddle>,
+        Read<'s, InputHandler<StringBindings>>,
+    );
+
+    fn run(&mut self, (mut transforms, paddles, input): Self::SystemData) {
+        for (paddle, transform) in (&paddles, &mut transforms).join() {
+            let movement = match paddle.side {
+                Side::Left => input.axis_value("left_paddle"),
+                Side::Right => input.axis_value("right_paddle"),
+            };
+            if let Some(mv_amount) = movement {
+                if mv_amount != 0.0 {
+                    let scaled_amount = 1.2 * mv_amount as f32;
+                    let paddle_y = transform.translation().y;
+                    transform.set_translation_y(
+                        (paddle_y + scaled_amount)
+                            .min(ARENA_HEIGHT - paddle.height * 0.5)
+                            .max(paddle.height * 0.5),
+                    );
+                }
+            }
+        }
+    }
+}