highlights squares of possible moves of selected piece, error messages, handling clicks outside the board

hjtan02 · hjtan02 · commit 24a437b60223 · 2024-12-05T11:54:03.000-05:00
diff --git a/app/src/main/java/com/example/chaiss/PlayActivity.java b/app/src/main/java/com/example/chaiss/PlayActivity.java
@@ -2,35 +2,48 @@
 
 import android.graphics.drawable.PictureDrawable;
 import android.os.Bundle;
+import android.util.Log;
 import android.view.MotionEvent;
 import android.view.View;
 import android.widget.ImageView;
 import android.widget.Toast;
 import androidx.appcompat.app.AppCompatActivity;
 
 import com.caverock.androidsvg.SVG;
+import com.caverock.androidsvg.PreserveAspectRatio;
+import com.caverock.androidsvg.SVGParseException;
+import com.chaquo.python.PyObject;
+import com.chaquo.python.Python;
+import com.chaquo.python.android.AndroidPlatform;
+
+import java.util.ArrayList;
+import java.util.List;
 
 public class PlayActivity extends AppCompatActivity {
 
-    private ChessEngine chessEngine;
+    private Python py;
+    private PyObject chessLogic;
     private String currentFEN;
     private ImageView chessBoardImage;
-
-    private String selectedSquare = null; // Track the square being touched
+    private String selectedSquare = null;
+    private List<String> legalMoves = null;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_play);
 
-        chessEngine = new ChessEngine();
+        if(!Python.isStarted()) {
+            Python.start(new AndroidPlatform(this));
+        }
+        py = Python.getInstance();
+        chessLogic = py.getModule("chess_logic");
+
         chessBoardImage = findViewById(R.id.chess_board);
 
-        // Initialize board state
-        currentFEN = chessEngine.createBoard();
+        currentFEN = chessLogic.callAttr("create_board").toString();
         updateBoard();
 
