Created a new branch due to a bug

Previous pull request didn't work (didnt change ui/src/main.rs), created new branch to see if the problem persists

engine/src/bitboard.rs

@@ -1,3 +1,7 @@
 mod attackmaps;
 mod utils;
+mod legality;
+mod checkinfo;
+mod attacks;
+
 pub mod board;

engine/src/bitboard/attacks.rs

@@ -0,0 +1,89 @@
+use super::board::Board;
+use super::attackmaps::*;
+
+impl Board {
+
+  const RANK_2: u64 = 0x0000_0000_0000_FF00;
+  const RANK_7: u64 = 0x00FF_0000_0000_0000;
+
+  pub fn get_pseudo_pawn_moves(&self, sq: u32) -> u64 {
+    let pawn: u64 = 1 << sq;
+    let mut move_mask: u64 = 0u64;
+    let move_offset: i8 = 8 - 16 * self.side_to_move as i8;
+
+    let next_sq: u64 = if move_offset > 0 {pawn << move_offset} else {pawn >> -move_offset};
+    if (self.occupancy[2] & next_sq) == 0 {
+      move_mask |= next_sq;
+
+      if (self.side_to_move == 0 && pawn & Self::RANK_2 != 0)
+        || (self.side_to_move == 1 && pawn & Self::RANK_7 != 0) {
+
+        let next_sq: u64 = if move_offset > 0 {next_sq << move_offset} else {next_sq >> -move_offset};
+        if (self.occupancy[2] & next_sq) == 0 {
+          move_mask |= next_sq;
+        }
+      }
+    }
+
+    return move_mask;
+  }
+  #[inline]
+  pub fn get_pseudo_knight_moves(&self, sq: u32) -> u64 {
+    return KNIGHT_ATTACK_MAP[sq as usize];
+  }
+  #[inline]
+  pub fn get_pseudo_king_moves(&self, sq: u32) -> u64 {
+    return KING_ATTACK_MAP[sq as usize];
+  }
+  #[inline]
+  pub fn get_pseudo_pawn_captures(&self, sq: u32) -> u64 {
+    return PAWN_ATTACK_MAP[sq as usize][self.side_to_move as usize];
+  }
+  #[inline]
+  pub fn get_pseudo_opponent_pawn_captures(&self, sq: u32) -> u64 {
+    return PAWN_ATTACK_MAP[sq as usize][1 - self.side_to_move as usize];
+  }
+  #[inline]
+  pub fn get_pseudo_bishop_moves(&self, sq: u32) -> u64 {
+    let mut  moves = 0u64;
+    let sq  = sq as usize;
+    let occupancy = self.occupancy[2];
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 1);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 3);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 5);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 7);
+
+    return moves;
+  }
+  #[inline]
+  pub fn get_pseudo_rook_moves(&self, sq: u32) -> u64 {
+    let mut moves: u64 = 0u64;
+    let occupancy = self.occupancy[2];
+    let sq = sq as usize;
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 0);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 2);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 4);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 6);
+
+    return moves;
+  }
+  #[inline(always)]
+  pub fn get_pseudo_queen_moves(&self, sq: u32) -> u64 {
+    return self.get_pseudo_bishop_moves(sq) | self.get_pseudo_rook_moves(sq);
+  }
+}
+
+#[inline(always)]
+pub fn get_raycast_from_square_in_direction(occupancy: u64, sq: usize, dir: usize) -> u64 {
+  let is_up: bool = dir / 4 == 0;
+  let mut ray: u64 = RAY_TABLE[sq][dir];
+  let blockers: u64 = occupancy & ray;
+
+  if blockers != 0 {
+    let first_blocker: u32 = if is_up { blockers.trailing_zeros() } else { 63 - blockers.leading_zeros() };
+
+    ray &= !RAY_TABLE[first_blocker as usize][dir];
+  }
+
+  return ray;
+}

engine/src/bitboard/board.rs

@@ -115,7 +115,7 @@ impl Board {
           }
        }
     }
-    // board.calc_pinned_squares();
+    board.calc_pinned_squares();
     board.calc_piece_board();
 
     return board;

engine/src/bitboard/checkinfo.rs

