Unity 掷骰子后让玩家的棋子轮流移动

Question

我是 Unity 的新手，我一直在关注并结合教程中的示例，使用本教程中的 3d 骰子组合一个简单的棋盘游戏样演示：https://www.youtube.com/watch?v=LHQ4ynQhPLY 和使用本教程的棋盘游戏瓷砖设置：@ 987654322@ 以及本教程中的回合制系统：https://www.youtube.com/watch?v=W8ielU8iURI

虽然我有一个完全可用的 3D 骰子，并且我可以让我的棋子移动适当数量的空间，但我发现自己很难融入回合制方面。

我的项目文件可以在这里下载：https://drive.google.com/drive/folders/1Odj3iqeYAaO3lnkzGOjwyxIdL0g00Xge?usp=sharing

对于那些不愿意下载项目文件的人，我将在此处尝试详细说明：

我有六个主要脚本：Dice.cs、DiceSide.cs、ButtonHandler.cs、PlayerPiece.cs、Route.cs 和 GameControl.cs。

我排除了 DiceSide.cs，因为此代码没有损坏。它只是检测哪一边在地上，这样我就可以检测到另一边是骰子的值，它存储在下面代码中的 diceValue 变量中。

我还排除了 Route.cs，因为它也没有损坏。它根据“棋盘”游戏对象的子对象的位置定义玩家棋子的路径。

最后，我还排除了 ButtonHandler.cs，它只是一个简单的函数，它告诉按钮何时被单击以使用 Dice.cs 中的 RollDice() 函数掷骰子

Dice.cs（附加到“Die”预制件）：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Dice : MonoBehaviour
{
    Rigidbody rb;

    bool hasLanded;
    bool thrown;

    Vector3 initPosition;
    
    public int diceValue;

    public DiceSide[] diceSides;

    public bool IsDoneRolling;

    public int whosTurn = 1;


    // Start is called before the first frame update
    void Start()
    {
        rb = GetComponent<Rigidbody>();
        initPosition = transform.position;
        rb.useGravity = false;
    }

    // Update is called once per frame
    void Update()
    {
        if (rb.IsSleeping() && !hasLanded && thrown)
        {
            hasLanded = true;
            rb.useGravity = false;
            rb.isKinematic = true;

            SideValueCheck();

            if (whosTurn == 1)
            {
                GameControl.MovePlayer(1);
            } 
            else if (whosTurn == -1)
            {
                GameControl.MovePlayer(2);
            }
            whosTurn *= -1;
        }
        else if (rb.IsSleeping() && hasLanded && diceValue == 0)
        {
            RollAgain();
        }
    }

    public void RollDice() 
    {
        if (!thrown && !hasLanded)
        {
            IsDoneRolling = false;
            thrown = true;
            rb.useGravity = true;
            rb.AddTorque(Random.Range(0,250), Random.Range(0,250), Random.Range(0,250));
        }
        else if (thrown && hasLanded)
        {
            Reset();
        }
    }

    void Reset()
    {
        transform.position = initPosition;
        thrown = false;
        hasLanded = false;
        rb.useGravity = false;
        rb.isKinematic = false;
        IsDoneRolling = true;
    }

    void RollAgain()
    {
        Reset();
        IsDoneRolling = false;
        thrown = true;
        rb.useGravity = true;
        rb.AddTorque(Random.Range(0,250), Random.Range(0,250), Random.Range(0,250));
    }

    void SideValueCheck()
    {
        diceValue = 0;
        foreach (DiceSide side in diceSides)
        {
            if (side.OnGround())
            {
                diceValue = side.sideValue;
                Debug.Log(diceValue + " has been rolled!");
            }
        }
    }
}

