fix: comply with FIDE 9.2.2 in samePosition en passant check (#98)

* fix: only consider en passant square in samePosition when capture is legal

Per FIDE Article 9.2.2, positions are the same if "the possible moves
of all the pieces are the same". The en passant square should only be
considered when determining position equality if an en passant capture
is actually possible — that is, there is an opponent pawn on an
adjacent file that could make the capture.

Previously, samePosition compared en passant squares directly, which
could treat positions as different even when no pawn could actually
capture en passant. This caused incorrect threefold repetition
detection.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: reference correct FIDE article (9.2.3, not 9.2.2)

* fix: reference correct FIDE article 9.2.3 in test

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: meruiden

position.go

@@ -441,10 +441,59 @@ func (pos *Position) updateEnPassantSquare(m *Move) Square {
 	return NoSquare
 }
 
-// samePosition returns true if the two positions are the same.
+// samePosition returns true if the two positions are the same
+// according to FIDE Article 9.2.3. The en passant square is only
+// considered if an en passant capture is actually possible (i.e.,
+// there is an opponent pawn on an adjacent file that could capture)
+// per FIDE Article 9.2.3.1.
 func (pos *Position) samePosition(pos2 *Position) bool {
 	return pos.board.String() == pos2.board.String() &&
 		pos.turn == pos2.turn &&
 		pos.castleRights.String() == pos2.castleRights.String() &&
-		pos.enPassantSquare == pos2.enPassantSquare
+		pos.relevantEnPassantSquare() == pos2.relevantEnPassantSquare()
+}
+
+// relevantEnPassantSquare returns the en passant square only if
+// an en passant capture is actually possible. Per FIDE rules,
+// the en passant square is only relevant if there is an opponent
+// pawn that can make the capture.
+func (pos *Position) relevantEnPassantSquare() Square {
+	if pos.enPassantSquare == NoSquare {
+		return NoSquare
+	}
+	// The en passant square is the square the capturing pawn moves TO.
+	// The capturing pawn must be on an adjacent file, on the same rank
+	// as the pawn that just advanced two squares.
+	//
+	// If the en passant square is on rank 3, the capturing pawn (black)
+	// must be on rank 4. If on rank 6, the capturing pawn (white)
+	// must be on rank 5.
+	epFile := pos.enPassantSquare.File()
+	epRank := pos.enPassantSquare.Rank()
+
+	var captureRank Rank
+	var capturingPawn Piece
+	if epRank == Rank3 {
+		captureRank = Rank4
+		capturingPawn = BlackPawn
+	} else {
+		captureRank = Rank5
+		capturingPawn = WhitePawn
+	}
+
+	// Check adjacent files for a pawn that could capture
+	if epFile > FileA {
+		sq := NewSquare(epFile-1, captureRank)
+		if pos.board.Piece(sq) == capturingPawn {
+			return pos.enPassantSquare
+		}
+	}
+	if epFile < FileH {
+		sq := NewSquare(epFile+1, captureRank)
+		if pos.board.Piece(sq) == capturingPawn {
+			return pos.enPassantSquare
+		}
+	}
+
+	return NoSquare
 }

position_test.go

@@ -85,3 +85,65 @@ func TestPositionPly(t *testing.T) {
 		}
 	}
 }
+
+func TestSamePositionEnPassantFIDECompliance(t *testing.T) {
+	// FIDE Article 9.2.3: positions are the same only if "the possible
+	// moves of all the pieces are the same". Per Article 9.2.3.1, an en
+	// passant square should only matter when a pawn could have been
+	// captured en passant (i.e., the capture is actually possible).
+
+	// Position with en passant square set but no pawn can capture:
+	// White pawn on e4 (just pushed e2-e4), en passant square e3,
+	// but no black pawn on d4 or f4 to capture.
+	posWithIrrelevantEP, err := decodeFEN("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Same board position but without en passant square set.
+	posWithoutEP, err := decodeFEN("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// These should be considered the same position because no en passant
+	// capture is possible (no black pawn on d4 or f4).
+	if !posWithIrrelevantEP.samePosition(posWithoutEP) {
+		t.Error("positions with irrelevant en passant square should be considered the same")
+	}
+
+	// Position where en passant IS possible:
+	// White pawn on e4, black pawn on d4. En passant square e3.
+	// Black pawn on d4 can capture en passant on e3.
+	posWithRelevantEP, err := decodeFEN("rnbqkbnr/ppp1pppp/8/8/3pP3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Same board but without en passant square.
+	posWithRelevantNoEP, err := decodeFEN("rnbqkbnr/ppp1pppp/8/8/3pP3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// These should NOT be considered the same because the en passant
+	// capture is actually possible.
+	if posWithRelevantEP.samePosition(posWithRelevantNoEP) {
+		t.Error("positions with relevant en passant square should be considered different")
+	}
+
+	// Test with black pawn on f4 (right side of e4 pawn).
+	posWithRelevantEPRight, err := decodeFEN("rnbqkbnr/pppp1ppp/8/8/4Pp2/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	posWithRelevantEPRightNoEP, err := decodeFEN("rnbqkbnr/pppp1ppp/8/8/4Pp2/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if posWithRelevantEPRight.samePosition(posWithRelevantEPRightNoEP) {
+		t.Error("positions with relevant en passant square (right adjacent pawn) should be considered different")
+	}
+}