Reinitialize repository and add working move generation for all pieces

tests/move_to_algebraic_conversion.rs

@@ -0,0 +1,92 @@
+use chess_engine::r#move::*;
+use chess_engine::square::Square;
+
+#[test]
+fn test_quiet_move_white_pawn() {
+    // Test 1: Standard Quiet Move (White Pawn)
+    // (from: E2, to: E4)
+    // NOTE: This was MOVE_TYPE_FLAG_QUIET, but in the new system it's a specific flag.
+    // The algebraic notation is the same, so we test with the new specific flag.
+    let m_quiet = Move::new(Square::E2, Square::E4, MOVE_FLAG_QUIET);
+    assert_eq!(m_quiet.to_algebraic(), "e2e4");
+}
+
+#[test]
+fn test_quiet_move_black_knight() {
+    // Test 2: Standard Quiet Move (Black Knight)
+    // (from: B8, to: C6)
+    let m_knight = Move::new(Square::B8, Square::C6, MOVE_FLAG_QUIET);
+    assert_eq!(m_knight.to_algebraic(), "b8c6");
+}
+
+#[test]
+fn test_en_passant_move() {
+    // Test 3: En Passant Move (Notation is same as quiet move)
+    // (from: E5, to: F6)
+    let m_ep = Move::new(Square::E5, Square::F6, MOVE_FLAG_EN_PASSANT);
+    assert_eq!(m_ep.to_algebraic(), "e5f6");
+}
+
+#[test]
+fn test_promotion_to_queen() {
+    // Test 4: Promotion to Queen (Push)
+    // (from: E7, to: E8)
+    let m_promo_q = Move::new(Square::E7, Square::E8, MOVE_FLAG_PROMO_Q);
+    assert_eq!(m_promo_q.to_algebraic(), "e7e8q");
+}
+
+#[test]
+fn test_promotion_to_rook() {
+    // Test 5: Promotion to Rook (Push)
+    // (from: A7, to: A8)
+    let m_promo_r = Move::new(Square::A7, Square::A8, MOVE_FLAG_PROMO_R);
+    assert_eq!(m_promo_r.to_algebraic(), "a7a8r");
+}
+
+#[test]
+fn test_promotion_to_bishop() {
+    // Test 6: Promotion to Bishop (Capture)
+    // (from: G2, to: H1)
+    let m_promo_b = Move::new(Square::G2, Square::H1, MOVE_FLAG_PROMO_CAP_B);
+    assert_eq!(m_promo_b.to_algebraic(), "g2h1b");
+}
+
+#[test]
+fn test_promotion_to_knight() {
+    // Test 7: Promotion to Knight (Capture)
+    // (from: G7, to: F8)
+    let m_promo_n = Move::new(Square::G7, Square::F8, MOVE_FLAG_PROMO_CAP_N);
+    assert_eq!(m_promo_n.to_algebraic(), "g7f8n");
+}
+
+#[test]
+fn test_white_kingside_castling() {
+    // Test 8: White Kingside Castling
+    // (from: E1, to: G1)
+    let m_castle_wk = Move::new(Square::E1, Square::G1, MOVE_FLAG_WK_CASTLE);
+    assert_eq!(m_castle_wk.to_algebraic(), "O-O");
+}
+
+#[test]
+fn test_white_queenside_castling() {
+    // Test 9: White Queenside Castling
+    // (from: E1, to: C1)
+    let m_castle_wq = Move::new(Square::E1, Square::C1, MOVE_FLAG_WQ_CASTLE);
+    assert_eq!(m_castle_wq.to_algebraic(), "O-O-O");
+}
+
+#[test]
+fn test_black_kingside_castling() {
+    // Test 10: Black Kingside Castling
+    // (from: E8, to: G8)
+    let m_castle_bk = Move::new(Square::E8, Square::G8, MOVE_FLAG_BK_CASTLE);
+    assert_eq!(m_castle_bk.to_algebraic(), "O-O");
+}
+
+#[test]
+fn test_black_queenside_castling() {
+    // Test 11: Black Queenside Castling
+    // (from: E8, to: C8)
+    let m_castle_bq = Move::new(Square::E8, Square::C8, MOVE_FLAG_BQ_CASTLE);
+    assert_eq!(m_castle_bq.to_algebraic(), "O-O-O");
+}