PlayerPiece.cs（附加到两个玩家游戏对象预制件中的每一个）：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerPiece : MonoBehaviour
{
    public Route currentRoute;

    int routePosition;

    public bool isMoving;
    public bool moveAllowed;

    public static int steps = 0;

    // Update is called once per frame
    void Update()
    {
        if (!isMoving)
        {
            StartCoroutine(Move());
            moveAllowed = false;
        }
    }

    IEnumerator Move()
    {
        if (isMoving)
        {
            yield break;
        }
        isMoving = true;

        while (steps > 0)
        {
            Debug.Log("Route position: "+routePosition);
            
            routePosition++;
            routePosition %= currentRoute.childNodeList.Count;

            Vector3 nextPos = currentRoute.childNodeList[routePosition].position;
            while (MoveToNextNode(nextPos)) { yield return null; }

            yield return new WaitForSeconds(0.1f);
            steps--;
        }

        isMoving = false;
    }

    bool MoveToNextNode(Vector3 goal)
    {
        return goal != (transform.position = Vector3.MoveTowards(transform.position, goal, 8f * Time.deltaTime));
        
    }
}

GameControl.cs（附加到一个空的游戏对象）：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameControl : MonoBehaviour
{
    private static GameObject player1, player2;

    public static int diceSideThrown = 0;

    // Start is called before the first frame update
    void Start()
    {
        player1 = GameObject.Find("Player1-Piece");
        player2 = GameObject.Find("Player2-Piece");

        player1.GetComponent<PlayerPiece>().moveAllowed = false;
        player2.GetComponent<PlayerPiece>().moveAllowed = false;
    }

    // Update is called once per frame
    void Update()
    {
       if (player1.GetComponent<PlayerPiece>().moveAllowed)
        {
            //Move the player 1 piece... code in PlayerPiece.cs
        }


        if (player2.GetComponent<PlayerPiece>().moveAllowed)
        {
            //Move the player 2 piece... code in PlayerPiece.cs
        }
    }

   public static void MovePlayer(int playerToMove)
    {
        switch (playerToMove)
        {
            case 1:
                player1.GetComponent<PlayerPiece>().moveAllowed = true;
                break;

            case 2:
                player2.GetComponent<PlayerPiece>().moveAllowed = true;
                break;
        }
    }
}

所以应该发生的是我单击按钮，Dice.cs 中的 RollDice() 函数触发（工作），它掷骰子并生成玩家必须移动（工作）的空间值，然后只有玩家1 应该移动该数量的空格（不起作用，显然因为这部分在 GameControl.cs 中没有连接，但是 PlayerPiece.cs 中的移动代码在我的非回合测试中被证明可以工作）。玩家 1 完成移动后，单击相同的按钮应该掷骰子，重复这些步骤，但只有玩家 2 应该移动新生成的空格数。

我知道所有部件都在那里，但我不知道如何让它们组合在一起以按预期工作。

非常感谢您的帮助。

Answer 1

看起来您已经很接近了，只是需要填补一些空白，并进行一些清理/重组。

让我们从 Dice 脚本开始。 Dice 不应该关心轮到谁了，所以我们将从这里删除它并将它添加到 GameControl。我们将传递要移动的步数，而不是传递要移动的玩家。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Dice : MonoBehaviour
{
    Rigidbody rb;

    bool hasLanded;
    bool thrown;

    Vector3 initPosition;
    
    public int diceValue;

    public DiceSide[] diceSides;

    public bool IsDoneRolling;
    // Assign game object through editor
    public GameObject gameControllerGameObject; 
    private GameController gameController;


    // Start is called before the first frame update
    void Start()
    {
        rb = GetComponent<Rigidbody>();
        initPosition = transform.position;
        rb.useGravity = false;
    }
    void Awake()
    {
        gameController = gameControllerGameObject.GetComponent<GameController>();
    }

    // Update is called once per frame
    void Update()
    {
        if (rb.IsSleeping() && !hasLanded && thrown)
        {
            hasLanded = true;
            rb.useGravity = false;
            rb.isKinematic = true;

            SideValueCheck();
            
            gameControl.MovePlayer(diceValue);
            
        }
        else if (rb.IsSleeping() && hasLanded && diceValue == 0)
        {
            RollAgain();
        }
    }

    public void RollDice() 
    {
        if (!thrown && !hasLanded)
        {
            IsDoneRolling = false;
            thrown = true;
            rb.useGravity = true;
            rb.AddTorque(Random.Range(0,250), Random.Range(0,250), Random.Range(0,250));
        }
        else if (thrown && hasLanded)
        {
            Reset();
        }
    }

    void Reset()
    {
        transform.position = initPosition;
        thrown = false;
        hasLanded = false;
        rb.useGravity = false;
        rb.isKinematic = false;
        IsDoneRolling = true;
    }

    void RollAgain()
    {
        Reset();
        IsDoneRolling = false;
        thrown = true;
        rb.useGravity = true;
        rb.AddTorque(Random.Range(0,250), Random.Range(0,250), Random.Range(0,250));
    }

    void SideValueCheck()
    {
        diceValue = 0;
        foreach (DiceSide side in diceSides)
        {
            if (side.OnGround())
            {
                diceValue = side.sideValue;
                Debug.Log(diceValue + " has been rolled!");
            }
        }
    }
}

