Unity做一个魔方

最新推荐文章于 2024-03-11 14:49:48 发布
最新推荐文章于 2024-03-11 14:49:48 发布
阅读量3.1k 收藏 23
点赞数 6
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OneWord233/article/details/89306531
版权

最近项目周期变得平稳，不再像之前那么忙了，所以抽空写了个魔方小游戏，在这里跟大家分享。

游戏原理并不复杂，在场景中，我们放了27个Cube，和6个面的触发器，根据触发器的Enter检测和Exit检测，确定对应面的子物体，使得触发器底下的9个Cube能同时转动，同时，再设置X，Y，Z三个轴向的整体转动，子物体是固定的27个Cube。

有了思路以后，我们来做场景，做完场景以后，画面大概是这样：

在FrontContent及以下5个物体中，我们要挂靠BoxCollider,和Rigibody组件，如图：

接下来，我们来写脚本，因为总体逻辑并不复杂，所以主逻辑只写了了一个GameController脚本，另外还有6个触发器脚本，以下是代码：

GameController.cs

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

public class GameController : MonoBehaviour {

    public static GameController Instance;

    public enum Axis {//旋转轴
        X = 1,
        Y = 2,
        Z = 3
    }

    public enum RotateModel {//旋转模式
        Forward = 90,
        Back = -90
    }

    public enum Direction {//旋转方位
        First = -90,
        Second = -180,
        Third = 90,
        Fourth = 0
    }

    private Direction cubeDirF;//F面转向
    private Direction cubeDirB;//B面转向
    private Direction cubeDirU;//U面转向
    private Direction cubeDirD;//D面转向
    private Direction cubeDirL;//L面转向
    private Direction cubeDirR;//R面转向
    private Direction cubeDirWholeX;//整体转向
    private Direction cubeDirWholeY;
    private Direction cubeDirWholeZ;

    private const float rotateSpeed = 150f;//旋转速度

    private Quaternion targetRotationF;//旋转角度
    private Quaternion targetRotationB;
    private Quaternion targetRotationU;
    private Quaternion targetRotationD;
    private Quaternion targetRotationL;
    private Quaternion targetRotationR;
    private Quaternion targetRotationWholeX;
    private Quaternion targetRotationWholeY;
    private Quaternion targetRotationWholeZ;

    private int targetFZ = 0;//旋转轴度数
    private int targetBZ = 0;
    private int targetUY = 0;
    private int targetDY = 0;
    private int targetLX = 0;
    private int targetRX = 0;
    private int targetWholeX = 0;
    private int targetWholeY = 0;
    private int targetWholeZ = 0;

    public Button FButton;
    public Button FAntiButton;
    public Button BButton;
    public Button BAntiButton;
    public Button UButton;
    public Button UAntiButton;
    public Button DButton;
    public Button DAntiButton;
    public Button LButton;
    public Button LAntiButton;
    public Button RButton;
    public Button RAntiButton;
    public Button XButton;
    public Button XAntiButton;
    public Button YButton;
    public Button YAntiButton;
    public Button ZButton;
    public Button ZAntiButton;

    public GameObject FrontContent;//旋转父物体
    public GameObject BackContent;
    public GameObject UpContent;
    public GameObject DownContent;
    public GameObject LeftContent;
    public GameObject RightContent;
    public GameObject WholeXContent;
    public GameObject WholeYContent;
    public GameObject WholeZContent;
    private GameObject prevContent;//上一个转动的模块

    public List<GameObject> FrontObjList;//旋转面方块集合
    public List<GameObject> BackObjList;
    public List<GameObject> UpObjList;
    public List<GameObject> DownObjList;
    public List<GameObject> LeftObjList;
    public List<GameObject> RightObjList;
    public List<GameObject> WholeObjList; 