@@ -0,0 +1,21 @@
+
+pub struct CheckInfo {
+  pub check_count: u8,
+  pub move_mask: u64
+}
+
+impl CheckInfo {
+
+  pub fn new() -> Self {
+    return Self {
+      check_count: 0,
+      move_mask: 0xFFFF_FFFF_FFFF_FFFF
+    }
+  }
+
+  #[inline(always)]
+  pub fn add_checker(&mut self, move_mask: u64) {
+    self.move_mask &= move_mask;
+    self.check_count += 1;
+  }
+}

engine/src/bitboard/legality.rs

@@ -0,0 +1,48 @@
+use super::board::Board;
+use super::attackmaps::RAY_TABLE;
+
+impl Board {
+
+  pub(in super) fn calc_pinned_squares(&mut self) {
+    self.pinned_squares = [4; 64];
+    self.pin_mask = 0u64;
+
+    let friendly_pieces: u64 = self.occupancy[self.side_to_move as usize];
+    let offset: usize = 6 * self.side_to_move as usize;
+    let king_board: u64 = self.bitboards[5 + offset];
+    let king_sq: u32 = king_board.trailing_zeros();
+    let opponent_queen_bishop_mask: u64 = self.bitboards[8 - offset] | self.bitboards[10 - offset];
+    let opponent_queen_rook_mask: u64 = self.bitboards[9 - offset] | self.bitboards[10 - offset];
+
+    // Queen-Rook directions
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 0);
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 2);
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 4);
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_rook_mask, 6);
+
+    // Queen-Bishop directions
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 1);
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 3);
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 5);
+    self.set_pinned_in_ray_direction(king_sq, friendly_pieces, opponent_queen_bishop_mask, 7);
+  }
+
+  pub(in super) fn set_pinned_in_ray_direction(&mut self, king_sq: u32, friendly_pieces: u64, attackers: u64, dir: u8) {
+    let is_up: bool = dir / 4 == 0;
+    let mask: u64 = RAY_TABLE[king_sq as usize][dir as usize];
+    let blockers: u64 = self.occupancy[2] & mask;
+    if blockers == 0 { return; }
+    let first_blocker_sq: u32 = if is_up { blockers.trailing_zeros() } else { 63 - blockers.leading_zeros() };
+    if (friendly_pieces & 1 << first_blocker_sq) != 0 {
+      let blockers: u64 = blockers & !(1 << first_blocker_sq);
+      if blockers == 0 { return; }
+      let second_blocker_sq: u32 = if is_up { blockers.trailing_zeros() } else { 63 - blockers.leading_zeros() };
+
+      if (attackers & 1 << second_blocker_sq) != 0 {
+        self.pinned_squares[first_blocker_sq as usize] = dir % 4;
+        self.pin_mask |= 1 << first_blocker_sq;
+      }
+    }
+  }
+
+}

ui/Cargo.toml

@@ -4,3 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+eframe = "0.33.0"
+egui = "0.33.0"
+tokio-tungstenite = "0.28.0"
+winit = "0.30.12"

ui/src/main.rs

