Connect4 — 11: מהלך אחד, שלושה מסכים

     public RoomStatus getStatus() {
         return status;
     }
 
+    /** Reports whether this role owns the side to move in an active, validated room. */
+    public boolean canMove() {
+        if (status != RoomStatus.PLAYING || role == RoomRole.SPECTATOR) {
+            return false;
+        }
+        int player = gameState.currentPlayer();
+        return (role == RoomRole.RED && player == 1)
+                || (role == RoomRole.YELLOW && player == 2);
+    }
 }

 package com.example.connect4.multiplayer;
 
+import com.example.connect4.core.GameAction;
+import com.example.connect4.core.GameState;
 import com.google.firebase.auth.FirebaseAuth;
 import com.google.firebase.auth.FirebaseUser;
 import com.google.firebase.auth.GoogleAuthProvider;
 import com.google.firebase.database.DataSnapshot;

     private final DatabaseReference gamesReference;
 
     private String pendingCreateRoomId;
     private String pendingJoinRoomId;
+    private PendingMove pendingMove;
 
     /** Creates a repository backed by the configured production Firebase instances. */
     public MultiplayerRepository() {
         this(FirebaseAuth.getInstance(), FirebaseRefs.database());

             }
         }, false);
     }
 
-
+    /** Appends one column only when the server still has the captured expected history. */
+    public void submitMove(String roomId, int column, String expectedMoves,
+                           ResultCallback<String> callback) {
+        String uid = currentUid();
+        if (uid == null) {
+            callback.onError(error(RepositoryError.Code.AUTH_REQUIRED,
+                    "Sign in before playing a move", roomId));
+            return;
+        }
+        if (!validRoomId(roomId) || column < 0 || column > 6
+                || expectedMoves == null || !expectedMoves.matches("[0-6]{0,42}")) {
+            callback.onError(error(RepositoryError.Code.INVALID_ARGUMENT,
+                    "Move request is invalid", roomId));
+            return;
+        }
+        PendingMove operation = new PendingMove(roomId, expectedMoves, column);
+        synchronized (this) {
+            if (pendingMove != null) {
+                callback.onError(error(RepositoryError.Code.BUSY,
+                        "A move is already pending", pendingMove.roomId));
+                return;
+            }
+            pendingMove = operation;
+        }
+
+        DatabaseReference roomReference = gamesReference.child(roomId);
+        roomReference.get().addOnCompleteListener(readTask -> {
+            if (!readTask.isSuccessful()) {
+                clearPendingMove(operation);
+                callback.onError(firebaseError(readTask.getException(), roomId));
+                return;
+            }
+            if (!readTask.getResult().exists()) {
+                clearPendingMove(operation);
+                callback.onError(error(RepositoryError.Code.MISSING_ROOM,
+                        "This room no longer exists", roomId));
+                return;
+            }
+            ParsedRoom baseline = parseRoom(readTask.getResult());
+            if (baseline.error != null) {
+                clearPendingMove(operation);
+                callback.onError(error(RepositoryError.Code.INVALID_ROOM,
+                        baseline.error, roomId));
+                return;
+            }
+            runMoveTransaction(roomReference, uid, baseline.room, operation, callback);
+        });
+    }
+
+    private void runMoveTransaction(DatabaseReference roomReference, String uid, RoomData baseline,
+                                    PendingMove operation, ResultCallback<String> callback) {
+        AtomicReference<String> rejection = new AtomicReference<>("Room changed before the move");
+        roomReference.runTransaction(new Transaction.Handler() {
+            @Override
+            public Transaction.Result doTransaction(MutableData currentData) {
+                seedEmptyTransaction(currentData, baseline);
+                MutableRoom parsed = parseMutableRoom(currentData);
+                if (parsed.error != null) {
+                    rejection.set(parsed.error);
+                    return Transaction.abort();
+                }
+                RoomData room = parsed.room;
+                RoomValidation.Result validation = parsed.validation;
+                if (!operation.expectedMoves.equals(room.getMoves())) {
+                    rejection.set("Move history changed; refresh the room");
+                    return Transaction.abort();
+                }
+                if (room.getPlayerYellow().isEmpty()) {
+                    rejection.set("Wait for a Yellow player before moving");
+                    return Transaction.abort();
+                }
+                int player = validation.getState().currentPlayer();
+                boolean ownsTurn = (player == GameState.RED && uid.equals(room.getPlayerRed()))
+                        || (player == GameState.YELLOW && uid.equals(room.getPlayerYellow()));
+                if (!ownsTurn) {
+                    rejection.set("It is not this user's turn");
+                    return Transaction.abort();
+                }
+                if (!new com.example.connect4.core.GameEngine(validation.getState())
+                        .apply(new GameAction(operation.column))) {
+                    rejection.set("That column is full or the game is finished");
+                    return Transaction.abort();
+                }
+                String newMoves = room.getMoves() + operation.column;
+                currentData.child("moves").setValue(newMoves);
+                currentData.child("updatedAt").setValue(ServerValue.TIMESTAMP);
+                rejection.set(null);
+                return Transaction.success(currentData);
+            }
+
+            @Override
+            public void onComplete(DatabaseError databaseError, boolean committed,
+                                   DataSnapshot snapshot) {
+                clearPendingMove(operation);
+                if (databaseError != null) {
+                    callback.onError(databaseError(databaseError, operation.roomId));
+                } else if (!committed) {
+                    callback.onError(error(RepositoryError.Code.CONFLICT,
+                            rejection.get(), operation.roomId));
+                } else {
+                    callback.onSuccess(operation.expectedMoves + operation.column);
+                }
+            }
+        }, false);
+    }
 
     public synchronized String pendingCreateRoomId() {
         return pendingCreateRoomId;
     }

     public synchronized String pendingJoinRoomId() {
         return pendingJoinRoomId;
     }
 
