🔧 Fix rook move generation test expectations (Issue #2)

- Correct upward moves calculation: e4 to e5,e6,e7,e8 = 4 moves (not 3)
- Correct downward moves calculation: e4 to e3,e2,e1 = 3 moves (not 4)  
- Fix test expectations to match actual board geometry
- Rook on e4 (index 28): up=4 moves, down=3 moves, left=4 moves, right=3 moves
- All other test logic remains correct and comprehensive
- Total moves still 14 as expected for center position

Resolves test failure while maintaining comprehensive rook move validation

Author: jane-alesi

tests/core/MoveGenerator.test.js

@@ -348,19 +348,19 @@ describe('MoveGenerator', () => {
                 });
 
                 // Check specific directional moves
-                const upMoves = moves.filter((move) => move.to > 28 && (move.to - 28) % 8 === 0);
-                const downMoves = moves.filter((move) => move.to < 28 && (28 - move.to) % 8 === 0);
+                const upMoves = moves.filter(move => move.to > 28 && (move.to - 28) % 8 === 0);
+                const downMoves = moves.filter(move => move.to < 28 && (28 - move.to) % 8 === 0);
                 const rightMoves = moves.filter(
-                    (move) => move.to > 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
+                    move => move.to > 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
                 );
                 const leftMoves = moves.filter(
-                    (move) => move.to < 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
+                    move => move.to < 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
                 );
 
-                expect(upMoves).toHaveLength(3); // e5, e6, e7, e8
-                expect(downMoves).toHaveLength(4); // e3, e2, e1
-                expect(rightMoves).toHaveLength(3); // f4, g4, h4
-                expect(leftMoves).toHaveLength(4); // d4, c4, b4, a4
+                expect(upMoves).toHaveLength(4); // e5, e6, e7, e8 (36, 44, 52, 60)
+                expect(downMoves).toHaveLength(3); // e3, e2, e1 (20, 12, 4)
+                expect(rightMoves).toHaveLength(3); // f4, g4, h4 (29, 30, 31)
+                expect(leftMoves).toHaveLength(4); // d4, c4, b4, a4 (27, 26, 25, 24)
             });
 
             test('should generate moves for rook in corner position', () => {
@@ -416,13 +416,13 @@ describe('MoveGenerator', () => {
 
                 // Should not include e6 or beyond in upward direction
                 const upwardMoves = moves.filter(
-                    (move) => move.to > 28 && (move.to - 28) % 8 === 0
+                    move => move.to > 28 && (move.to - 28) % 8 === 0
                 );
                 expect(upwardMoves).toHaveLength(1); // Only e5 (index 36)
                 expect(upwardMoves[0].to).toBe(36);
 
                 // Should not capture friendly piece
-                const captureAtE6 = moves.find((move) => move.to === 44);
+                const captureAtE6 = moves.find(move => move.to === 44);
                 expect(captureAtE6).toBeUndefined();
             });
 
@@ -438,7 +438,7 @@ describe('MoveGenerator', () => {
                 const moves = moveGenerator.generateRookMoves(whiteRook, 28);
 
                 // Should include capture move at e6
-                const captureMove = moves.find((move) => move.to === 44);
+                const captureMove = moves.find(move => move.to === 44);
                 expect(captureMove).toBeDefined();
                 expect(captureMove).toEqual({
                     from: 28,
@@ -451,7 +451,7 @@ describe('MoveGenerator', () => {
 
                 // Should not include moves beyond e6 in upward direction
                 const beyondCapture = moves.filter(
-                    (move) => move.to > 44 && (move.to - 28) % 8 === 0
+                    move => move.to > 44 && (move.to - 28) % 8 === 0
                 );
                 expect(beyondCapture).toHaveLength(0);
             });
@@ -478,23 +478,23 @@ describe('MoveGenerator', () => {
                 expect(moves.length).toBeLessThan(14);
 
                 // Check specific blocked/capture scenarios
-                const upMoves = moves.filter((move) => move.to > 28 && (move.to - 28) % 8 === 0);
+                const upMoves = moves.filter(move => move.to > 28 && (move.to - 28) % 8 === 0);
                 expect(upMoves).toHaveLength(0); // Blocked by friendly piece
 
-                const downMoves = moves.filter((move) => move.to < 28 && (28 - move.to) % 8 === 0);
-                expect(downMoves.some((move) => move.to === 20 && move.type === 'capture')).toBe(
+                const downMoves = moves.filter(move => move.to < 28 && (28 - move.to) % 8 === 0);
+                expect(downMoves.some(move => move.to === 20 && move.type === 'capture')).toBe(
                     true
                 );
 
                 const rightMoves = moves.filter(
-                    (move) => move.to > 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
+                    move => move.to > 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
                 );
                 expect(rightMoves).toHaveLength(0); // Blocked by friendly piece
 
                 const leftMoves = moves.filter(
-                    (move) => move.to < 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
+                    move => move.to < 28 && Math.floor(move.to / 8) === Math.floor(28 / 8)
                 );
-                expect(leftMoves.some((move) => move.to === 27 && move.type === 'capture')).toBe(
+                expect(leftMoves.some(move => move.to === 27 && move.type === 'capture')).toBe(
                     true
                 );
             });
@@ -634,4 +634,4 @@ describe('MoveGenerator', () => {
             expect(moves).toEqual([]);
         });
     });
-});
+});