-        // Set touch listener on the chessboard
         chessBoardImage.setOnTouchListener(new View.OnTouchListener() {
             @Override
             public boolean onTouch(View v, MotionEvent event) {
@@ -42,61 +55,116 @@ public boolean onTouch(View v, MotionEvent event) {
             }
         });
 
-        // Back arrow functionality
         ImageView backArrow = findViewById(R.id.back_arrow);
         backArrow.setOnClickListener(v -> finish());
     }
 
     private void handleTouch(float x, float y) {
-        // Map touch coordinates to a chess square
         String square = getSquareFromTouch(x, y);
-
+        if (square == null) {
+            return;
+        }
         if (selectedSquare == null) {
-            // First touch: select the piece
             selectedSquare = square;
-            Toast.makeText(this, "Selected: " + selectedSquare, Toast.LENGTH_SHORT).show();
+            try {
+                PyObject legalMovesPy = chessLogic.callAttr("get_legal_moves_from_square", currentFEN, selectedSquare);
+                List<String> legalMoves = new ArrayList<>();
+                for (PyObject move : legalMovesPy.asList()) {
+                    legalMoves.add(move.toString());
+                }
+                if (legalMoves.isEmpty()) {
+                    Toast.makeText(this, "No legal moves from " + selectedSquare, Toast.LENGTH_SHORT).show();
+                    selectedSquare = null;
+                } else {
+                    this.legalMoves = legalMoves;
+                    updateBoard();
+                }
+            } catch (Exception e) {
+                Toast.makeText(this, "Error finding legal moves: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+                selectedSquare = null;
+            }
         } else {
-            // Second touch: move the piece
-            String move = selectedSquare + square; // e.g., "e2e4"
+            String move = selectedSquare + square;
+            Log.d("ChessApp", "Attempting move: " + move);
             try {
-                currentFEN = chessEngine.makeMove(currentFEN, move); // Update the board state
-                updateBoard(); // Redraw the board
-                selectedSquare = null; // Reset selection
+                PyObject result = chessLogic.callAttr("make_move", currentFEN, move);
+                currentFEN = result.toString();
+                selectedSquare = null;
+                this.legalMoves = null;
+                updateBoard();
             } catch (Exception e) {
-                Toast.makeText(this, "Invalid move", Toast.LENGTH_SHORT).show();
-                selectedSquare = null; // Reset selection
+                Toast.makeText(this, "Invalid move: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+                selectedSquare = null;
+                this.legalMoves = null;
+                updateBoard();
             }
         }
     }
 
     private String getSquareFromTouch(float x, float y) {
-        // Calculate board square based on touch coordinates
-        int boardSize = chessBoardImage.getWidth(); // Assuming square layout
+        int boardSize = chessBoardImage.getWidth();
         int squareSize = boardSize / 8;
 
         int col = (int) (x / squareSize);
-        int row = 7 - (int) (y / squareSize); // Flip Y-axis for chess notation
+        int row = 7 - (int) (y / squareSize);
+
+        if (col < 0 || col > 7 || row < 0 || row > 7) {
+            return null;
+        }
 
         char file = (char) ('a' + col);
         int rank = row + 1;
 
-        return "" + file + rank; // Chess notation, e.g., "e2"
+        return "" + file + rank;
     }
 
     private void updateBoard() {
-        try {
-            // Fetch the SVG representation of the chessboard from the Python code
-            String boardSvg = chessEngine.renderBoard(currentFEN);
-
-            // Use AndroidSVG to render the SVG
-            SVG svg = SVG.getFromString(boardSvg);
-            PictureDrawable drawable = new PictureDrawable(svg.renderToPicture());
-
-            // Display the drawable in the ImageView
-            chessBoardImage.setLayerType(View.LAYER_TYPE_SOFTWARE, null); // Required for SVG rendering
-            chessBoardImage.setImageDrawable(drawable);
-        } catch (Exception e) {
-            Toast.makeText(this, "Error rendering board: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        new Thread(() -> {
+            try {
+                PyObject svgData;
+                if (selectedSquare != null && legalMoves != null) {
+                    String[] legalMovesArray = legalMoves.toArray(new String[0]);
+                    svgData = chessLogic.callAttr("render_board", currentFEN, selectedSquare, (Object) legalMovesArray);
+                } else {
+                    svgData = chessLogic.callAttr("render_board", currentFEN);
+                }
+                String boardSvg = svgData.toString();
+                runOnUiThread(() -> {
+                    try {
+                        SVG svg = SVG.getFromString(boardSvg);
+                        svg.setDocumentWidth("100%");
+                        svg.setDocumentHeight("100%");
+                        svg.setDocumentPreserveAspectRatio(PreserveAspectRatio.LETTERBOX);
+                        chessBoardImage.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
+                        chessBoardImage.setImageDrawable(new PictureDrawable(svg.renderToPicture()));
+                    } catch (SVGParseException e) {
+                        Toast.makeText(this, "Error rendering board: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+                        e.printStackTrace();
+                    }
+                });
+            } catch (Exception e) {
+                runOnUiThread(() -> {
+                    Toast.makeText(this, "Error rendering board: " + e.getMessage(), Toast.LENGTH_LONG).show();
+                });
+                e.printStackTrace();
+            }
+        }).start();
+    }
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putString("currentFEN", currentFEN);
+        outState.putString("selectedSquare", selectedSquare);
+        if (legalMoves != null) {
+            outState.putStringArrayList("legalMoves", new ArrayList<>(legalMoves));
         }
     }
+    @Override
+    protected void onRestoreInstanceState(Bundle savedInstanceState) {
+        super.onRestoreInstanceState(savedInstanceState);
+        currentFEN = savedInstanceState.getString("currentFEN");
+        selectedSquare = savedInstanceState.getString("selectedSquare");
+        legalMoves = savedInstanceState.getStringArrayList("legalMoves");
+        updateBoard();
+    }
 }
diff --git a/app/src/main/python/chess_logic.py b/app/src/main/python/chess_logic.py
@@ -7,17 +7,39 @@ def create_board():
 
 def get_legal_moves(fen):
     board = chess.Board(fen)
-    return [move.uci() for move in board.legal_moves]
+    moves = [move.uci() for move in board.legal_moves]
+    return moves
 
-def make_move(fen, move):
+def make_move(fen, move_uci):
     board = chess.Board(fen)
-    if move in [m.uci() for m in board.legal_moves]:
-        board.push_uci(move)
+    move = chess.Move.from_uci(move_uci)
+    if move in board.legal_moves:
+        board.push(move)
         return board.fen()
     else:
-        raise ValueError("Invalid move")
+        raise ValueError(f"Invalid move: {move_uci}")
 
-def render_board(fen):
+def get_legal_moves_from_square(fen, square):
     board = chess.Board(fen)
-    svg_data = chess.svg.board(board)
+    legal_moves = []
+    from_square = chess.parse_square(square)
+    for move in board.legal_moves:
+        if move.from_square == from_square:
+            to_square = chess.square_name(move.to_square)
+            legal_moves.append(to_square)
+    return legal_moves
+
+def render_board(fen, selected_square=None, legal_moves=None):
+    board = chess.Board(fen)
+    squares_to_highlight = {}
+    if selected_square:
+        selected_sq = chess.parse_square(selected_square)
+        squares_to_highlight[selected_sq] = "#a9a9f5"
+
+    if legal_moves:
+        for move_square in legal_moves:
+            sq = chess.parse_square(move_square)
+            squares_to_highlight[sq] = "#f5a9a9"
+
+    svg_data = chess.svg.board(board, squares=squares_to_highlight)
     return svg_data
