Добавлена обработка ESC для отмены выделения ячейки; реализована логика определения первого хода через стартовые кости

Author: nicknotknack

packages/foundry/contracts/Backgammon.sol

@@ -29,9 +29,16 @@ contract Backgammon {
     address public whitePlayer; // First player (white)
     address public blackPlayer; // Second player (black)
     uint256 public stakeAmount; // Amount each player must stake
-    bool public gameStarted; // True when both players have staked
+    bool public gameStarted; // True when both players have staked (but game not active yet)
+    bool public gameActive; // True when first turn is determined and game can begin
     bool public fundsWithdrawn; // True when winner has withdrawn funds
 
+    // Start dice rolls to determine first turn
+    uint256 public whiteStartDice; // White player's start dice roll (1-6)
+    uint256 public blackStartDice; // Black player's start dice roll (1-6)
+    bool public whiteStartDiceRolled; // True when white player rolled start dice
+    bool public blackStartDiceRolled; // True when black player rolled start dice
+
     event WhiteTurn(uint256 _from, uint256 _to);
     event BlackTurn(uint256 _from, uint256 _to);
     event DiceRolled(bool isBlack, uint256 dice1, uint256 dice2);
@@ -44,6 +51,8 @@ contract Backgammon {
         uint256 stakeAmount
     );
     event FundsWithdrawn(address winner, uint256 amount);
+    event StartDiceRolled(address player, uint256 dice);
+    event FirstTurnDetermined(bool isBlackTurn, uint256 dice1, uint256 dice2);
 
     constructor() payable {
         // black: [0,0,0,0,0,5,0,3,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,2]
@@ -71,9 +80,18 @@ contract Backgammon {
         _;
     }
 
-    // Modifier to check if game has started (both players staked)
-    modifier gameHasStarted() {
-        require(gameStarted, "Game has not started yet");
+    // Modifier to check if game is active (first turn determined)
+    modifier gameIsActive() {
+        require(
+            gameActive,
+            "Game is not active yet. Determine first turn first."
+        );
+        _;
+    }
+
+    // Modifier to check if both players have staked
+    modifier bothPlayersStaked() {
+        require(gameStarted, "Both players must stake first");
         _;
     }
 
@@ -104,7 +122,12 @@ contract Backgammon {
         );
         require(msg.sender != whitePlayer, "Cannot play against yourself");
         blackPlayer = msg.sender;
-        gameStarted = true;
+        gameStarted = true; // Both players staked, but game not active yet
+        // Reset start dice flags
+        whiteStartDiceRolled = false;
+        blackStartDiceRolled = false;
+        whiteStartDice = 0;
+        blackStartDice = 0;
         emit StakeDeposited(msg.sender, msg.value);
         emit GameStarted(whitePlayer, blackPlayer, stakeAmount);
     }
@@ -167,20 +190,143 @@ contract Backgammon {
             address _blackPlayer,
             uint256 _stakeAmount,
             bool _gameStarted,
+            bool _gameActive,
             uint8 _winner,
             bool _fundsWithdrawn,
-            uint256 _balance
+            uint256 _balance,
+            uint256 _whiteStartDice,
+            uint256 _blackStartDice,
+            bool _whiteStartDiceRolled,
+            bool _blackStartDiceRolled
         )
     {
         return (
             whitePlayer,
             blackPlayer,
             stakeAmount,
             gameStarted,
+            gameActive,
             winner,
             fundsWithdrawn,
-            address(this).balance
+            address(this).balance,
+            whiteStartDice,
+            blackStartDice,
+            whiteStartDiceRolled,
+            blackStartDiceRolled
+        );
+    }
+
+    // Roll start dice for black player (second player rolls first)
+    function rollStartDiceBlack() public bothPlayersStaked returns (uint256) {
+        require(!gameActive, "Game already active");
+        require(
+            msg.sender == blackPlayer,
+            "Only black player can roll start dice"
+        );
+        require(
+            !blackStartDiceRolled,
+            "Black player already rolled start dice"
+        );
+
+        // Generate random dice value (1-6)
+        uint256 seed = uint256(
+            keccak256(
+                abi.encodePacked(
+                    block.timestamp,
+                    block.prevrandao,
+                    blockhash(block.number - 1),
+                    msg.sender
+                )
+            )
+        );
+        uint256 dice = (seed % 6) + 1;
+
+        blackStartDice = dice;
+        blackStartDiceRolled = true;
+        emit StartDiceRolled(msg.sender, dice);
+
+        // If white already rolled, determine first turn
+        if (whiteStartDiceRolled) {
+            _determineFirstTurn();
+        }
+
+        return dice;
+    }
+
+    // Roll start dice for white player (first player rolls second)
+    function rollStartDiceWhite() public bothPlayersStaked returns (uint256) {
+        require(!gameActive, "Game already active");
+        require(
+            msg.sender == whitePlayer,
+            "Only white player can roll start dice"
         );
+        require(
+            !whiteStartDiceRolled,
+            "White player already rolled start dice"
+        );
+        require(blackStartDiceRolled, "Black player must roll first");
+
+        // Generate random dice value (1-6)
+        uint256 seed = uint256(
+            keccak256(
+                abi.encodePacked(
+                    block.timestamp,
+                    block.prevrandao,
+                    blockhash(block.number - 1),
+                    msg.sender
+                )
+            )
+        );
+        uint256 dice = (seed % 6) + 1;
+
+        whiteStartDice = dice;
+        whiteStartDiceRolled = true;
+        emit StartDiceRolled(msg.sender, dice);
+
+        // Determine first turn
+        _determineFirstTurn();
+
+        return dice;
+    }
+
+    // Internal function to determine first turn based on start dice rolls
+    function _determineFirstTurn() internal {
+        require(
+            whiteStartDiceRolled && blackStartDiceRolled,
+            "Both players must roll start dice"
+        );
+
+        // If dice are equal, reset and require re-roll
+        if (whiteStartDice == blackStartDice) {
+            whiteStartDiceRolled = false;
+            blackStartDiceRolled = false;
+            whiteStartDice = 0;
+            blackStartDice = 0;
+            return; // Players need to roll again
+        }
+
+        // Determine who goes first (higher dice wins)
+        if (blackStartDice > whiteStartDice) {
+            // Black goes first
+            isItBlackTurn = true;
+            // Set initial dice combination for first turn (use the two dice values)
+            blackMovesCount = 2;
+            blackAvailableMoves[0] = blackStartDice;
+            blackAvailableMoves[1] = whiteStartDice;
+            blackDiceRolled = true;
+        } else {
+            // White goes first
+            isItBlackTurn = false;
+            // Set initial dice combination for first turn (use the two dice values)
+            whiteMovesCount = 2;
+            whiteAvailableMoves[0] = whiteStartDice;
+            whiteAvailableMoves[1] = blackStartDice;
+            whiteDiceRolled = true;
+        }
+
+        // Activate the game
+        gameActive = true;
+        emit FirstTurnDetermined(isItBlackTurn, whiteStartDice, blackStartDice);
     }
 
     // Check for win condition and set winner if game is won
@@ -229,7 +375,7 @@ contract Backgammon {
     function rollDiceWhite()
         public
         gameNotFinished
-        gameHasStarted
+        gameIsActive
         returns (uint256 dice1, uint256 dice2)
     {
         require(!isItBlackTurn, "Is Black Turn");
@@ -279,7 +425,7 @@ contract Backgammon {
     function moveWhite(
         uint256 _from,
         uint256 _to
-    ) public gameNotFinished gameHasStarted {
+    ) public gameNotFinished gameIsActive {
         require(!isItBlackTurn, "Is Black Turn");
         require(msg.sender == whitePlayer, "Only white player can move");
         require(whiteDiceRolled, "Must roll dice before making a move");
@@ -541,7 +687,7 @@ contract Backgammon {
     function rollDiceBlack()
         public
         gameNotFinished
-        gameHasStarted
+        gameIsActive
         returns (uint256 dice1, uint256 dice2)
     {
         require(isItBlackTurn, "Is White Turn");
@@ -591,7 +737,7 @@ contract Backgammon {
     function moveBlack(
         uint256 _from,
         uint256 _to
-    ) public gameNotFinished gameHasStarted {
+    ) public gameNotFinished gameIsActive {
         require(isItBlackTurn, "Is White Turn");
         require(msg.sender == blackPlayer, "Only black player can move");
         require(blackDiceRolled, "Must roll dice before making a move");

packages/foundry/scripts-js/sendStake.js

@@ -6,44 +6,44 @@ import { foundry } from "viem/chains";
 const PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
 
 async function main() {
-  const account = privateKeyToAccount(PRIVATE_KEY);
-  
-  const client = createWalletClient({
-    account,
-    chain: foundry,
-    transport: http("http://localhost:8545"),
-  });
-
-  const contractAddress = "0x19A1c09fE3399C4Daaa2C98b936a8E460fC5Eaa4";
-  const amount = parseEther("0.00000000000001");
-
-  console.log(`Sending ${amount.toString()} wei to contract ${contractAddress}...`);
-  console.log(`From account: ${account.address}`);
-
-  try {
-    const hash = await client.sendTransaction({
-      to: contractAddress,
-      value: amount,
+    const account = privateKeyToAccount(PRIVATE_KEY);
+
+    const client = createWalletClient({
+        account,
+        chain: foundry,
+        transport: http("http://localhost:8545"),
     });
 
-    console.log(`Transaction hash: ${hash}`);
-    console.log(`Waiting for confirmation...`);
-    
-    // Wait a bit for the transaction to be mined
-    await new Promise(resolve => setTimeout(resolve, 2000));
-    
-    console.log("Transaction sent successfully!");
-    console.log(`Check the contract at: ${contractAddress}`);
-  } catch (error) {
-    console.error("Error sending transaction:", error);
-    process.exit(1);
-  }
+    const contractAddress = "0x19A1c09fE3399C4Daaa2C98b936a8E460fC5Eaa4";
+    const amount = parseEther("0.00000000000001");
+
+    console.log(`Sending ${amount.toString()} wei to contract ${contractAddress}...`);
+    console.log(`From account: ${account.address}`);
+
+    try {
+        const hash = await client.sendTransaction({
+            to: contractAddress,
+            value: amount,
+        });
+
+        console.log(`Transaction hash: ${hash}`);
+        console.log(`Waiting for confirmation...`);
+
+        // Wait a bit for the transaction to be mined
+        await new Promise(resolve => setTimeout(resolve, 2000));
+
+        console.log("Transaction sent successfully!");
+        console.log(`Check the contract at: ${contractAddress}`);
+    } catch (error) {
+        console.error("Error sending transaction:", error);
+        process.exit(1);
+    }
 }
 
 main()
-  .then(() => process.exit(0))
-  .catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
+    .then(() => process.exit(0))
+    .catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });