Display test_data.log in workflow script

Added command to display contents of test_data.log

.github/workflows/dispatcher.yml

@@ -16,7 +16,6 @@ jobs:
       server: ${{ steps.check.outputs.server }}
       ui: ${{ steps.check.outputs.ui }}
     steps:
-      - uses: actions/checkout@v4
       - name: Determine which tests to run
         id: check
         run: |
@@ -91,3 +90,6 @@ jobs:
           cd "$GITHUB_WORKSPACE"
           git clean -fdx
           git reset --hard
+
+
+

.github/workflows/engine_test.yml

@@ -9,6 +9,8 @@ jobs:
     runs-on: self-hosted
 
     steps:
+      - uses: actions/checkout@v4
+
       - name: Run Engine tests
         run: |
           bash .github/workflows/test.sh engine/

.github/workflows/release.yml

@@ -101,3 +101,5 @@ jobs:
             release/windows.zip
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+

.github/workflows/server_test.yml

@@ -9,6 +9,8 @@ jobs:
     runs-on: self-hosted
 
     steps:
+      - uses: actions/checkout@v4
+
       - name: Run Server tests
         run: |
           bash .github/workflows/test.sh server/

.github/workflows/ui_test.yml

@@ -9,6 +9,8 @@ jobs:
     runs-on: self-hosted
 
     steps:
+      - uses: actions/checkout@v4
+
       - name: Run UI tests
         run: |
           bash .github/workflows/test.sh ui/

engine/src/bitboard.rs

@@ -1 +1,2 @@
-mod attackmaps;
+mod attackmaps;
+mod utils;

engine/src/bitboard/utils.rs

@@ -0,0 +1,99 @@
+#[inline(always)]
+pub fn pop_lsb(value: &mut u64) -> usize {
+  let idx = value.trailing_zeros() as usize;
+  *value &= !(1 << idx);
+  return idx;
+}
+
+#[inline(always)]
+pub fn pop_msb(value: &mut u64) -> usize {
+  let idx = 63 - value.leading_zeros() as usize;
+  *value &= !(1 << idx);
+  return idx;
+}
+
+const RANK_NUMBERS: [char; 8] = ['1', '2', '3', '4', '5', '6', '7', '8'];
+const FILE_LETTERS: [char; 8] = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
+pub fn notation_from_square_number(sq: u8) -> String {
+  let row = sq / 8;
+  let col = sq % 8;
+  let mut notation = String::new();
+
+  let row_not = RANK_NUMBERS[row as usize];
+  let col_not = FILE_LETTERS[col as usize];
+
+  notation.push(col_not);
+  notation.push(row_not);
+  return notation;
+}
+
+
+// <----- TESTS ----->
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn pop_lsb_test() {
+
+    // test setup
+    let test_values: [u64; 6] = [
+      0x8000_0000_0000_0000,
+      0x4E91_CF05_713E_451B,
+      0xD588_2D58_6962_34B0,
+      0x9581_3335_DCAB_1DD4,
+      0xBEAC_DBE0_903A_AC00,
+      0x01E8_C895_A6F0_0000
+    ];
+    let expected_values: [usize; 6] = [63, 0, 4, 2, 10, 20];
+
+    // tests
+    for index in 0..6 {
+      let mut test_value = test_values[index];
+      assert_eq!(pop_lsb(&mut test_value), expected_values[index])
+    }
+  }
+
+  #[test]
+  fn pop_msb_test() {
+    // test setup
+    let test_values: [u64; 6] = [
+      0x86D6_8EB0_96A8_8D1C,
+      0x0000_0000_0000_0001,
+      0x3809_24AF_A7AE_8129,
+      0x0277_DA36_3B31_86D9,
+      0x0000_C1C3_201C_0DB1,
+      0x0000_0203_0DE4_E944
+    ];
+    let expected_values: [usize; 6] = [63, 0, 61, 57, 47, 41];
+
+    // tests
+    for index in 0..6 {
+      let mut test_value = test_values[index];
+      assert_eq!(pop_msb(&mut test_value), expected_values[index])
+    }
+  }
+
+  #[test]
+  fn notation_from_square_number_test() {
+    // test setup
+    let square_indices: [u8; 8] = [1, 12, 22, 27, 32, 47, 53, 58];
+    let notations: [String; 8] = [
+      String::from("b1"),
+      String::from("e2"),
+      String::from("g3"),
+      String::from("d4"),
+      String::from("a5"),
+      String::from("h6"),
+      String::from("f7"),
+      String::from("c8")
+    ];
+
+    // tests
+    for index in 0..8 {
+      let notation = notation_from_square_number(square_indices[index].clone());
+      assert_eq!(notation, notations[index]);
+    }
+  }
+}

ui/Cargo.toml

@@ -4,7 +4,3 @@ 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,430 +1,3 @@
-use eframe::egui;
-
-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");
-    }
+fn main() {
+    println!("Hello, world!");
 }