@@ -1,3 +1,430 @@
-fn main() {
+use eframe::egui;
-    println!("Hello, world!");
+
+fn main() -> eframe::Result<()> {
+    let options = eframe::NativeOptions{
+        viewport: egui::ViewportBuilder::default()
+            .with_fullscreen(false)
+            .with_min_inner_size(egui::vec2(800.0, 600.0)) // Minimum width, height
+            .with_inner_size(egui::vec2(7680.0, 4320.0)), // Initial size
+        ..Default::default()
+    };
+    eframe::run_native(
+    "Knightly",
+    options,
+    Box::new(|cc| {
+        let mut fonts = egui::FontDefinitions::default();
+        fonts.font_data.insert(
+            "symbols".to_owned(),
+            egui::FontData::from_static(include_bytes!("../fonts/DejaVuSans.ttf")).into(),
+        );
+        fonts
+            .families
+            .entry(egui::FontFamily::Proportional)
+            .or_default()
+            .insert(0, "symbols".to_owned());
+        cc.egui_ctx.set_fonts(fonts);
+        Ok(Box::new(ChessApp::default()))
+    }),
+)
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+enum Piece {
+    King(char),
+    Queen(char),
+    Rook(char),
+    Bishop(char),
+    Knight(char),
+    Pawn(char),
+    Empty,
+}
+
+impl Piece {
+    fn symbol(&self) -> &'static str {
+        match self {
+            Piece::King('w') => "♔",
+            Piece::Queen('w') => "♕",
+            Piece::Rook('w') => "♖",
+            Piece::Bishop('w') => "♗",
+            Piece::Knight('w') => "♘",
+            Piece::Pawn('w') => "♙",
+            Piece::King('b') => "♚",
+            Piece::Queen('b') => "♛",
+            Piece::Rook('b') => "♜",
+            Piece::Bishop('b') => "♝",
+            Piece::Knight('b') => "♞",
+            Piece::Pawn('b') => "♟︎",
+            Piece::Empty => "",
+            _ => "",
+        }
+    }
+}
+
+#[derive(PartialEq, Debug)]
+enum Turn {
+    White,
+    Black,
+}
+
+enum AppState {
+    MainMenu,
+    InGame,
+    Settings,
+}
+
+struct ChessApp {
+    fullscreen: bool,
+    resolutions: Vec<(u32, u32)>,
+    selected_resolution: usize,
+    state: AppState,
+    board: [[Piece; 8]; 8],
+    selected: Option<(usize, usize)>,
+    turn: Turn,
+    pending_settings: PendingSettings,
+    server_port: String,
+}
+
+#[derive(Default)]
+struct PendingSettings {
+    fullscreen: bool,
+    selected_resolution: usize,
+    server_port: String,
+}
+
+impl Default for ChessApp {
+    fn default() -> Self {
+        Self {
+            fullscreen: true,
+            resolutions: vec![
+                (1280, 720),
+                (1600, 900),
+                (1920, 1080),
+                (2560, 1440),
+                (3840, 2160),
+            ],
+            selected_resolution: 2, // Default to 1920x1080
+            state: AppState::MainMenu,
+            board: Self::starting_board(),
+            selected: None,
+            turn: Turn::White,
+            pending_settings: PendingSettings::default(),
+            server_port: "8080".to_string(), // Default port
+        }
+    }
+}
+
+impl ChessApp {
+    fn starting_board() -> [[Piece; 8]; 8] {
+        use Piece::*;
+        [
+            [
+                Rook('b'),
+                Knight('b'),
+                Bishop('b'),
+                Queen('b'),
+                King('b'),
+                Bishop('b'),
+                Knight('b'),
+                Rook('b'),
+            ],
+            [Pawn('b'); 8],
+            [Empty; 8],
+            [Empty; 8],
+            [Empty; 8],
+            [Empty; 8],
+            [Pawn('w'); 8],
+            [
+                Rook('w'),
+                Knight('w'),
+                Bishop('w'),
+                Queen('w'),
+                King('w'),
+                Bishop('w'),
+                Knight('w'),
+                Rook('w'),
+            ],
+        ]
+    }
+
+    fn handle_click(&mut self, row: usize, col: usize) {
+        if let Some((r, c)) = self.selected {
+            let piece = self.board[r][c];
+            self.board[r][c] = Piece::Empty;
+            self.board[row][col] = piece;
+            self.selected = None;
+            self.turn = if self.turn == Turn::White {
+                Turn::Black
+            } else {
+                Turn::White
+            };
+        } else {
+            if self.board[row][col] != Piece::Empty {
+                self.selected = Some((row, col));
+            }
+        }
+    }
+
+    fn apply_settings(&mut self, ctx: &egui::Context) {
+        self.fullscreen = self.pending_settings.fullscreen;
+        self.selected_resolution = self.pending_settings.selected_resolution;
+        self.server_port = self.pending_settings.server_port.clone();
+        
+        if let Some(resolution) = self.resolutions.get(self.selected_resolution) {
+            ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(
+                egui::Vec2::new(resolution.0 as f32, resolution.1 as f32)
+            ));
+        }
+        
+        ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(self.fullscreen));
+    }
+
+    fn enter_settings(&mut self) {
+        self.pending_settings.fullscreen = self.fullscreen;
+        self.pending_settings.selected_resolution = self.selected_resolution;
+        self.pending_settings.server_port = self.server_port.clone();
+        self.state = AppState::Settings;
+    }
+}
+
+impl eframe::App for ChessApp {
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        match self.state {
+            AppState::MainMenu => {
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    ui.vertical_centered(|ui| {
+                        ui.heading("♞ Knightly ♞");
+                        ui.add_space(30.0);
+
+                        if ui.add_sized([300.0, 60.0], egui::Button::new("Play")).clicked() {
+                            self.state = AppState::InGame;
+                        }
+                        ui.add_space(8.0);
+                        
+                        if ui.add_sized([300.0, 60.0], egui::Button::new("Settings")).clicked() {
+                            self.enter_settings();
+                        }
+                        ui.add_space(8.0);
+                        
+                        if ui
+                            .add_sized([300.0, 60.0], egui::Button::new("Quit"))
+                            .clicked()
+                        {
+                            std::process::exit(0);
+                        }
+                    });
+                });
+            }
+
+            AppState::Settings => {
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    ui.vertical_centered(|ui| {
+                        ui.heading("Settings");
+                        ui.add_space(30.0);
+
+                        // Fullscreen toggle
+                        ui.horizontal(|ui| {
+                            ui.label("Fullscreen:");
+                            if ui.checkbox(&mut self.pending_settings.fullscreen, "").changed() {
+                                // If enabling fullscreen, we might want to disable resolution selection
+                            }
+                        });
+                        ui.add_space(10.0);
+
+                        // Resolution dropdown
+                        ui.horizontal(|ui| {
+                            ui.label("Resolution:");
+                            egui::ComboBox::new("resolution_combo", "")
+                                .selected_text(format!(
+                                    "{}x{}",
+                                    self.resolutions[self.pending_settings.selected_resolution].0,
+                                    self.resolutions[self.pending_settings.selected_resolution].1
+                                ))
+                                .show_ui(ui, |ui| {
+                                    for (i, &(width, height)) in self.resolutions.iter().enumerate() {
+                                        ui.selectable_value(
+                                            &mut self.pending_settings.selected_resolution,
+                                            i,
+                                            format!("{}x{}", width, height),
+                                        );
+                                    }
+                                });
+                        });
+                        ui.add_space(10.0);
+
+                        // Server port input field
+                        ui.horizontal(|ui| {
+                            ui.label("Local Server Port:");
+                            ui.add(egui::TextEdit::singleline(&mut self.pending_settings.server_port)
+                                .desired_width(100.0)
+                                .hint_text("8080"));
+                        });
+                        ui.add_space(30.0);
+
+                        // Apply and Cancel buttons
+                        ui.horizontal(|ui| {
+                            if ui.add_sized([140.0, 40.0], egui::Button::new("Apply")).clicked() {
+                                self.apply_settings(ctx);
+                                self.state = AppState::MainMenu;
+                            }
+                            
+                            if ui.add_sized([140.0, 40.0], egui::Button::new("Cancel")).clicked() {
+                                self.state = AppState::MainMenu;
+                            }
+                        });
+                    });
+                });
+            }
+
+            AppState::InGame => {
+                egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
+                    ui.horizontal(|ui| {
+                        if ui.button("Main Menu").clicked() {
+                            self.state = AppState::MainMenu;
+                        }
+                        if ui.button("Settings").clicked() {
+                            self.enter_settings();
+                        }
+                        if ui.button("New Game").clicked() {
+                            *self = ChessApp::default();
+                            self.state = AppState::InGame;
+                        }
+                        ui.separator();
+                        ui.label(format!("Turn: {:?}", self.turn));
+                    });
+                });
+                
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    ui.vertical_centered(|ui| {
+                        let full_avail = ui.available_rect_before_wrap();
+                        let board_tile = (full_avail.width().min(full_avail.height())) / 8.0;
+                        let board_size = board_tile * 8.0;
+                        
+                        // Create a child UI at the board position
+                        let (response, painter) = ui.allocate_painter(
+                            egui::Vec2::new(board_size, board_size),
+                            egui::Sense::click()
+                        );
+                        
+                        let board_rect = egui::Rect::from_center_size(
+                            full_avail.center(),
+                            egui::vec2(board_size, board_size)
+                        );
+                        
+                        // Draw the chess board
+                        let tile_size = board_size / 8.0;
+                        for row in 0..8 {
+                            for col in 0..8 {
+                                let color = if (row + col) % 2 == 0 {
+                                    egui::Color32::from_rgb(100, 97, 97)
+                                } else {
+                                    egui::Color32::from_rgb(217, 217, 217)
+                                };
+                                
+                                let rect = egui::Rect::from_min_size(
+                                    egui::Pos2::new(
+                                        board_rect.min.x + col as f32 * tile_size,
+                                        board_rect.min.y + row as f32 * tile_size
+                                    ),
+                                    egui::Vec2::new(tile_size, tile_size)
+                                );
+                                
+                                painter.rect_filled(rect, 0.0, color);
+                                
+                                // Draw piece
+                                let piece = self.board[row][col];
+                                if piece != Piece::Empty {
+                                    let symbol = piece.symbol();
+                                    let font_id = egui::FontId::proportional(tile_size * 0.75);
+                                    painter.text(
+                                        rect.center(),
+                                        egui::Align2::CENTER_CENTER,
+                                        symbol,
+                                        font_id,
+                                        if matches!(piece, Piece::King('w') | Piece::Queen('w') | Piece::Rook('w') | Piece::Bishop('w') | Piece::Knight('w') | Piece::Pawn('w')) {
+                                            egui::Color32::WHITE
+                                        } else {
+                                            egui::Color32::BLACK
+                                        }
+                                    );
+                                }
+                                
+                                // Draw selection highlight
+                                if self.selected == Some((row, col)) {
+                                    painter.rect_stroke(
+                                        rect, 
+                                        0.0, 
+                                        egui::Stroke::new(3.0, egui::Color32::RED),
+                                        egui::StrokeKind::Inside
+                                    );
+                                }
+                                
+                                // Handle clicks
+                                if ui.ctx().input(|i| i.pointer.primary_clicked()) {
+                                    let click_pos = ui.ctx().input(|i| i.pointer.interact_pos()).unwrap();
+                                    if rect.contains(click_pos) {
+                                        self.handle_click(row, col);
+                                    }
+                                }
+                            }
+                        }
+                    });
+                });
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_initial_board_setup() {
+        let app = ChessApp::default();
+        assert!(matches!(app.board[0][0], Piece::Rook('b')));
+        assert!(matches!(app.board[7][0], Piece::Rook('w')));
+
+        assert!(matches!(app.board[1][0], Piece::Pawn('b')));
+        assert!(matches!(app.board[6][0], Piece::Pawn('w')));
+    }
+    
+    #[test]
+    fn test_piece_symbols() {
+        assert_eq!(Piece::King('w').symbol(), "♔");
+        assert_eq!(Piece::King('b').symbol(), "♚");
+        assert_eq!(Piece::Empty.symbol(), "");
+    }
+    
+    #[test]
+    fn test_piece_selection() {
+        let mut app = ChessApp::default();
+        app.handle_click(6, 0);
+        assert_eq!(app.selected, Some((6, 0)));
+        app.handle_click(6, 0);
+        assert_eq!(app.selected, None);
+    }
+    
+    #[test]
+    fn test_piece_movement() {
+        let mut app = ChessApp::default();
+        // Select and move a piece
+        app.handle_click(6, 0); // Select white pawn
+        app.handle_click(5, 0); // Move to empty square
+        assert_eq!(app.board[6][0], Piece::Empty);
+        assert!(matches!(app.board[5][0], Piece::Pawn('w')));
+    }
+
+    #[test]
+    fn test_turn_switching() {
+        let mut app = ChessApp::default();
+        assert_eq!(app.turn, Turn::White);
+        app.handle_click(6, 0); // White selects
+        app.handle_click(5, 0); // White moves
+        assert_eq!(app.turn, Turn::Black); // Should now be Black's turn
+    }
+    
+    #[test]
+    fn test_server_port_default() {
+        let app = ChessApp::default();
+        assert_eq!(app.server_port, "8080");
+    }
 }