End-State Refactor

The final cleanup is to make every terminal path use one shared payout and lifecycle flow.

Why Centralize End State:
Wins, draws, and forfeits all end the game. They should not each hand-edit winner , credits , stake , and lifecycle flags.

Use _endGame:
makeMove should call _endGame(msg.sender, false) for a win and _endGame(address(0), true) for a draw.

Forfeit Path:
claimForfeit should also call _endGame(msg.sender, false) . That avoids duplicated payout math and keeps timeout wins consistent with board wins.

Keep checkWin:
The win helper is named checkWin() throughout the course. Keep that helper name in every end-state branch.

Your task: Refactor the end-state paths so the contract has one source of truth for payouts, lifecycle cleanup, and GameEnded while keeping the completed board readable.

Centralize end-state updates in _endGame

44%

Requirements:

makeMove uses _endGame for wins

makeMove uses _endGame for draws

makeMove does not emit GameEnded directly

claimForfeit uses _endGame

claimForfeit removes duplicated payout writes

_endGame clears stake and active flags

_endGame clears stale timeout state

_endGame leaves board inspectable

Keeps checkWin helper name

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract TicTacToe {
    uint64 constant ACCEPT_TIMEOUT = 1 days;
    uint64 constant MOVE_TIMEOUT = 1 days;

    event GameStarted(address indexed playerX, address indexed playerO, uint stake);
    event GameAccepted(address indexed playerO);
    event MoveMade(address indexed player, uint position);
    event GameEnded(address indexed winner, bool isDraw);
    event GameCancelled(address indexed playerX);
    event ForfeitClaimed(address indexed winner);

    address public playerX;
    address public playerO;

    enum Cell { Empty, X, O }

    Cell[9] public board;

    bool public xTurn;
    bool public gameOver;
    address public winner;
    uint public stake;
    bool public gameActive;
    bool public gameAccepted;
    uint64 public acceptDeadline;
    uint64 public lastMoveAt;
    mapping(address => uint256) public credits;

    function startGame(address _opponent) public payable {
        require(msg.value > 0, "Must send stake");
        require(!gameActive, "Game already active");
        require(_opponent != address(0), "Invalid opponent");
        require(_opponent != msg.sender, "Cannot play yourself");

        _resetGame();

        playerX = msg.sender;
        playerO = _opponent;
        xTurn = true;
        gameOver = false;
        winner = address(0);
        stake = msg.value;
        gameActive = true;
        gameAccepted = false;
        acceptDeadline = uint64(block.timestamp) + ACCEPT_TIMEOUT;

        emit GameStarted(playerX, playerO, stake);
    }

    function acceptGame() public payable {
        require(gameActive, "No active game");
        require(!gameAccepted, "Already accepted");
        require(msg.value == stake, "Must match stake");
        require(msg.sender == playerO, "Only opponent can accept");
        require(block.timestamp <= acceptDeadline, "Accept period expired");
        require(!gameOver, "Game already over");

        gameAccepted = true;
        lastMoveAt = uint64(block.timestamp);
        stake = msg.value * 2;

        emit GameAccepted(playerO);
    }

    function cancelUnaccepted() public {
        require(msg.sender == playerX, "Only starter can cancel");
        require(block.timestamp > acceptDeadline, "Accept period not expired");
        require(!gameAccepted, "Game already accepted");

        credits[playerX] += stake;
        stake = 0;
        gameActive = false;

        emit GameCancelled(playerX);
    }

    function makeMove(uint _position) public {
        require(gameActive, "No active game");
        require(gameAccepted, "Game not accepted yet");
        require(!gameOver, "Game over");
        require(_position < 9, "Invalid position");
        require(board[_position] == Cell.Empty, "Cell already taken");
        require(xTurn ? msg.sender == playerX : msg.sender == playerO, "Not your turn");

        Cell piece = xTurn ? Cell.X : Cell.O;
        board[_position] = piece;
        lastMoveAt = uint64(block.timestamp);

        emit MoveMade(msg.sender, _position);

        if (checkWin()) {
            winner = msg.sender;
            gameOver = true;
            emit GameEnded(winner, false);
        } else if (checkDraw()) {
            winner = address(0);
            gameOver = true;
            emit GameEnded(winner, true);
        } else {
            xTurn = !xTurn;
        }
    }

    function claimForfeit() public {
        require(gameActive, "No active game");
        require(gameAccepted, "Game not accepted yet");
        require(!gameOver, "Game already over");
        require(block.timestamp > lastMoveAt + MOVE_TIMEOUT, "Timeout not reached");

        if (xTurn) {
            require(msg.sender == playerO, "Not your turn to claim");
        } else {
            require(msg.sender == playerX, "Not your turn to claim");
        }

        credits[msg.sender] += stake;
        gameOver = true;
        winner = msg.sender;

        emit ForfeitClaimed(msg.sender);
    }

    function withdraw() public {
        require(credits[msg.sender] > 0, "No credits");
        uint256 amount = credits[msg.sender];
        credits[msg.sender] = 0;
        (bool success, ) = payable(msg.sender).call{value: amount}("");
        require(success, "Transfer failed");
    }

    function _endGame(address _winner, bool isDraw) private {
        gameOver = true;
        winner = _winner;
        uint256 pot = stake;

        if (isDraw) {
            credits[playerX] += pot / 2;
            credits[playerO] += pot / 2;
        } else {
            credits[_winner] += pot;
        }

        stake = 0;
        gameActive = false;
        gameAccepted = false;
        acceptDeadline = 0;
        lastMoveAt = 0;

        emit GameEnded(winner, isDraw);
    }

    function _resetGame() private {
        for (uint i = 0; i < 9; i++) {
            board[i] = Cell.Empty;
        }
        gameAccepted = false;
        acceptDeadline = 0;
        lastMoveAt = 0;
    }

    function checkWin() private view returns (bool) {
        for (uint i = 0; i < 3; i++) {
            if (board[i*3] != Cell.Empty &&
                board[i*3] == board[i*3+1] &&
                board[i*3] == board[i*3+2]) {
                return true;
            }
        }

        for (uint i = 0; i < 3; i++) {
            if (board[i] != Cell.Empty &&
                board[i] == board[i+3] &&
                board[i] == board[i+6]) {
                return true;
            }
        }

        if (board[0] != Cell.Empty &&
            board[0] == board[4] &&
            board[0] == board[8]) {
            return true;
        }

        if (board[2] != Cell.Empty &&
            board[2] == board[4] &&
            board[2] == board[6]) {
            return true;
        }

        return false;
    }

    function checkDraw() private view returns (bool) {
        for (uint i = 0; i < 9; i++) {
            if (board[i] == Cell.Empty) {
                return false;
            }
        }
        return true;
    }
}