Implement Pong game!

Signed-off-by: Daniel Schaefer <[email protected]>

Author: JohnAZoidberg

control.py

@@ -32,6 +32,14 @@
 WIDTH = 9
 HEIGHT = 34
 
+ARG_UP = 0
+ARG_DOWN = 1
+ARG_LEFT = 2
+ARG_RIGHT = 3
+ARG_QUIT = 4
+ARG_2LEFT = 5
+ARG_2RIGHT = 6
+
 SERIAL_DEV = None
 
 STOP_THREAD = False
@@ -82,6 +90,8 @@ def main():
     parser.add_argument("--snake", help="Snake", action="store_true")
     parser.add_argument("--snake-embedded",
                         help="Snake on the module", action="store_true")
+    parser.add_argument("--pong-embedded",
+                        help="Pong on the module", action="store_true")
     parser.add_argument(
         "--all-brightnesses", help="Show every pixel in a different brightness", action="store_true")
     parser.add_argument("-v", "--version",
@@ -145,6 +155,8 @@ def main():
         snake()
     elif args.snake_embedded:
         snake_embedded()
+    elif args.pong_embedded:
+        pong_embedded()
     elif args.eq is not None:
         eq(args.eq)
     elif args.random_eq:
@@ -444,6 +456,32 @@ def game_over():
         time.sleep(0.75)
 
 
+def pong_embedded():
+    # Start game
+    command = FWK_MAGIC + [0x10, 0x01]
+    send_command(command)
+
+    from getkey import getkey, keys
+
+    while True:
+        key_arg = None
+        key = getkey()
+        if key == keys.LEFT:
+            key_arg = ARG_LEFT
+        elif key == keys.RIGHT:
+            key_arg = ARG_RIGHT
+        elif key == 'a':
+            key_arg = ARG_2LEFT
+        elif key == 'd':
+            key_arg = ARG_2RIGHT
+        elif key == 'q':
+            # Quit
+            key_arg = ARG_QUIT
+        if key_arg is not None:
+            command = FWK_MAGIC + [0x11, key_arg]
+            send_command(command)
+
+
 def snake_embedded():
     # Start game
     command = FWK_MAGIC + [0x10, 0x00]

src/bin/ledmatrix.rs

@@ -100,7 +100,7 @@ use core::fmt::Write;
 use heapless::String;
 
 use lotus_input::control::*;
-use lotus_input::games::snake;
+use lotus_input::games::{pong, snake};
 use lotus_input::lotus::LotusLedMatrix;
 use lotus_input::matrix::*;
 use lotus_input::patterns::*;
@@ -303,23 +303,36 @@ fn main() -> ! {
         }
 
         // Handle game state
-        if timer.get_counter().ticks() > game_timer + 500_000 {
+        let game_step_diff = match state.game {
+            Some(GameState::Pong(ref pong_state)) => 100_000 - 5_000 * pong_state.speed,
+            Some(GameState::Snake(_)) => 500_000,
+            _ => 500_000,
+        };
+        if timer.get_counter().ticks() > game_timer + game_step_diff {
             let _ = serial.write(b"Game step\r\n");
-            if let Some(GameState::Snake(_)) = state.game {
-                let random = get_random_byte(&rosc);
-                let (direction, game_over, points, (x, y)) = snake::game_step(&mut state, random);
-
-                if game_over {
-                } else {
-                    let mut text: String<64> = String::new();
-                    write!(
-                        &mut text,
-                        "Dir: {:?} Status: {}, Points: {}, Head: ({},{})\r\n",
-                        direction, game_over, points, x, y
-                    )
-                    .unwrap();
-                    let _ = serial.write(text.as_bytes());
+            let random = get_random_byte(&rosc);
+            match state.game {
+                Some(GameState::Pong(_)) => {
+                    pong::game_step(&mut state, random);
+                }
+                Some(GameState::Snake(_)) => {
+                    let (direction, game_over, points, (x, y)) =
+                        snake::game_step(&mut state, random);
+
+                    if game_over {
+                        // TODO: Show score
+                    } else {
+                        let mut text: String<64> = String::new();
+                        write!(
+                            &mut text,
+                            "Dir: {:?} Status: {}, Points: {}, Head: ({},{})\r\n",
+                            direction, game_over, points, x, y
+                        )
+                        .unwrap();
+                        let _ = serial.write(text.as_bytes());
+                    }
                 }
+                None => {}
             }
             game_timer = timer.get_counter().ticks();
         }

src/control.rs

@@ -13,6 +13,8 @@ use embedded_graphics::{
 #[cfg(feature = "b1display")]
 use heapless::String;
 
+#[cfg(feature = "ledmatrix")]
+use crate::games::pong;
 #[cfg(feature = "ledmatrix")]
 use crate::games::snake;
 #[cfg(feature = "ledmatrix")]
@@ -51,6 +53,7 @@ pub enum PatternVals {
 
 pub enum Game {
     Snake,
+    Pong,
 }
 
 #[derive(Clone)]
@@ -60,6 +63,8 @@ pub enum GameControlArg {
     Left,
     Right,
     Exit,
+    SecondLeft,
+    SecondRight,
 }
 
 // TODO: Reduce size for modules that don't require other commands
@@ -182,6 +187,7 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
             0x08 => Some(Command::DrawGreyColBuffer),
             0x10 => match arg {
                 Some(0) => Some(Command::StartGame(Game::Snake)),
+                Some(1) => Some(Command::StartGame(Game::Pong)),
                 _ => None,
             },
             0x11 => match arg {
@@ -190,6 +196,8 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
                 Some(2) => Some(Command::GameControl(GameControlArg::Left)),
                 Some(3) => Some(Command::GameControl(GameControlArg::Right)),
                 Some(4) => Some(Command::GameControl(GameControlArg::Exit)),
+                Some(5) => Some(Command::GameControl(GameControlArg::SecondLeft)),
+                Some(6) => Some(Command::GameControl(GameControlArg::SecondRight)),
                 _ => None,
             },
             0x12 => Some(Command::GameStatus),
@@ -340,12 +348,14 @@ pub fn handle_command(
         Command::StartGame(game) => {
             match game {
                 Game::Snake => snake::start_game(state, random),
+                Game::Pong => pong::start_game(state, random),
             }
             None
         }
         Command::GameControl(arg) => {
             match state.game {
                 Some(GameState::Snake(_)) => snake::handle_control(state, arg),
+                Some(GameState::Pong(_)) => pong::handle_control(state, arg),
                 _ => {}
             }
             None

src/games/mod.rs

@@ -1 +1,2 @@
+pub mod pong;
 pub mod snake;

src/games/pong.rs

@@ -0,0 +1,164 @@
+use crate::control::GameControlArg;
+use crate::matrix::{GameState, Grid, State, HEIGHT, LEDS, WIDTH};
+
+use heapless::Vec;
+
+const PADDLE_WIDTH: usize = 5;
+
+#[derive(Clone)]
+struct Score {
+    upper: u8,
+    lower: u8,
+}
+
+type Position = (usize, usize);
+type Velocity = (i8, i8);
+
+#[derive(Clone)]
+struct Ball {
+    pos: Position,
+    // Not a position, more like a directional vector
+    direction: Velocity,
+}
+
+#[derive(Clone)]
+pub struct PongState {
+    score: Score,
+    ball: Ball,
+    paddles: (usize, usize),
+    pub speed: u64,
+}
+
+pub fn start_game(state: &mut State, random: u8) {
+    state.game = Some(GameState::Pong(PongState {
+        score: Score { upper: 0, lower: 0 },
+        ball: Ball {
+            pos: (4, 20),
+            direction: (0, 1),
+        },
+        paddles: (PADDLE_WIDTH / 2, PADDLE_WIDTH / 2),
+        speed: 0,
+    }))
+}
+pub fn handle_control(state: &mut State, arg: &GameControlArg) {
+    if let Some(GameState::Pong(ref mut pong_state)) = state.game {
+        match arg {
+            GameControlArg::Left => {
+                if pong_state.paddles.0 + PADDLE_WIDTH < WIDTH {
+                    pong_state.paddles.0 += 1;
+                }
+            }
+            GameControlArg::Right => {
+                if pong_state.paddles.0 >= 1 {
+                    pong_state.paddles.0 -= 1;
+                }
+            }
+            GameControlArg::SecondLeft => {
+                if pong_state.paddles.1 + PADDLE_WIDTH < WIDTH {
+                    pong_state.paddles.1 += 1;
+                }
+            }
+            GameControlArg::SecondRight => {
+                if pong_state.paddles.1 >= 1 {
+                    pong_state.paddles.1 -= 1;
+                }
+            }
+            //GameControlArg::Exit => {
+            _ => {
+                // TODO
+            }
+        }
+    }
+}
+
+fn random_v(random: u8) -> Velocity {
+    // TODO: while food == head:
+    let x = ((random & 0xF0) >> 4) % WIDTH as u8;
+    let y = (random & 0x0F) % HEIGHT as u8;
+    (x as i8, y as i8)
+}
+
+fn add_velocity(pos: Position, v: Velocity) -> Position {
+    let (vx, vy) = v;
+    let (x, y) = pos;
+    (((x as i8) + vx) as usize, ((y as i8) + vy) as usize)
+}
+
+fn hit_paddle(ball: Position, paddles: (usize, usize)) -> Option<usize> {
+    let (x, y) = ball;
+    if y == 1 && paddles.0 <= x && x <= paddles.0 + PADDLE_WIDTH {
+        Some((((paddles.0) as i32) - (x as i32)).abs() as usize)
+    } else if y == HEIGHT - 2 && paddles.1 <= x && x <= paddles.1 + PADDLE_WIDTH {
+        Some((((paddles.1) as i32) - (x as i32)).abs() as usize)
+    } else {
+        None
+    }
+}
+
+pub fn game_step(state: &mut State, random: u8) {
+    if let Some(GameState::Pong(ref mut pong_state)) = state.game {
+        pong_state.ball.pos = {
+            let (vx, vy) = pong_state.ball.direction;
+            let (x, y) = pong_state.ball.pos;
+            let (x, y) = add_velocity(pong_state.ball.pos, pong_state.ball.direction);
+            let x = if x < 0 {
+                0
+            } else if x > WIDTH - 1 {
+                WIDTH - 1
+            } else {
+                x
+            };
+            if x == 0 || x == WIDTH - 1 {
+                // Hit wall, bounce back
+                pong_state.ball.direction = (-vx, vy);
+            }
+
+            let y = if y < 0 {
+                0
+            } else if y > HEIGHT - 1 {
+                HEIGHT - 1
+            } else {
+                y
+            };
+            let (x, y) = if let Some(paddle_hit) = hit_paddle((x, y), pong_state.paddles) {
+                // Hit paddle, bounce back
+                // TODO: Change vy direction slightly depending on where the paddle was hit
+                let (vx, vy) = pong_state.ball.direction;
+                pong_state.ball.direction = match paddle_hit {
+                    0 => (vx - 2, -vy),
+                    1 => (vx - 1, -vy),
+                    2 => (vx, -vy),
+                    3 => (vx + 1, -vy),
+                    4 => (vx + 2, -vy),
+                    // Shouldn't occur
+                    _ => (vx, -vy),
+                };
+                // TODO: Not sure if I want the speed to change. Speed by angle change is already high enough
+                //pong_state.speed += 1;
+                (x, y)
+            } else if y == 0 || y == HEIGHT - 1 {
+                pong_state.speed = 0;
+                pong_state.ball.direction = (1, 1); //random_v(random);
+                (WIDTH / 2, HEIGHT / 2)
+            } else {
+                (x, y)
+            };
+            (x, y)
+        };
+        state.grid = draw_matrix(&pong_state);
+    }
+}
+
+fn draw_matrix(state: &PongState) -> Grid {
+    let mut grid = Grid::default();
+
+    for x in state.paddles.0..state.paddles.0 + PADDLE_WIDTH {
+        grid.0[x][0] = 0xFF;
+    }
+    for x in state.paddles.1..state.paddles.1 + PADDLE_WIDTH {
+        grid.0[x][HEIGHT - 1] = 0xFF;
+    }
+    grid.0[state.ball.pos.0 as usize][state.ball.pos.1 as usize] = 0xFF;
+
+    grid
+}

src/matrix.rs

@@ -1,3 +1,4 @@
+use crate::games::pong::PongState;
 use crate::games::snake::SnakeState;
 
 pub const WIDTH: usize = 9;
@@ -31,4 +32,5 @@ pub enum SleepState {
 #[derive(Clone)]
 pub enum GameState {
     Snake(SnakeState),
+    Pong(PongState),
 }