Working with Time

Smart contracts can access the current time using block.timestamp.

What is block.timestamp?

block.timestamp returns the current Unix timestamp (seconds since Jan 1, 1970).

It's set by the miner when they create the block.

Casting to uint64:

block.timestamp returns a uint256, but we use uint64 for storage efficiency.

Cast it like this: uint64(block.timestamp)

Setting Deadlines:

In startGame, set the accept deadline:

acceptDeadline = uint64(block.timestamp) + ACCEPT_TIMEOUT;

In makeMove, update the last move time:

lastMoveAt = uint64(block.timestamp);

Add timestamp tracking to startGame and makeMove.

Add timestamp tracking

Requirements:

Sets acceptDeadline in startGame

Uses block.timestamp for acceptDeadline

Casts timestamp to uint64

Adds ACCEPT_TIMEOUT to deadline

Sets lastMoveAt in makeMove

lastMoveAt uses block.timestamp

lastMoveAt casts to uint64

// 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 GameEnded(address indexed winner, bool isDraw);

    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;

    function startGame(address _opponent) public payable {
        require(!gameActive, "Game already active");
        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;
        gameActive = true;
        gameAccepted = false;

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

        emit GameStarted(playerX, playerO, stake);
    }

    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;
            emit GameEnded(winner, false);
        } else if (checkDraw()) {
            winner = address(0);
            gameOver = true;
            emit GameEnded(winner, 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;
    }
}