Lifecycle Guards

Now tighten the rules around when each function can run.

Contract Lifecycle:
The advanced contract has more states than the early lessons:
• No active game
• Game created, waiting for acceptance
• Accepted game, waiting for moves
• Finished game, waiting for withdrawals
Guard the Transitions:
A zero-stake game should not start. An accepted game should not be accepted again. Moves and forfeits should only happen after both players have committed.

Existing Helpers Stay Put:
Keep using checkWin() , checkDraw() , _endGame() , and _resetGame() . This lesson is about missing lifecycle checks, not rewriting win detection.

Your task: Add the missing require checks so every public gameplay function can only run in the correct lifecycle state.

Tighten lifecycle guard rules

13%

Requirements:

startGame rejects zero stake

acceptGame requires active game

acceptGame rejects duplicate acceptance

makeMove requires active game

makeMove requires accepted game

claimForfeit requires active game

claimForfeit requires accepted game

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(!gameActive, "Game already active");
        require(_opponent != address(0), "Invalid opponent");
        require(_opponent != msg.sender, "Cannot play yourself");
        // Require a non-zero stake before setting up the game.

        _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 an active game that has not already been accepted.
        require(!gameOver, "Game already over");
        require(msg.value == stake, "Must match stake");
        require(msg.sender == playerO, "Only opponent can accept");
        require(block.timestamp <= acceptDeadline, "Accept period expired");

        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 an active, accepted game before validating the move.
        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()) {
            _endGame(msg.sender, false);
        } else if (checkDraw()) {
            _endGame(address(0), true);
        } else {
            xTurn = !xTurn;
        }
    }

    function claimForfeit() public {
        // Require an active, accepted game before checking timeout.
        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");
        }

        _endGame(msg.sender, false);

        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;
        emit GameEnded(winner, isDraw);
        _resetGame();
    }

    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;
    }
}