    private bool isFrontClockwise = false;//旋转判断条件
    private bool isFrontAntiClockwise = false;
    private bool isBackClockwise = false;
    private bool isBackAntiClockwise = false;
    private bool isUpClockwise = false;
    private bool isUpAntiClockwise = false;
    private bool isDownClockwise = false;
    private bool isDownAntiClockwise = false;
    private bool isLeftClockwise = false;
    private bool isLeftAntiClockwise = false;
    private bool isRightClockwise = false;
    private bool isRightAntiClockwise = false;
    private bool isXClockwise = false;
    private bool isXAntiClockwise = false;
    private bool isYClockwise = false;
    private bool isYAntiClockwise = false;
    private bool isZClockwise = false;
    private bool isZAntiClockwise = false;
    private bool isPlaying = false;//正在旋转

    void Awake()
    {
        Instance = this;
    }

    void Start () {
        FButton.onClick.AddListener(OnClickFBtn);
        FAntiButton.onClick.AddListener(OnClickFAntiBtn);
        BButton.onClick.AddListener(OnClickBBtn);
        BAntiButton.onClick.AddListener(OnClickBAntiBtn);
        UButton.onClick.AddListener(OnClickUBtn);
        UAntiButton.onClick.AddListener(OnClickUAntiBtn);
        DButton.onClick.AddListener(OnClickDBtn);
        DAntiButton.onClick.AddListener(OnClickDAntiBtn);
        LButton.onClick.AddListener(OnClickLBtn);
        LAntiButton.onClick.AddListener(OnClickLAntiBtn);
        RButton.onClick.AddListener(OnClickRBtn);
        RAntiButton.onClick.AddListener(OnClickRAntiBtn);

        XButton.onClick.AddListener(OnClickXBtn);
        XAntiButton.onClick.AddListener(OnClickXAntiBtn);
        YButton.onClick.AddListener(OnClickYBtn);
        YAntiButton.onClick.AddListener(OnClickYAntiBtn);
        ZButton.onClick.AddListener(OnClickZBtn);
        ZAntiButton.onClick.AddListener(OnClickZAntiBtn);
    }

    void Update () {
        UpdateFrontClockwise();
        UpdateFrontAntiClockwise();
        UpdateBackClockwise();
        UpdateBackAntiClosewise();
        UpdateUpClockwise();
        UpdateUpAntiClockwise();
        UpdateDownClockwise();
        UpdateDownAntiClockwise();
        UpdateLeftClockwise();
        UpdateLeftAntiClockwise();
        UpdateRightClockwise();
        UpdateRightAntiClockwise();

        UpdateXAxisClockwise();
        UpdateXAxisAntiClockwise();
        UpdateYAxisClockwise();
        UpdateYAxisAntiClockwise();
        UpdateZAxisClockwise();
        UpdateZAxisAntiClockwise();
    }

