Connect4 — 05: מחשב פשוט שאפשר להסביר

         }
         return true;
     }
 
+    /**
+     * Tests a hypothetical drop for either side without changing the snapshot.
+     * The heuristic uses this for both winning moves and opponent threats, so
+     * gravity and win detection remain the same rules used by apply().
+     */
+    public static boolean wouldWin(GameState state, GameAction action, int player) {
+        if (player != GameState.RED && player != GameState.YELLOW) {
+            throw new IllegalArgumentException("player must be Red or Yellow");
+        }
+        if (state.isTerminal() || action == null
+                || action.column() < 0 || action.column() >= GameState.COLUMNS) {
+            return false;
+        }
+        int[][] board = state.boardCopy();
+        int row = findLandingRow(board, action.column());
+        if (row < 0) {
+            return false;
+        }
+        board[row][action.column()] = player;
+        return !findWinningCells(board, player).isEmpty();
+    }
+
     private static int findLandingRow(int[][] board, int column) {
         for (int row = GameState.ROWS - 1; row >= 0; row--) {
             if (board[row][column] == GameState.EMPTY) {
                 return row;

 <resources>
     <string name="app_name">Connect4</string>
+    <string-array name="game_modes">
+        <item>Two players · this device</item>
+        <item>Play heuristic</item>
+    </string-array>
+    <string-array name="player_sides">
+        <item>You are Red · play first</item>
+        <item>You are Yellow · play second</item>
+    </string-array>
 </resources>

     android:layout_width="match_parent"
     android:layout_height="match_parent"
     tools:context=".MainActivity">
 
+    <androidx.fragment.app.FragmentContainerView
+        android:id="@+id/gameSetup"
+        android:name="com.example.connect4.GameSetupFragment"
+        android:layout_width="0dp" android:layout_height="wrap_content"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent" />
+
     <TextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:id="@+id/status"
         android:text="Tap a column"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
+        app:layout_constraintTop_toBottomOf="@id/gameSetup" />
 
     <com.example.connect4.ui.BoardView
         android:id="@+id/board"
         android:layout_width="0dp"

 import com.example.connect4.core.GameEngine;
 
 /** Retains the game across Activity recreation, without keeping a View or Activity. */
 public final class GameSession extends ViewModel {
+    public static final int MODE_LOCAL = 0;
+    public static final int MODE_HEURISTIC = 1;
+    public int mode = MODE_LOCAL;
+    public int humanSide = com.example.connect4.core.GameState.RED;
     public GameEngine engine = new GameEngine();
     public boolean restored;
 }

 import androidx.lifecycle.ViewModelProvider;
 import com.example.connect4.core.GameAction;
 import com.example.connect4.core.GameEngine;
 import com.example.connect4.core.GameState;
+import com.example.connect4.core.ComputerPlayer;
+import com.example.connect4.core.HeuristicPlayer;
 
 import com.example.connect4.databinding.ActivityMainBinding;
 
 import androidx.activity.EdgeToEdge;

 
 public class MainActivity extends AppCompatActivity {
     private ActivityMainBinding binding;
     private GameSession session;
+    private GameSetupFragment setup;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

             v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
             return insets;
         });
         session = new ViewModelProvider(this).get(GameSession.class);
+        setup = (GameSetupFragment) getSupportFragmentManager().findFragmentById(R.id.gameSetup);
         if (!session.restored) {
+            session.mode = getPreferences(MODE_PRIVATE).getInt("mode", GameSession.MODE_LOCAL);
+            if (session.mode < 0 || session.mode > GameSession.MODE_HEURISTIC) session.mode = GameSession.MODE_LOCAL;
+            session.humanSide = getPreferences(MODE_PRIVATE).getInt("side", GameState.RED);
+            if (session.humanSide != GameState.RED && session.humanSide != GameState.YELLOW) session.humanSide = GameState.RED;
             String moves = getPreferences(MODE_PRIVATE).getString("moves", "");
             GameEngine restored = new GameEngine();
             for (int i = 0; i < moves.length(); i++) {
                 if (!restored.apply(new GameAction(moves.charAt(i) - '0'))) break;
             }
             session.engine = restored;
             session.restored = true;
         }
+        setup.configure(session.mode, session.humanSide - 1, new GameSetupFragment.Listener() {
+            @Override public void onModeSelected(int position) {
+                if (session.mode != position) { session.mode = position; newGame(); }
+                setup.showMode(session.mode);
+            }
+            @Override public void onSideSelected(int position) {
+                if (session.humanSide != position + 1) { session.humanSide = position + 1; newGame(); }
+            }
+        });
         binding.board.setColumnListener(column -> {
+            if (!humanTurn()) return;
             if (session.engine.apply(new GameAction(column))) { persist(); render(); }
         });
-        binding.restart.setOnClickListener(v -> {
-            session.engine = new GameEngine();
-            persist();
-            render();
-        });
+        binding.restart.setOnClickListener(v -> newGame());
         render();
     }
+    /** Resets the game after changing a player or pressing New game. */
+    private void newGame() {
+        session.engine = new GameEngine();
+        persist();
+        render();
+    }
+
+    private boolean humanTurn() {
+        return !session.engine.snapshot().isTerminal()
+                && (session.mode == GameSession.MODE_LOCAL
+                || session.engine.snapshot().currentPlayer() == session.humanSide);
+    }
+
     /** Presents the model; drawing does not change the game. */
     private void render() {
         GameState state = session.engine.snapshot();
         binding.board.show(state);
         if (state.isDraw()) binding.status.setText("Draw — board full");
         else if (state.isTerminal()) binding.status.setText(state.winner() == GameState.RED ? "Red wins!" : "Yellow wins!");
         else binding.status.setText(state.currentPlayer() == GameState.RED ? "Red to play" : "Yellow to play");
+        if (session.mode == GameSession.MODE_HEURISTIC && !state.isTerminal() && !humanTurn()) {
+            ComputerPlayer player = new HeuristicPlayer();
+            GameAction action = player.chooseAction(state);
+            if (session.engine.apply(action)) { persist(); render(); }
+        }
     }
 
     /** Saves only accepted column history; the engine reconstructs the rest. */
     private void persist() {
-        getPreferences(MODE_PRIVATE).edit().putString("moves", session.engine.snapshot().moves()).apply();
+        getPreferences(MODE_PRIVATE).edit().putString("moves", session.engine.snapshot().moves())
+                .putInt("mode", session.mode).putInt("side", session.humanSide).apply();
     }
 
     @Override protected void onStop() {
         persist();
         super.onStop();
     }
+
+    ActivityMainBinding viewBinding() { return binding; }
+    com.example.connect4.databinding.FragmentGameSetupBinding setupBinding() { return setup.viewBinding(); }
 }