+    public synchronized String pendingMoveRoomId() {
+        return pendingMove == null ? null : pendingMove.roomId;
+    }
 
     private synchronized void clearPendingCreate(String roomId) {
         if (roomId != null && roomId.equals(pendingCreateRoomId)) {
             pendingCreateRoomId = null;

             pendingJoinRoomId = null;
         }
     }
 
+    private synchronized void clearPendingMove(PendingMove operation) {
+        if (pendingMove == operation) {
+            pendingMove = null;
+        }
+    }
 
     private static ParsedRoom parseRoom(DataSnapshot snapshot) {
         RoomData room;
         try {

             this.error = error;
         }
     }
 
+    private static final class PendingMove {
+        private final String roomId;
+        private final String expectedMoves;
+        private final int column;
+
+        private PendingMove(String roomId, String expectedMoves, int column) {
+            this.roomId = roomId;
+            this.expectedMoves = expectedMoves;
+            this.column = column;
+        }
+    }
+
     public interface Subscription extends AutoCloseable {
         Subscription EMPTY = () -> { };
 
         @Override

         session.onlineMessage = "Choose a room or create a new one. Previous rooms are preserved.";
         refreshScreen();
     }
 
-
+    void move(int column) {
+        if (!canMove()) return;
+        long token = session.onlineGeneration;
+        String prefix = session.room.getRoom().getMoves();
+        session.onlineMessage = "Sending move…";
+        session.repository.submitMove(session.roomId, column, prefix, new MultiplayerRepository.ResultCallback<String>() {
+            @Override public void onSuccess(String moves) {
+                if (token != session.onlineGeneration) return;
+                session.onlineMessage = "Move accepted";
+                refreshLatestScreen();
+            }
+            @Override public void onError(RepositoryError error) {
+                if (token != session.onlineGeneration) return;
+                showError(error);
+                refreshLatestScreen();
+            }
+        });
+        host.changed();
+    }
+
+    boolean canMove() {
+        return active && !pending()
+                && session.room != null && session.room.canMove();
+    }
 
     private boolean pending() {
         MultiplayerRepository repo = session.repository;
-        return repo != null && (repo.pendingCreateRoomId() != null || repo.pendingJoinRoomId() != null);
+        return repo != null && (repo.pendingCreateRoomId() != null || repo.pendingJoinRoomId() != null || repo.pendingMoveRoomId() != null);
     }
 
     private void showError(RepositoryError error) {
         session.onlineMessage = error.getMessage();

 
 
     private boolean humanTurn() {
         GameState state = session.engine.snapshot();
-        if (session.mode == GameSession.MODE_ONLINE) return false;
+        if (session.mode == GameSession.MODE_ONLINE) return online != null && online.canMove();
         return started && !state.isTerminal() && !session.isComputerThinking()
                 && (session.mode == GameSession.MODE_LOCAL
                 || state.currentPlayer() == session.humanSide);
     }
 
     private void playColumn(int column) {
         if (!humanTurn()) return;
+        if (session.mode == GameSession.MODE_ONLINE) { online.move(column); return; }
         if (session.engine.apply(new GameAction(column))) { persist(); render(); }
     }
 
     private void render() {