    public void OnClickFBtn()//点击F按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.Z, ref FrontContent, ref FrontObjList, ref targetFZ, ref cubeDirF, ref targetRotationF, ref isFrontClockwise);
    }

    public void OnClickFAntiBtn()//点击F'按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.Z, ref FrontContent, ref FrontObjList, ref targetFZ, ref cubeDirF, ref targetRotationF, ref isFrontAntiClockwise);
    }

    private void UpdateFrontClockwise()//F面正向旋转
    {
        UpdateRotateZEvent(Vector3.back, cubeDirF, targetRotationF, RotateModel.Back, ref FrontContent, ref isFrontClockwise, ref isFrontAntiClockwise);
    }

    private void UpdateFrontAntiClockwise()//F面反向旋转
    {
        UpdateRotateZEvent(Vector3.forward, cubeDirF, targetRotationF, RotateModel.Forward, ref FrontContent, ref isFrontAntiClockwise, ref isFrontClockwise);
    }

    public void OnClickBBtn()//点击B按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.Z, ref BackContent, ref BackObjList,ref targetBZ, ref cubeDirB, ref targetRotationB, ref isBackClockwise);
    }

    public void OnClickBAntiBtn()//点击B'按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.Z, ref BackContent, ref BackObjList, ref targetBZ, ref cubeDirB, ref targetRotationB, ref isBackAntiClockwise);
    }

    public void UpdateBackClockwise()//B面正向旋转
    {
        UpdateRotateZEvent(Vector3.forward, cubeDirB, targetRotationB, RotateModel.Forward, ref BackContent,ref isBackClockwise,ref isBackAntiClockwise);
    }

    public void UpdateBackAntiClosewise()//B面反向旋转
    {
        UpdateRotateZEvent(Vector3.back, cubeDirB, targetRotationB, RotateModel.Back, ref BackContent, ref isBackAntiClockwise, ref isBackClockwise);
    }

    public void OnClickUBtn()//点击U按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.Y, ref UpContent, ref UpObjList, ref targetUY, ref cubeDirU, ref targetRotationU, ref isUpClockwise);
    }

    public void OnClickUAntiBtn()//点击U'按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.Y, ref UpContent, ref UpObjList, ref targetUY, ref cubeDirU, ref targetRotationU, ref isUpAntiClockwise);
    }

    public void UpdateUpClockwise()//U面正向旋转
    {
        UpdateRotateYEvent(Vector3.up, cubeDirU, targetRotationU, RotateModel.Forward, ref UpContent, ref isUpClockwise, ref isUpAntiClockwise);
    }

    public void UpdateUpAntiClockwise()//U面反向旋转
    {
        UpdateRotateYEvent(Vector3.down, cubeDirU, targetRotationU, RotateModel.Back, ref UpContent, ref isUpAntiClockwise, ref isUpClockwise);
    }

    public void OnClickDBtn()//点击D按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.Y, ref DownContent, ref DownObjList, ref targetDY, ref cubeDirD, ref targetRotationD, ref isDownClockwise);
    }

    public void OnClickDAntiBtn()//点击D'按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.Y, ref DownContent, ref DownObjList, ref targetDY, ref cubeDirD, ref targetRotationD, ref isDownAntiClockwise);
    }

    public void UpdateDownClockwise()//D面正向旋转
    {
        UpdateRotateYEvent(Vector3.down, cubeDirD, targetRotationD, RotateModel.Back, ref DownContent, ref isDownClockwise, ref isDownAntiClockwise);
    }

    public void UpdateDownAntiClockwise()//D面反向旋转
    {
        UpdateRotateYEvent(Vector3.up, cubeDirD, targetRotationD, RotateModel.Forward, ref DownContent, ref isDownAntiClockwise, ref isDownClockwise);
    }

    public void OnClickLBtn()//点击L按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.X, ref LeftContent, ref LeftObjList, ref targetLX, ref cubeDirL, ref targetRotationL, ref isLeftClockwise);
    }

    public void OnClickLAntiBtn()//点击L'按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.X, ref LeftContent, ref LeftObjList, ref targetLX, ref cubeDirL, ref targetRotationL, ref isLeftAntiClockwise);
    }

    public void UpdateLeftClockwise()//L面正向旋转
    {
        UpdateRotateXEvent(Vector3.left, cubeDirL, targetRotationL, RotateModel.Back, ref LeftContent, ref isLeftClockwise, ref isLeftAntiClockwise);
    }

    public void UpdateLeftAntiClockwise()//L面反向旋转
    {
        UpdateRotateXEvent(Vector3.right, cubeDirL, targetRotationL, RotateModel.Forward, ref LeftContent, ref isLeftAntiClockwise, ref isLeftClockwise);
    }

    public void OnClickRBtn()//点击R按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.X, ref RightContent, ref RightObjList, ref targetRX, ref cubeDirR, ref targetRotationR, ref isRightClockwise);
    }

    public void OnClickRAntiBtn()//点击R'按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.X, ref RightContent, ref RightObjList, ref targetRX, ref cubeDirR, ref targetRotationR, ref isRightAntiClockwise);
    }

    public void UpdateRightClockwise()//R面正向旋转
    {
        UpdateRotateXEvent(Vector3.right, cubeDirR, targetRotationR, RotateModel.Forward, ref RightContent, ref isRightClockwise, ref isRightAntiClockwise);
    }

    public void UpdateRightAntiClockwise()//R面反向旋转
    {
        UpdateRotateXEvent(Vector3.left, cubeDirR, targetRotationR, RotateModel.Back, ref RightContent, ref isRightAntiClockwise, ref isRightClockwise);
    }

    public void OnClickXBtn()//点击X按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.X, ref WholeXContent, ref WholeObjList, ref targetWholeX, ref cubeDirWholeX, ref targetRotationWholeX, ref isXClockwise);
    }

    public void OnClickXAntiBtn()//点击X'按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.X, ref WholeXContent, ref WholeObjList, ref targetWholeX, ref cubeDirWholeX, ref targetRotationWholeX, ref isXAntiClockwise);
    }

    public void UpdateXAxisClockwise()//X轴正向旋转
    {
        UpdateRotateXEvent(Vector3.right, cubeDirWholeX, targetRotationWholeX, RotateModel.Forward, ref WholeXContent, ref isXClockwise, ref isXAntiClockwise);
    }

    public void UpdateXAxisAntiClockwise()//X轴反向旋转
    {
        UpdateRotateXEvent(Vector3.left, cubeDirWholeX, targetRotationWholeX, RotateModel.Back, ref WholeXContent, ref isXAntiClockwise, ref isXClockwise);
    }

    public void OnClickYBtn()//点击Y按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.Y, ref WholeYContent, ref WholeObjList, ref targetWholeY, ref cubeDirWholeY, ref targetRotationWholeY, ref isYClockwise);
    }

    public void OnClickYAntiBtn()//点击Y'按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.Y, ref WholeYContent, ref WholeObjList, ref targetWholeY, ref cubeDirWholeY, ref targetRotationWholeY, ref isYAntiClockwise);
    }

    public void UpdateYAxisClockwise()//Y轴正向旋转
    {
        UpdateRotateYEvent(Vector3.up, cubeDirWholeY, targetRotationWholeY, RotateModel.Forward, ref WholeYContent, ref isYClockwise, ref isYAntiClockwise);
    }

    public void UpdateYAxisAntiClockwise()//Y轴反向旋转
    {
        UpdateRotateYEvent(Vector3.down, cubeDirWholeY, targetRotationWholeY, RotateModel.Back, ref WholeYContent, ref isYAntiClockwise, ref isYClockwise);
    }
    public void OnClickZBtn()//点击Z按钮
    {
        ClickBtnEvent(RotateModel.Forward, Axis.Z, ref WholeZContent, ref WholeObjList, ref targetWholeZ, ref cubeDirWholeZ, ref targetRotationWholeZ, ref isZClockwise);
    }

    public void OnClickZAntiBtn()//点击Z'按钮
    {
        ClickBtnEvent(RotateModel.Back, Axis.Z, ref WholeZContent, ref WholeObjList, ref targetWholeZ, ref cubeDirWholeZ, ref targetRotationWholeZ, ref isZAntiClockwise);
    }

    public void UpdateZAxisClockwise()//Z轴正向旋转
    {
        UpdateRotateZEvent(Vector3.forward, cubeDirWholeZ, targetRotationWholeZ, RotateModel.Forward, ref WholeZContent, ref isZClockwise, ref isZAntiClockwise);
    }

    public void UpdateZAxisAntiClockwise()//Z轴反向旋转
    {
        UpdateRotateZEvent(Vector3.back, cubeDirWholeZ, targetRotationWholeZ, RotateModel.Back, ref WholeZContent, ref isZAntiClockwise, ref isZClockwise);
    }

    //封装点击事件
    public void ClickBtnEvent(RotateModel model, Axis axis, ref GameObject nowContent,ref List<GameObject> objList,ref int targetDegree,ref Direction cubeDir,ref Quaternion targetRotation,ref bool isRotateStart)
    {
        if (isPlaying)
            return;
        foreach (GameObject cubeObj in objList)
        {
            cubeObj.transform.SetParent(nowContent.transform);
        }
        
        targetDegree += (int)model;
        int index = targetDegree % 360;
        if (index == -270)
            index = 90;
        if (index == 270)
            index = -90;
        if (index == 180)
            index = -180;
        //Debug.Log("Dir:" + cubeDir);
        cubeDir = (Direction)index;
        switch (axis)
        {
            case Axis.X:
                targetRotation = Quaternion.Euler((float)cubeDir, 0, 0);
                break;
            case Axis.Y:
                targetRotation = Quaternion.Euler(0, (float)cubeDir, 0);
                break;
            case Axis.Z:
                targetRotation = Quaternion.Euler(0, 0, (float)cubeDir);
                break;
            default:
                break;
        }
        if (nowContent.GetComponent<Rigidbody>() != null)
            Destroy(nowContent.GetComponent<Rigidbody>());
        isRotateStart = true;
        prevContent = nowContent;
    }

    //魔方旋转(x轴)
    public void UpdateRotateXEvent(Vector3 rotateDir, Direction cubeDir, Quaternion targetRotation, RotateModel model, ref GameObject nowContent, ref bool isRotateStart, ref bool isRotateAntiStart)
    {
        if (isRotateStart)
        {
            isPlaying = isRotateStart;
            nowContent.transform.Rotate(rotateDir * Time.deltaTime * rotateSpeed);
            //Debug.Log("X:" + nowContent.transform.localRotation.x);
            //Debug.Log("X2:" + targetRotation.x);
            bool isBreak = false;

            switch (model)
            {
                case RotateModel.Forward:
                    {
                        switch (cubeDir)
                        {
                            case Direction.First:
                                {
                                    if (nowContent.transform.localRotation.x >= targetRotation.x)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Second:
                                {
                                    if (nowContent.transform.localRotation.x >= -targetRotation.x - 0.0001f)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Third:
                                {
                                    if (nowContent.transform.localRotation.x >= targetRotation.x)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Fourth:
                                {
                                    if (nowContent.transform.localRotation.x >= targetRotation.x)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                        }
                    }
                    break;
                case RotateModel.Back:
                    {
                        switch (cubeDir)
                        {
                            case Direction.First:
                                {
                                    if (nowContent.transform.localRotation.x <= targetRotation.x)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Second:
                                {
                                    if (nowContent.transform.localRotation.x <= targetRotation.x + 0.0001f)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Third:
                                {
                                    if (nowContent.transform.localRotation.x >= -targetRotation.x)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Fourth:
                                {
                                    if (nowContent.transform.localRotation.x <= targetRotation.x)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                        }
                    }
                    break;
            }

            if (isBreak)
            {
                nowContent.transform.localRotation = targetRotation;
                isRotateStart = false;
                isRotateAntiStart = false;
                Rigidbody rigidbody = nowContent.AddComponent<Rigidbody>();
                rigidbody.useGravity = false;
                isPlaying = isRotateStart;
            }

        }
    }

    //魔方旋转(y轴)
    public void UpdateRotateYEvent(Vector3 rotateDir, Direction cubeDir, Quaternion targetRotation, RotateModel model, ref GameObject nowContent, ref bool isRotateStart, ref bool isRotateAntiStart)
    {
        if (isRotateStart)
        {
            isPlaying = isRotateStart;
            nowContent.transform.Rotate(rotateDir * Time.deltaTime * rotateSpeed);
            bool isBreak = false;

            switch (model)
            {
                case RotateModel.Forward:
                    {
                        switch (cubeDir)
                        {
                            case Direction.First:
                                {
                                    if (nowContent.transform.localRotation.y >= targetRotation.y)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Second:
                                {
                                    if (nowContent.transform.localRotation.y >= -targetRotation.y - 0.0001f)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Third:
                                {
                                    if (nowContent.transform.localRotation.y >= targetRotation.y)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Fourth:
                                {
                                    if (nowContent.transform.localRotation.y >= targetRotation.y)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                        }
                    }
                    break;
                case RotateModel.Back:
                    {
                        switch (cubeDir)
                        {
                            case Direction.First:
                                {
                                    if (nowContent.transform.localRotation.y <= targetRotation.y)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Second:
                                {
                                    if (nowContent.transform.localRotation.y <= targetRotation.y + 0.0001f)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Third:
                                {
                                    if (nowContent.transform.localRotation.y >= -targetRotation.y)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Fourth:
                                {
                                    if (nowContent.transform.localRotation.y <= targetRotation.y)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                        }
                    }
                    break;
            }

            if (isBreak)
            {
                nowContent.transform.localRotation = targetRotation;
                isRotateStart = false;
                isRotateAntiStart = false;
                Rigidbody rigidbody = nowContent.AddComponent<Rigidbody>();
                rigidbody.useGravity = false;
                isPlaying = isRotateStart;
            }

        }
    }

    //魔方旋转(z轴)
    public void UpdateRotateZEvent(Vector3 rotateDir, Direction cubeDir, Quaternion targetRotation,RotateModel model, ref GameObject nowContent, ref bool isRotateStart, ref bool isRotateAntiStart)
    {
        if (isRotateStart)
        {
            isPlaying = isRotateStart;
            nowContent.transform.Rotate(rotateDir * Time.deltaTime * rotateSpeed);
            bool isBreak = false;

            switch (model) {
                case RotateModel.Forward:
                    {
                        switch (cubeDir)
                        {
                            case Direction.First:
                                {
                                    if (nowContent.transform.localRotation.z >= targetRotation.z)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Second:
                                {
                                    if (nowContent.transform.localRotation.z >= -targetRotation.z - 0.0001f)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Third:
                                {
                                    if (nowContent.transform.localRotation.z >= targetRotation.z)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Fourth:
                                {
                                    if (nowContent.transform.localRotation.z >= targetRotation.z)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                        }
                    }
                    break;
                case RotateModel.Back:
                    {
                        switch (cubeDir)
                        {
                            case Direction.First:
                                {
                                    if (nowContent.transform.localRotation.z <= targetRotation.z)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Second:
                                {
                                    if (nowContent.transform.localRotation.z <= targetRotation.z + 0.0001f)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Third:
                                {
                                    if (nowContent.transform.localRotation.z >= -targetRotation.z)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                            case Direction.Fourth:
                                {
                                    if (nowContent.transform.localRotation.z <= targetRotation.z)
                                    {
                                        isBreak = true;
                                    }
                                }
                                break;
                        }
                    }
                    break;
            }
            
            if (isBreak)
            {
                nowContent.transform.localRotation = targetRotation;
                isRotateStart = false;
                isRotateAntiStart = false;
                Rigidbody rigidbody = nowContent.AddComponent<Rigidbody>();
                rigidbody.useGravity = false;
                isPlaying = isRotateStart;
            }

        }
    }
}

FrontContentTrigger.cs

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

public class FrontContentTrigger : MonoBehaviour {

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if(!GameController.Instance.FrontObjList.Contains(other.gameObject))
                GameController.Instance.FrontObjList.Add(other.gameObject);
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if(GameController.Instance.FrontObjList.Contains(other.gameObject))
                GameController.Instance.FrontObjList.Remove(other.gameObject);
    }

}

BackContentTrigger.cs

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

public class BackContentTrigger : MonoBehaviour {

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (!GameController.Instance.BackObjList.Contains(other.gameObject))
                GameController.Instance.BackObjList.Add(other.gameObject);   
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (GameController.Instance.BackObjList.Contains(other.gameObject))
                GameController.Instance.BackObjList.Remove(other.gameObject);
    }

}

UpContentTrigger.cs

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

public class UpContentTrigger : MonoBehaviour {

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (!GameController.Instance.UpObjList.Contains(other.gameObject))
                GameController.Instance.UpObjList.Add(other.gameObject);
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (GameController.Instance.UpObjList.Contains(other.gameObject))
                GameController.Instance.UpObjList.Remove(other.gameObject);
    }

}

DownContentTrigger.cs

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

public class DownContentTrigger : MonoBehaviour {

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (!GameController.Instance.DownObjList.Contains(other.gameObject))
                GameController.Instance.DownObjList.Add(other.gameObject);
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (GameController.Instance.DownObjList.Contains(other.gameObject))
                GameController.Instance.DownObjList.Remove(other.gameObject);
    }

}

LeftContentTrigger.cs

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

public class LeftContentTrigger : MonoBehaviour {

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (!GameController.Instance.LeftObjList.Contains(other.gameObject))
                GameController.Instance.LeftObjList.Add(other.gameObject);
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (GameController.Instance.LeftObjList.Contains(other.gameObject))
                GameController.Instance.LeftObjList.Remove(other.gameObject);
    }

}

RightContentTrigger.cs

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

public class RightContentTrigger : MonoBehaviour {

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (!GameController.Instance.RightObjList.Contains(other.gameObject))
                GameController.Instance.RightObjList.Add(other.gameObject);
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.tag == "Cube")
            if (GameController.Instance.RightObjList.Contains(other.gameObject))
                GameController.Instance.RightObjList.Remove(other.gameObject);
    }

}

写完脚本以后，我们把GameController脚本挂到MainCamera上，然后吧场景中对应的游戏物体拖上去，如下图：

接着，把FrontContent到RightContent对应的触发器脚本挂上，同时，需要注意的是，要把27个Cube游戏物体的tag值，改成“Cube”。整个魔方的控制，就算完成了。

按上面的按钮可以整体转动魔方，按下面的按钮可以转动单独的某个魔方面。

以上。

OneWord233
关注
  • 6
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 30
    评论
专栏目录
Unity 魔方游戏（附游戏开源代码）
qq_39858654的博客
04-08 5492
unity引擎，用c#写的魔方小游戏，用协程实现的动画效果
用Unity3d做一个魔方
04-19
用Unity3d做的一个魔方demo,算是自己初学练手的作业吧。
unity魔方
w36371的博客
11-10 2446
unity3D魔方算法 在最开始想要写魔方的时候，考虑的第一件事就是怎么让一面的方块跟着轴心旋转。 起先，我是想要将每一面的魔方放到一个数组中，后来在思考中，才知道自己的想法多幼稚，吧每一面放入数组中之后，魔方每一块都是会动的，一旋转，就什么都乱了，想了一会之后这个想法被抛弃，又回到原点。 之后，想到了一个最笨的方法，建立一个三维数组，用遍历数组的方式来达成目的，之后打了一点代码，又放弃了，
【Unity3D】魔方
little_fat_sheep
04-19 4629
1）魔方渲染模块 用户选择魔方阶数，渲染指定阶数的魔方； 2）魔方整体控制模块 用户 Scroll 或 Ctrl + Scroll，控制魔方放大和缩小； 用户 Drag 空白处（或右键 Drag），控制魔方整体连续旋转； 用户点击翻面按钮（或方向键，或 Ctrl + Drag，或 Alt + Drag），控制魔方翻面； 用户点击朝上的面按钮，控制魔方指定面朝上； 可以实时识别用户视觉下魔方的正面、上面、右面； 3）魔方局部控制模块 用户点击刷新按钮，打乱魔方； 用户 Drag 魔方相邻的两个方块，控制该层旋
unity 简单实现三阶魔方游戏
发布unity，三维模型的相关内容
01-04 1661
简单的魔方游戏
unity3d魔方源码
05-10
"unity3d魔方源码"项目显然是利用Unity3D来实现一个虚拟的魔方游戏或者教学工具。下面我们将深入探讨这个主题涉及的相关知识点。 1. **Unity3D基础**：Unity3D使用C#编程语言，通过Unity Editor进行场景构建、资源...
3d魔方游戏,unity,c#,魔方游戏
05-28
首先，Unity引擎是一个跨平台的游戏开发工具，它提供了丰富的图形渲染能力，以及强大的物理引擎，使得创建3D模型如魔方变得非常直观。在Unity中，开发者可以通过场景编辑器来设计游戏环境，调整光照、纹理和动画，...
魔方(Unity).rar_ubity 魔方_unity游戏_unity音乐魔方_unity魔方_魔方
07-15
《Unity魔方：游戏开发与音乐融合的创新实践》 Unity，作为一款强大的跨平台游戏开发引擎，一直以来都是游戏开发者们的首选工具。本资源“魔方(Unity).rar_ubity 魔方”是一个利用Unity制作的创新魔方游戏，它巧妙...
unity 简单魔方游戏
01-04
unity 简单魔方游戏 详见 ...
Unity魔方拓展脚本（魔方打乱和复原功能）
OneWord233的博客
04-16 1346
接上文，因为懒得自己手动打乱魔方，所以写了一个打乱魔方的脚本，还有魔方复原方法，以下是代码： using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class CubePlayer : MonoBehaviour { p...
魔方游戏源码
01-24
魔方功能源码，鼠标控制旋转，缩放视角，鼠标左键拖动转动魔方。
（结对编程）基于unity3d游戏引擎的魔方游戏
u012462279的专栏
11-14 4450
软件工程
Unity教程 | 手把手教你拼一个3D“魔方”
虚拟现实开发
04-12 9934
本教程将为刚接触unity的初学者讲解如何在Unity中实现3D立方体的堆叠，利用一个或多个预制件动态创建立方体进行拼接，为这些立方体赋予不同的颜色。  下载本文的示例工程，示例工程使用Unity 5.3.1f1。 http://pan.baidu.com/s/1pLnYdVd   第一步：创建UI 打开Unity编辑器新建3D工程命名为“Cubes Galore”，
unity魔方进阶 AR魔方
w36371的博客
11-10 1485
AR其实不难，我用的是高通AR 如果不会用的高通AR教程 当我们把魔方做出来之后，实现AR魔方就很简单了，就是将整个魔方作为一个模型让手机扫描图片的时候显示出来就可以了 将魔方放在触发图上方，然后做成AR程序打包即可，然后将我们在魔方中控制摄像机的脚本，挂上AR摄像机，就可以实现，摄像机旋转了，记得，要做一个跟魔方轴心一样的中心轴来控制摄像机旋转 模型导出之后，我们不可能一直举着手
unity3d实现一个魔方旋转展示
qq_25725093的博客
07-29 1494
我们先看一下效果吧 这个正方体可以转动 首先创建一个cube对象,然后将unity3d贴图置于Cube的材质 并编写一个名为Rotate.cs的脚本文件 using UnityEngine; using System.Collections; public class Rotate : MonoBehaviour { // Use this for initializatio
软件工程第二次作业：基于Unity的3D魔方实现
Faust Yates
11-16 9668
基于Unity的3D魔方实现   一、背景：     魔方，英文名为Rubik's Cube，又叫魔术方块，也称鲁比克方块。是匈牙利布达佩斯建筑学院厄尔诺·鲁比克教授在1974年发明的。三阶魔方系由富有弹性的硬塑料制成的6面正方体，共有26块小立方体。魔方在1980年代最为风靡，至今未衰。截至2009年1月，魔方在全世界售出了3亿5千多万个。面世不久后，很多类似的玩具也纷纷出现，有些出自发明
魔方案例源代码
欢迎光临雨落星辰的博客
06-02 1983
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> <style> *{ margin: 0; padding: 0; } .container{ width: 300px;
unity基础案例讲解：创建旋转的魔方
最新发布
Richard_shen的博客
03-11 760
在所有那些我熟悉的，旨在让玩家以独立游戏人的身份体验游戏开发过程的游戏中，游戏开发要掌握的理论知识绝对不是最有用或是最有吸引力的那个，最实用的还是案例项目的制作。最近，我在玩一款游戏——笼中窥梦，对其中的正方体不同面显示不同场景的功能非常感兴趣。我特地研究了一下，最终做出了这个魔方案例。如果你想要实现这个功能，首先要了解Unity中的渲染流程。在渲染过程中，有一个蒙版测试的流程，利用蒙版测试原理可以剔除不想显示的部分。
Unity中制作UI光晕效果（发光效果）
热门推荐
OneWord233的博客
04-25 2万+
Unity中，我们怎么制作UI物体发光的渐隐渐现的效果呢？比如说我们有一张月亮光晕的精灵图片我们可以给它添加一个CanvasGroup组件我们可以发现，组件上的Alpha值可以控制图片的透明度，从0到1那么我们可以在代码中通过控制Alpha值循环的变化实现发光的光晕效果以下是代码：using System.Collections; using System.Collections.Generic;...
Unity_SDK_V2.1开发者文档1
08-08
2. 调试说明Unity Editor中调试：请将且仅将NOLO头盔定位器用usb线连接至电脑，开启NOLO HOME PC版本，其他NOLO设备打开，待NOL

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 30
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值