Logging Contract Activity

Events let your contract log important actions. Frontend apps can listen for these events.

What Are Events?

Events are logs stored on the blockchain that external apps can read.

They're much cheaper than storing data in state variables.

Declaring Events:

event GameStarted(address indexed playerX, address indexed playerO, uint stake);

The indexed keyword makes parameters searchable/filterable.

Emitting Events:

Use the emit keyword to trigger an event:

emit GameStarted(playerX, playerO, stake);

Your Task:

1. Declare two events at the top: GameStarted and GameEnded

2. Emit GameStarted at the end of startGame

3. Emit GameEnded when gameOver is set to true in makeMove

Add event logging

Requirements:

Declares GameStarted event

GameStarted has indexed playerX

GameStarted has indexed playerO

GameStarted has stake parameter

Declares GameEnded event

GameEnded has indexed winner

GameEnded has isDraw parameter

Emits GameStarted in startGame

Emits GameEnded when game ends

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

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