From 1e17c8fea8b22aeb28d966c47970848409207668 Mon Sep 17 00:00:00 2001
From: Ido-Barnea <dodo.barnea@gmail.com>
Date: Thu, 18 Jan 2024 21:23:28 +0200
Subject: [PATCH] [#139] Fixed pawn movement

---
 development/code/Game.ts                   |  5 ++-
 development/code/logic/PieceLogic.ts       | 14 +++++--
 development/code/logic/pieces/Pawn.test.ts |  2 +-
 development/code/logic/pieces/Pawn.ts      | 47 ++++++++++++++++------
 4 files changed, 48 insertions(+), 20 deletions(-)

diff --git a/development/code/Game.ts b/development/code/Game.ts
index 66acc468..8739d51e 100644
--- a/development/code/Game.ts
+++ b/development/code/Game.ts
@@ -88,8 +88,9 @@ function resetVariables() {
 
   pieces.forEach((piece) => {
     if (piece.player !== getCurrentPlayer() && piece instanceof Pawn) {
-      piece.enPassantPositions = undefined;
-      piece.isDiagonalAttack = false;
+      piece.possibleEnPassantPositions = undefined;
+      piece.isInitialDoubleStep = false;
+      piece.diagonalAttackPosition = undefined;
     }
   });
 }
diff --git a/development/code/logic/PieceLogic.ts b/development/code/logic/PieceLogic.ts
index 35b0ff2b..c87e8ebc 100644
--- a/development/code/logic/PieceLogic.ts
+++ b/development/code/logic/PieceLogic.ts
@@ -99,11 +99,17 @@ function onActionPieceToSquare(
     }
   }
 
-  if (draggedPiece instanceof Pawn && draggedPiece.isDiagonalAttack) {
-    const pawn = draggedPiece.isValidEnPassant(targetSquare.position);
-    if (!pawn) return;
+  if (draggedPiece instanceof Pawn) {
+    draggedPiece.checkInitialDoubleStep(targetSquare.position);
 
-    killPiece(draggedPiece, pawn, targetSquare.position);
+    if (draggedPiece.diagonalAttackPosition) {
+      if (comparePositions(draggedPiece.diagonalAttackPosition, targetSquare.position)) {
+        const enPassantPiece = draggedPiece.getEnPassantPiece(targetSquare.position);
+        if (!enPassantPiece) return;
+  
+        killPiece(draggedPiece, enPassantPiece, targetSquare.position);
+      }
+    }
   }
 
   move(draggedPiece, targetSquare);
diff --git a/development/code/logic/pieces/Pawn.test.ts b/development/code/logic/pieces/Pawn.test.ts
index 276a9d93..111aca41 100644
--- a/development/code/logic/pieces/Pawn.test.ts
+++ b/development/code/logic/pieces/Pawn.test.ts
@@ -34,7 +34,7 @@ describe('Piece movements', () => {
       blackPawnPosition,
       blackPlayer,
     );
-    blackPawn.enPassantPositions = [
+    blackPawn.possibleEnPassantPositions = [
       {
         coordinates: [1, 5],
         boardId: OVERWORLD_BOARD_ID,
diff --git a/development/code/logic/pieces/Pawn.ts b/development/code/logic/pieces/Pawn.ts
index 7512fae5..b608b075 100644
--- a/development/code/logic/pieces/Pawn.ts
+++ b/development/code/logic/pieces/Pawn.ts
@@ -6,25 +6,46 @@ import { game } from '../../Game';
 import { comparePositions, getPieceByPosition } from '../Utilities';
 
 export class Pawn extends Piece {
-  enPassantPositions: [Position, Position] | undefined;
-  isDiagonalAttack: boolean;
+  possibleEnPassantPositions: [Position, Position] | undefined;
+  isInitialDoubleStep: boolean;
+  diagonalAttackPosition: Position | undefined;
 
   constructor(position: Position, player: Player) {
     const logo = player.color === PlayerColors.WHITE
       ? '♙'
       : '♟';
     super(position, player, pawnResource, 'Pawn', logo);
-    this.enPassantPositions = undefined;
-    this.isDiagonalAttack = false;
+    this.possibleEnPassantPositions = undefined;
+    this.isInitialDoubleStep = false;
+    this.diagonalAttackPosition = undefined;
   }
 
-  isValidEnPassant(targetPosition: Position) {
+  checkInitialDoubleStep(targetPosition: Position): boolean {
+    const currentCoordinates = this.position.coordinates;
+    const currentPlayer = game.getCurrentPlayer();
+    // Determine the direction of pawn movement based on the player's color
+    const stepY = currentPlayer.color === PlayerColors.WHITE ? -1 : 1;
+
+    const twoSquaresForward: Position = {
+      coordinates: [currentCoordinates[0], currentCoordinates[1] + 2 * stepY],
+      boardId: this.position.boardId,
+    };
+
+    if (comparePositions(twoSquaresForward, targetPosition)) {
+      this.isInitialDoubleStep = true;
+      return true;
+    }
+
+    return false;
+  }
+
+  getEnPassantPiece(targetPosition: Position): Piece | undefined {
     const pawns = game.getPieces().filter(piece => piece instanceof Pawn && piece !== this) as Array<Pawn>;
-    if (!pawns) return;
+    if (!pawns.length) return;
 
     const enPassantPawns = pawns.filter(pawn => {
-      if (pawn.enPassantPositions) {
-        return comparePositions(pawn.enPassantPositions[0], targetPosition);
+      if (pawn.isInitialDoubleStep && pawn.possibleEnPassantPositions) {
+        return comparePositions(pawn.possibleEnPassantPositions[0], targetPosition);
       }
     });
     if (!enPassantPawns.length) return;
@@ -57,7 +78,7 @@ export class Pawn extends Piece {
         };
 
         if (!getPieceByPosition(twoSquaresForward) && !getPieceByPosition(oneSquareForward)) {
-          this.enPassantPositions = [oneSquareForward, twoSquaresForward];
+          this.possibleEnPassantPositions = [oneSquareForward, twoSquaresForward];
           validMoves.push(twoSquaresForward);
         }
       }
@@ -74,13 +95,13 @@ export class Pawn extends Piece {
       boardId: this.position.boardId,
     };
 
-    if (getPieceByPosition(leftDiagonal) || this.isValidEnPassant(leftDiagonal)) {
-      this.isDiagonalAttack = true;
+    if (getPieceByPosition(leftDiagonal) || this.getEnPassantPiece(leftDiagonal)) {
+      this.diagonalAttackPosition = leftDiagonal;
       validMoves.push(leftDiagonal);
     }
 
-    if (getPieceByPosition(rightDiagonal) || this.isValidEnPassant(rightDiagonal)) {
-      this.isDiagonalAttack = true;
+    if (getPieceByPosition(rightDiagonal) || this.getEnPassantPiece(rightDiagonal)) {
+      this.diagonalAttackPosition = rightDiagonal;
       validMoves.push(rightDiagonal);
     }