idk

src/user/bin/games/paper_rs/game.rs

@@ -0,0 +1,432 @@
+use core::any::Any;
+
+use alloc::{boxed::Box, format, string::String, vec::Vec};
+use async_trait::async_trait;
+
+use crate::{
+    std::{
+        self, 
+        application::{Application, Error}, 
+        io::{Color, ColorCode, Display, KeyStroke, Stdin}, 
+        render::{ColouredChar, Dimensions, Frame, Position, RenderError}, 
+        time
+    }, 
+    user::lib::libgui::cg_core::CgComponent
+};
+
+use super::player::Player;
+
+#[derive(Copy, Clone)]
+pub enum Cell {
+    Empty,
+    Solid(u8, bool),
+    Tail(u8, bool),
+    Head(u8, bool),
+}
+
+pub struct GameBoard {
+    board: [[Cell; 80]; 25],
+    players: [Player; 6],
+    max_territory: u32,  // Track maximum territory captured
+    current_territory: u32,  // Track current territory
+}
+
+#[async_trait]
+impl Application for GameBoard {
+    fn new() -> GameBoard {
+        GameBoard {
+            board: [[Cell::Empty; 80]; 25],
+            players: [
+                Player::new(0, (10, 10), false),
+                Player::new(1, (70, 10), true),
+                Player::new(2, (10, 15), true),
+                Player::new(3, (70, 15), true),
+                Player::new(4, (35, 5), true),
+                Player::new(5, (35, 20), true),
+            ],
+            max_territory: 0,
+            current_territory: 0,
+        }
+    }
+
+    async fn run(&mut self, _args: Vec<String>) -> Result<(), Error> {
+        let _display = Display::borrow();
+
+        'outer: loop {
+            // Set initial positions as solid territory
+            for player in &self.players {
+                let (x, y) = player.position;
+                self.board[y as usize][x as usize] = Cell::Head(player.id, true);
+            }
+    
+            let mut player_direction: (i32, i32) = (0, 0);
+    
+            // player controls player 1.
+            loop {
+                self.render().unwrap().write_to_screen().unwrap();
+                time::wait(0.1);
+    
+                // first get player input
+                if let Some(keystroke) = Stdin::try_keystroke() {
+                    match keystroke {
+                        KeyStroke::Up => player_direction = (0, -1),
+                        KeyStroke::Down => player_direction = (0, 1),
+                        KeyStroke::Left => player_direction = (-1, 0),
+                        KeyStroke::Right => player_direction = (1, 0),
+                        KeyStroke::Char('w') | KeyStroke::Char('W') => player_direction = (0, -1),
+                        KeyStroke::Char('s') | KeyStroke::Char('S') => player_direction = (0, 1),
+                        KeyStroke::Char('a') | KeyStroke::Char('A') => player_direction = (-1, 0),
+                        KeyStroke::Char('d') | KeyStroke::Char('D') => player_direction = (1, 0),
+                        KeyStroke::Char('`') => break 'outer,
+                        _ => {},
+                    }
+                }
+                
+                // perform movement commands
+                self.move_player(0, player_direction.0, player_direction.1);
+    
+                self.update_ai_players();
+    
+                self.run_fill_algorithm();
+    
+    
+                if !self.players[0].alive {
+                    self.render_end_screen().await.unwrap();
+                    break;
+                }
+            }
+    
+            // Wait for any key to exit
+            match Stdin::keystroke().await {
+                KeyStroke::Char('`') => break 'outer,
+                _ => self.reset(),
+            }
+        }
+        
+        Ok(())
+    }
+}
+
+
+impl CgComponent for GameBoard {
+    fn render(&self) -> Result<Frame, RenderError> {
+        let mut frame = Frame::new(Position::new(0, 0), Dimensions::new(80, 25))?;
+        
+        for i in 0..25 {
+            for j in 0..80 {
+
+                let character: char;
+                let pid: Option<u8>;
+
+                match self.board[i][j] {
+                    Cell::Empty => { character = ' '; pid = None; }
+                    Cell::Solid(p, _) => { character = '█'; pid = Some(p); }
+                    Cell::Tail(p, _) => { character = '▒'; pid = Some(p); }
+                    Cell::Head(p, _) => { character = '▓'; pid = Some(p); } 
+                }
+
+                let colour = if let Some(p) = pid {
+                    match p {
+                        0 => ColorCode::new(Color::Green, Color::Black),
+                        1 => ColorCode::new(Color::Blue, Color::Black),
+                        2 => ColorCode::new(Color::Red, Color::Black),
+                        3 => ColorCode::new(Color::Yellow, Color::Black),
+                        4 => ColorCode::new(Color::Magenta, Color::Black),
+                        _ => ColorCode::new(Color::Cyan, Color::Black),
+                    }
+                } else {
+                    ColorCode::new(Color::White, Color::Black)
+                };
+
+                frame[i][j] = ColouredChar {
+                    character,
+                    colour,
+                };
+            }
+        }
+
+        Ok(frame)
+    }
+    
+    fn as_any(&self) -> &dyn core::any::Any {
+        self as &dyn Any 
+    }
+}
+
+impl GameBoard {
+    const UP: (i32, i32) = (0, -1);
+    const DOWN: (i32, i32) = (0, 1);
+    const LEFT: (i32, i32) = (-1, 0);
+    const RIGHT: (i32, i32) = (1, 0);
+    const DIRS: [(i32, i32); 8] = [
+        Self::UP, Self::DOWN, Self::LEFT, Self::RIGHT,
+        (1, 1), (1, -1), (-1, 1), (-1, -1),
+    ];
+
+
+    fn reset(&mut self) {
+        self.board = [[Cell::Empty; 80]; 25];
+        self.players = [
+            Player::new(0, (10, 10), false),
+            Player::new(1, (70, 10), true),
+            Player::new(2, (10, 15), true),
+            Player::new(3, (70, 15), true),
+            Player::new(4, (35, 5), true),
+            Player::new(5, (35, 20), true),
+        ];
+
+        // Set initial positions as solid territory
+        for player in &self.players {
+            let (x, y) = player.position;
+            self.board[y as usize][x as usize] = Cell::Head(player.id, true);
+        }
+
+        self.max_territory = 0;
+        self.current_territory = 0;
+    }
+
+    fn respawn_ai_player(&mut self, player_id: u8) {
+        // Try up to 10 times to find a valid spawn position
+        for _ in 0..10 {
+            let x = std::random::Random::int(5, 75) as i32;
+            let y = std::random::Random::int(5, 20) as i32;
+            
+            // Check if position is empty or not in someone's territory
+            if let Cell::Empty = self.board[y as usize][x as usize] {
+                let dir_idx = std::random::Random::int(0, 3) as usize;
+                self.players[player_id as usize] = Player::new(player_id, (x, y), true);
+                // Place the head at spawn position
+                self.board[y as usize][x as usize] = Cell::Head(player_id, true);
+                return;
+            }
+        }
+        
+        // If we couldn't find a spot after 10 tries, just keep the player dead
+        self.players[player_id as usize].alive = false;
+    }
+
+    fn count_territory(&self) -> u32 {
+        let mut count = 0;
+        for row in &self.board {
+            for cell in row {
+                if let Cell::Solid(0, true) = cell {
+                    count += 1;
+                }
+            }
+        }
+        count
+    }
+
+    async fn render_end_screen(&mut self) -> Result<(), RenderError> {
+        let mut frame = self.render()?;
+        
+        // Game Over message
+        let game_over_text = "Game Over!";
+        let center_y = 12;
+        let center_x = 40 - (game_over_text.len() / 2) as u16;
+
+        // Draw the game over text
+        for (i, c) in game_over_text.chars().enumerate() {
+            let pos = center_x + i as u16;
+            frame[center_y][pos as usize] = ColouredChar {
+                character: c,
+                colour: ColorCode::new(Color::White, Color::Black),
+            };
+        }
+
+        // Show player's score
+        let score_text = format!("Score: {}", self.current_territory);
+        let score_x = 40 - (score_text.len() / 2) as u16;
+        for (i, c) in score_text.chars().enumerate() {
+            let pos = score_x + i as u16;
+            frame[center_y + 1][pos as usize] = ColouredChar {
+                character: c,
+                colour: ColorCode::new(Color::White, Color::Black),
+            };
+        }
+
+        // Show restart instruction
+        let restart_text = "Press any key to restart";
+        let restart_x = 40 - (restart_text.len() / 2) as u16;
+        for (i, c) in restart_text.chars().enumerate() {
+            let pos = restart_x + i as u16;
+            frame[center_y + 2][pos as usize] = ColouredChar {
+                character: c,
+                colour: ColorCode::new(Color::White, Color::Black),
+            };
+        }
+
+        frame.write_to_screen()?;
+
+        Ok(())
+    }
+
+    fn move_player(&mut self, playerid: u8, dx: i32, dy: i32) {
+        if let Some(eliminated_id) = self.players[playerid as usize].move_player(dx, dy, &mut self.board) {
+            self.players[eliminated_id as usize].alive = false;
+            // Clear territory and respawn if AI
+            if eliminated_id != 0 {
+                self.clear_player_territory(eliminated_id);
+                self.respawn_ai_player(eliminated_id);
+            } else {
+                // Update max territory before game over
+                self.current_territory = self.count_territory();
+                self.max_territory = self.max_territory.max(self.current_territory);
+            }
+        }
+    }
+
+    fn update_ai_players(&mut self) {
+        // Skip player 0 (human player)
+        for i in 1..6 {
+            let dir = self.players[i].update_ai(&self.board);
+            if dir != (0, 0) {
+                self.move_player(i as u8, dir.0, dir.1);
+            }
+        }
+    }
+
+    fn run_fill_algorithm(&mut self) {
+        // Pre-allocate a single reusable grid
+        let mut fill_grid = [[false; 80]; 25];
+        let mut queue = Vec::with_capacity(80 * 25);
+        
+        // Process for each alive player
+        for player in self.players.iter().filter(|p| p.alive) {
+            let pid = player.id;
+            
+            // Check if player's head is touching their territory
+            let (px, py) = player.position;
+            let mut head_touching_territory = false;
+            
+            // Check all adjacent cells to head
+            for (dy, dx) in Self::DIRS.iter().take(4) { // Only check cardinal directions
+                let ny = py + dy;
+                let nx = px + dx;
+                
+                if ny >= 0 && ny < 25 && nx >= 0 && nx < 80 {
+                    if let Cell::Solid(p, _) = self.board[ny as usize][nx as usize] {
+                        if p == pid {
+                            head_touching_territory = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            // Skip if head is not touching territory
+            if !head_touching_territory {
+                continue;
+            }
+            
+            // Reset grid
+            for row in fill_grid.iter_mut() {
+                row.fill(false);
+            }
+            
+            // Mark all player lines as walls but don't fill them yet
+            for y in 0..25 {
+                for x in 0..80 {
+                    if let Cell::Head(p, _) | Cell::Tail(p, _) | Cell::Solid(p, _) = self.board[y][x] {
+                        if p == pid {
+                            fill_grid[y][x] = true;
+                        }
+                    }
+                }
+            }
+            
+            // Clear queue for reuse
+            queue.clear();
+            
+            // Add edge cells to queue
+            for x in 0..80 {
+                if !fill_grid[0][x] {
+                    queue.push((0, x));
+                    fill_grid[0][x] = true;
+                }
+                if !fill_grid[24][x] {
+                    queue.push((24, x));
+                    fill_grid[24][x] = true;
+                }
+            }
+            for y in 1..24 {
+                if !fill_grid[y][0] {
+                    queue.push((y, 0));
+                    fill_grid[y][0] = true;
+                }
+                if !fill_grid[y][79] {
+                    queue.push((y, 79));
+                    fill_grid[y][79] = true;
+                }
+            }
+            
+            // Mark cells that are reachable from outside
+            while let Some((y, x)) = queue.pop() {
+                // Mark current cell as visited in the fill grid
+                fill_grid[y][x] = true;
+                
+                // Check all 8 directions
+                for (dy, dx) in Self::DIRS {
+                    let ny = (y as i32 + dy) as usize;
+                    let nx = (x as i32 + dx) as usize;
+                    
+                    if ny < 25 && nx < 80 && !fill_grid[ny][nx] {
+                        fill_grid[ny][nx] = true;
+                        queue.push((ny, nx));
+                    }
+                }
+            }
+            
+            // Check if we found any cells to fill
+            let mut found_territory = false;
+            'outer: for y in 0..25 {
+                for x in 0..80 {
+                    if !fill_grid[y][x] && matches!(self.board[y][x], Cell::Empty) {
+                        found_territory = true;
+                        break 'outer;
+                    }
+                }
+            }
+            
+            // Only convert tails if we actually filled some territory
+            if found_territory {
+                // First convert all tails to solid for this player
+                for y in 0..25 {
+                    for x in 0..80 {
+                        if let Cell::Tail(p, _) = self.board[y][x] {
+                            if p == pid {
+                                self.board[y][x] = Cell::Solid(pid, true);
+                            }
+                        }
+                        if let Cell::Head(p, _) = self.board[y][x] {
+                            if p == pid {
+                                self.board[y][x] = Cell::Head(pid, true);
+                            }
+                        }
+                    }
+                }
+            }
+            
+            // Convert all unreached cells to territory
+            for y in 0..25 {
+                for x in 0..80 {
+                    if !fill_grid[y][x] {
+                        self.board[y][x] = Cell::Solid(pid, true);
+                    }
+                }
+            }
+        }
+    }
+
+    fn clear_player_territory(&mut self, player_id: u8) {
+        for y in 0..25 {
+            for x in 0..80 {
+                if let Cell::Head(pid, _) | Cell::Tail(pid, _) | Cell::Solid(pid, _) = self.board[y][x] {
+                    if pid == player_id {
+                        self.board[y][x] = Cell::Empty;
+                    }
+                }
+            }
+        }
+    }
+}