State Management

We need to track the game's lifecycle to prevent issues like starting multiple games at once.

Game State Variables:

We'll add variables to track where we are in the game lifecycle:

bool public gameActive; - Is a game currently in progress?

bool public gameAccepted; - Has player O accepted the game?

Deadline Tracking:

We need to track when timeouts expire:

uint64 public acceptDeadline; - When does the accept period end?

uint64 public lastMoveAt; - When was the last move made?

Using in startGame:

First, check no active game: require(!gameActive, "Game already active");

Then set flags: gameActive = true; and gameAccepted = false;

Add these state variables and update startGame to use them.

Add game lifecycle tracking

Requirements:

Declares bool public gameActive

Declares bool public gameAccepted

Declares uint64 public acceptDeadline

Declares uint64 public lastMoveAt

Checks !gameActive in startGame

Sets gameActive = true

Sets gameAccepted = false

Check before state changes

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

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

    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;

    function startGame(address _opponent) public payable {
        require(_opponent != address(0), "Invalid opponent");
        require(_opponent != msg.sender, "Cannot play yourself");

        playerX = msg.sender;
        playerO = _opponent;
        xTurn = true;
        gameOver = false;
        winner = address(0);
        stake = msg.value;

        for (uint i = 0; i < 9; i++) {
            board[i] = Cell.Empty;
        }
    }

    function makeMove(uint _position) public {
        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;

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

    function checkWin() private view returns (bool) {
        // Check rows
        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;
            }
        }

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

        // Check diagonals
        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;
    }
}