接下来我们来看看 PlayerPiece。将步骤作为参数添加到 Move，以便我们可以使用要移动的步骤数来调用它，并清理一些我们不需要的变量，以及从 Update 中取出逻辑，以便我们可以直接从 GameControl 调用 Move

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerPiece : MonoBehaviour
{
    public Route currentRoute;

    int routePosition;

    // Remove unnecessary variables
    public bool isMoving;

    // Update is called once per frame
    void Update()
    {
        
    }
    // Make this public so we can call it from GameControl
    // Add number of steps to move as parameter
    public IEnumerator Move(int steps)
    {
        if (isMoving)
        {
            yield break;
        }
        isMoving = true;

        while (steps > 0)
        {
            Debug.Log("Route position: "+routePosition);
            
            routePosition++;
            routePosition %= currentRoute.childNodeList.Count;

            Vector3 nextPos = currentRoute.childNodeList[routePosition].position;
            while (MoveToNextNode(nextPos)) { yield return null; }

            yield return new WaitForSeconds(0.1f);
            steps--;
        }

        isMoving = false;
    }

    bool MoveToNextNode(Vector3 goal)
    {
        return goal != (transform.position = Vector3.MoveTowards(transform.position, goal, 8f * Time.deltaTime));
        
    }
}

最后，GameControl 将它们结合在一起。添加对 PlayerPiece 脚本的引用，这样您就不会在每次要调用方法或变量时都检索它们。最好在“清醒”而不是“开始”中这样做，以确保他们准备好了。添加 whosTurn 以便 GameControl 可以跟踪它。在轮到的玩家棋子上调用 Move()，并将步数传递给它。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameControl : MonoBehaviour
{
    // Be careful about using static variables when they're not necessary
    private GameObject player1, player2;
    // Add references to the player piece scripts
    private PlayerPiece player1Piece;
    private PlayerPiece player2Piece;

    private whosTurn = 1;

    // Start is called before the first frame update
    void Awake()
    {
        player1 = GameObject.Find("Player1-Piece");
        player2 = GameObject.Find("Player2-Piece");

        // Set the reference to the script so you don't have to call GetComponent() each time
        player1Piece = player1.GetComponent<PlayerPiece>();
        player2Piece = player2.GetComponent<PlayerPiece>();
    }

    // Update is called once per frame
    void Update()
    {
       // Clean this out and we'll handle movement directly in the PlayerMove
    }
   // Change variable to handle steps to move
   public void MovePlayer(int steps)
    {
        switch (whosTurn)
        {
            case 1:
                StartCoroutine(player1Piece.Move(steps));
                break;

            case 2:
                StartCoroutine(player2Piece.Move(steps));
                break;
        }

        whosTurn *= -1;
    }
}

我认为这应该让一切都...动起来...我没有测试过这段代码，所以如果您遇到任何问题，请告诉我