U3D(Unity) 实现电路解密、通水管游戏

最新推荐文章于 2024-09-06 23:03:55 发布
最新推荐文章于 2024-09-06 23:03:55 发布
阅读量5.5k 收藏 67
点赞数 5
分类专栏： Unity学习 文章标签： Unity U3D 游戏功能 电路解密 通水管
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39162826/article/details/99686045
版权

前言

游戏需要实现一个类似GTA5和蜘蛛侠游戏中的电路解密功能，记录下来以供日后复习和他人参考。

需求

在这里插入图片描述
游戏玩法是把右上角电源、右下角电源还有的游戏左下角终点连接在一起获得胜利，终点不能旋转，其他方块点击旋转90度，而且从两个电源出来的路径要高亮显示。

游戏一共有五种方块（其中十字形相当于两个一组成，不是向其他三个方向散开）。
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

思路

这种模式诈一看有点复杂，理清了思路就好做了。我一共写了两个类实现这个功能，一个是方块类，另一个是管理类。每个方块添加一个方块类，方块类起到设置方块类型，保存方块方块朝向，点击旋转并且改变朝向调用管理类方法的作用。管理类负责实现判断逻辑和路径高亮。总体思路就是将对应的方块赋值给管理类数组，然后点击方块调用管理类的递归方法，通过当前方块的流向和方块类行判断所要执行的递归方法。


在这里插入图片描述

代码

代码写得有些杂乱，有没有隐性bug也不得而知。重要的是思路，代码只是给大家一个参考。

Square类

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

//记录方块的类型
public enum SquareType
{
    Yi,
    Er,
    San,
    Si,
    Shi
}
public class Square : MonoBehaviour,IPointerClickHandler
{
    [HideInInspector]
    public int up = 0;//表示方块方向，最开始用了四个方向，其实一个就可以判断
    public SquareType type;//public方块类型，可以在外部修改

    //点击旋转90度，up方向也随之改变，并且调用管理类封装的方法
    public void OnPointerClick(PointerEventData eventData)
    {
        if(eventData.button == PointerEventData.InputButton.Left)
        {
            transform.Rotate(0, 0, -90);
            up = (up + 1) % 4;
            SquareManager.manager.StartConnect();
        }
    }
}

SquareManager类

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

//两个目标点
public enum SquareTarget
{
    TargetPoint1,
    TargetPoint2
}
public class SquareManager : MonoBehaviour
{
    public static SquareManager manager;//单例

    //储存所有方块
    public Square[] squares1;
    public Square[] squares2;
    public Square[] squares3;
    public Square[] squares4;
    public Square[,] squares = new Square[4,4];

    Dictionary<Vector2, List<int>> road = new Dictionary<Vector2, List<int>>();//路径

    //数组最大维度
    private const int MAX = 3;
    private const int MIN = 0;

    private SquareTarget target ;

    //判断是否完成
    bool isChecked1, isChecked2;

    //记录Connect方法执行第一次，第一次执行不存储上一个点
    bool isFirstConnect = true;

    private void Awake()
    {
        if (manager == null)
            manager = this;
    }

    //初始化数组
    void Start()
    {
        for(int i = MIN; i <= MAX; i++)
        {
            for (int j = MIN; j <= MAX; j++)
            {
                if (i == 0)
                {
                    squares[j, i] = squares1[j];
                }
                if (i == 1)
                {
                    squares[j, i] = squares2[j];
                }
                if (i == 2)
                {
                    squares[j, i] = squares3[j];
                }
                if (i == 3)
                {
                    squares[j, i] = squares4[j];
                }
            }
        }

        StartConnect();
    }

    //核心方法，根据来的流向和方块类型还有方块状态判断向下递归
    public bool CheckConnect(int x, int y, int comeDir, int lastX, int lastY, int lastDir)
    {
        //保存上一步方块，保存当前方块的话会导致一直高亮
        if (!isFirstConnect)
        {
            if (road.ContainsKey(new Vector2(x, y)) && road[new Vector2(x, y)].Contains(comeDir))
                return false;
            if (!road.ContainsKey(new Vector2(lastX, lastY)))
            {
                road.Add(new Vector2(lastX, lastY), new List<int>() { lastDir });
            }
            else
            {
                road[new Vector2(lastX, lastY)].Add(lastDir);
            }
        }
        else
        {
            isFirstConnect = false;
        }
        //越界返回
        if (x > 3 || x < 0 || y > 3 || y < 0)
            return false;
        //结束条件
        switch (target)
        {
            case SquareTarget.TargetPoint1:
                if (x == 3 && y == 0)
                {
                    if (squares[x, y].up == 2 && comeDir == 0)
                    {
                        if (!road.ContainsKey(new Vector2(x, y)))
                        {
                            road.Add(new Vector2(x, y), new List<int>() { comeDir });
                        }
                        else if (!road[new Vector2(x, y)].Contains(comeDir))
                        {
                            road[new Vector2(x, y)].Add(comeDir);
                        }
                        isChecked1 = true;
                        Debug.Log("-----------------------------Success1-------------------------------");
                        return true;
                    }
                }
                break;
            case SquareTarget.TargetPoint2:
                if (x == 0 && y == 0)
                {
                    if ((squares[x, y].up == 2 || squares[x, y].up == 0) && comeDir == 1)
                    {
                        if (!road.ContainsKey(new Vector2(x, y)))
                        {
                            road.Add(new Vector2(x, y), new List<int>() { comeDir });
                        }
                        else if (!road[new Vector2(x, y)].Contains(comeDir))
                        {
                            road[new Vector2(x, y)].Add(comeDir);
                        }

                        isChecked2 = true;
                        Debug.Log("-----------------------------Success2-------------------------------");
                        return true;
                    }
                }
                break;
        }

        //上0 右1 下2 左3
        //根据条件递归
        switch (comeDir)
        {
            case 0:
                switch (squares[x, y].type)
                {
                    case SquareType.Yi:
                        if (squares[x, y].up == 0 || squares[x, y].up == 2)
                        {
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Er:
                        if (squares[x, y].up == 1)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 2)
                        {
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.San:
                        if (squares[x, y].up == 0)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 1)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 2)
                        {
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Si:
                        if (squares[x, y].up == 0 || squares[x, y].up == 2)
                        {
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 1 || squares[x, y].up == 3)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Shi:
                        CheckConnect(x, y - 1, 0, x, y, comeDir);
                        break;
                }
                break;
            case 1:
                switch (squares[x, y].type)
                {
                    case SquareType.Yi:
                        if (squares[x, y].up == 1 || squares[x, y].up == 3)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Er:
                        if (squares[x, y].up == 2)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 3)
                        {
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.San:
                        if (squares[x, y].up == 1)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 2)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 3)
                        {
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Si:
                        if (squares[x, y].up == 0 || squares[x, y].up == 2)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 1 || squares[x, y].up == 3)
                        {
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Shi:
                        CheckConnect(x - 1, y, 1, x, y, comeDir);
                        break;
                }
                break;
            case 2:
                switch (squares[x, y].type)
                {
                    case SquareType.Yi:
                        if (squares[x, y].up == 0 || squares[x, y].up == 2)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Er:
                        if (squares[x, y].up == 0)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 3)
                        {
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.San:
                        if (squares[x, y].up == 0)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 2)
                        {
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 3)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Si:
                        if (squares[x, y].up == 0 || squares[x, y].up == 2)
                        {
                            CheckConnect(x - 1, y, 1, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 1 || squares[x, y].up == 3)
                        {
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Shi:
                        CheckConnect(x, y + 1, 2, x, y, comeDir);
                        break;
                }
                break;
            case 3:
                switch (squares[x, y].type)
                {
                    case SquareType.Yi:
                        if (squares[x, y].up == 1 || squares[x, y].up == 3)
                        {
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Er:
                        if (squares[x, y].up == 0)
                        {
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 1)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.San:
                        if (squares[x, y].up == 0)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 1)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 3)
                        {
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                            CheckConnect(x + 1, y, 3, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Si:
                        if (squares[x, y].up == 0 || squares[x, y].up == 2)
                        {
                            CheckConnect(x, y - 1, 0, x, y, comeDir);
                        }
                        else if (squares[x, y].up == 1 || squares[x, y].up == 3)
                        {
                            CheckConnect(x, y + 1, 2, x, y, comeDir);
                        }
                        else
                        {
                            return false;
                        }
                        break;
                    case SquareType.Shi:
                        CheckConnect(x + 1, y, 3, x, y, comeDir);
                        break;
                }
                break;
            default:
                return false;
        }
        return false;
    }

    //路径高亮
    void OnOffLight()
    {

        foreach (var item in squares)
        {
            if (item.type == SquareType.Si)
            {
                item.transform.GetChild(0).gameObject.SetActive(false);
                item.transform.GetChild(1).gameObject.SetActive(false);
            }
            else if (item.type == SquareType.Shi)
            {
                item.transform.GetChild(0).gameObject.SetActive(false);
                item.transform.GetChild(1).gameObject.SetActive(false);
                item.transform.GetChild(2).gameObject.SetActive(false);
            }
            else
            {
                item.transform.GetChild(0).gameObject.SetActive(false);
            }
        }
        foreach (var item in road.Keys)
        {
            if (squares[(int)item.x, (int)item.y].type == SquareType.Si)
            {
                if (squares[(int)item.x, (int)item.y].up == 0)
                {
                    foreach (var dirs in road[item])
                    {
                        if (dirs == 2 || dirs == 3)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(1).gameObject.SetActive(true);
                        }
                        if (dirs == 0 || dirs == 1)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.SetActive(true);
                        }
                    }
                }
                if (squares[(int)item.x, (int)item.y].up == 1)
                {
                    foreach (var dirs in road[item])
                    {
                        if (dirs == 3 || dirs == 0)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(1).gameObject.SetActive(true);
                        }
                        if (dirs == 2 || dirs == 1)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.SetActive(true);
                        }
                    }
                }
                if (squares[(int)item.x, (int)item.y].up == 2)
                {
                    foreach (var dirs in road[item])
                    {
                        if (dirs == 2 || dirs == 3)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.SetActive(true);
                        }
                        if (dirs == 0 || dirs == 1)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(1).gameObject.SetActive(true);
                        }
                    }
                }
                if (squares[(int)item.x, (int)item.y].up == 3)
                {
                    foreach (var dirs in road[item])
                    {
                        if (dirs == 3 || dirs == 0)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.SetActive(true);
                        }
                        if (dirs == 2 || dirs == 1)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(1).gameObject.SetActive(true);
                        }
                    }
                }
            }
            else if (squares[(int)item.x, (int)item.y].type == SquareType.Shi)
            {
                if (squares[(int)item.x, (int)item.y].up == 0 || squares[(int)item.x, (int)item.y].up == 2)
                {
                    foreach (var dirs in road[item])
                    {
                        if (dirs == 0 || dirs == 2)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.SetActive(true);
                        }
                        if (dirs == 3 || dirs == 1)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(1).gameObject.SetActive(true);
                        }
                    }
                }
                if (squares[(int)item.x, (int)item.y].up == 1 || squares[(int)item.x, (int)item.y].up == 3)
                {
                    foreach (var dirs in road[item])
                    {
                        if (dirs == 0 || dirs == 2)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(1).gameObject.SetActive(true);
                        }
                        if (dirs == 3 || dirs == 1)
                        {
                            squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.SetActive(true);
                        }
                    }
                }
                if (squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.activeSelf && squares[(int)item.x, (int)item.y].transform.GetChild(1).gameObject.activeSelf)
                {
                    squares[(int)item.x, (int)item.y].transform.GetChild(2).gameObject.SetActive(true);
                }
            }
            else
            {
                squares[(int)item.x, (int)item.y].transform.GetChild(0).gameObject.SetActive(true);
                
            }
        }
    }

    //统一调用
        public void StartConnect()
    {
        target = SquareTarget.TargetPoint2;
        isFirstConnect = true;
        CheckConnect(3, 3, 1,3,3,1);

        //这一步是为了实现从第二个点向外路径高亮
        target = SquareTarget.TargetPoint2;
        isFirstConnect = true;
        CheckConnect(3, 0, 1, 3, 0, 1);
        OnOffLight();
        road.Clear();

        target = SquareTarget.TargetPoint1;
        isFirstConnect = true;
        CheckConnect(3, 3, 1,3,3,1);
        road.Clear();

        if (isChecked1 && isChecked2)
        {
            Debug.Log("-----------------------------Success-------------------------------");
        }

        isChecked1 = false;
        isChecked2 = false;
    }
}
我寄人间雪满头丶
关注
专栏目录
【Unity实战篇 】| 2.5D游戏是如何做出来的呢，2.5D游戏快速制作教程
努力前行，总会成为自己心中的那道光
08-09 8万+
玩过游戏的朋友都知道，市面上最常见的游戏多数分为2D和3D两种。 2D和3D游戏之间的差异大家都知道，一个是类似纸片游戏属于二维层面，另一个则是在3D立体空间中游玩。 其中还夹杂着一个2.5D游戏，本篇文章就来讲一下怎么通过Unity进行2.5D游戏是怎样的以及如何制作2.5D游戏。 制作方法很简单，文中使用到了Tile Map Editor制作2D地图，通过控制相机角度来形成伪3D来制作2.5D效果的游戏。 下面就一起来看看到底是怎样制作的吧！
接水管游戏
04-16
有趣的接水管游戏，欢迎下载来学习玩，cocos2dx开发的
Unity Shader 基础教程
Sun.ME的博客
05-27 4万+
Unity-Shader-基础教程 在Github上看到一篇关于Unity-Shader的教程，感觉还不错，作者写的很好，很适合Unity-Shader的基础入门，我在这里翻译一下，分享给大家，英文水平很烂，大致能明白Unity-Shader是什么，渲染管线的工作流程，以及Unity Shader的一些类型和怎样编写Unity Shader。 （原文链接） 第一部分：什么是Shader?...
PipeFlow——Unity中的液体流动视觉革命
最新发布
gitblog_09800的博客
09-06 421
PipeFlow——Unity中的液体流动视觉革命 项目地址:https://gitcode.com/open-source-toolkit/645fc 在追求细节与真实性的数字世界中，让每一滴液体的流动都栩栩如生，是每个开发者心中的渴望。今天，我们要向您隆重推荐——PipeFlow，一个专为Unity引擎打造的管道内液体流动特效解决方案，它犹如一颗宝石，点亮了仿真流动特效的新篇章。 项目介绍 P...
试着在Unity中实现电学实验
凉尘雨的博客
03-23 7401
试着在Unity中实现电学实验系统 作为一个初学者，在大创项目（VR物理实验室）中遇到的第一个挑战就是，如何在unity实现自定义组件和串联分压，并联分流？ 在建完模型之后，我只能看着一堆电学部件陷入了沉思。。。。 所以我一个团队分工做美术的为什么还要来写程序啊喂 咳咳，言归正传。一开始想过一些方法，就是每一个模型都单独给一个脚本，里面有自己的属性方法什么的，然后导线作为连接装置，可以传递模型的...
Unity 电路解密小游戏实现思路
qq_51491918的博客
10-23 2536
点击电线组件可以旋转，连接电池首尾游戏结束(该Demo还要连通特殊组件)，连通后线路会亮起来(该Demo只要和正极相连的线路就会亮，Demo的亮是图片颜色变化和Unity光照，这里就写图片的颜色变化，思路是差不多的)。为每个电线组件添加接口Trigger，点击组件后组件进行旋转，将接口触发到的线路引用添加进来，将离开的线路引用删除，然后发送事件，重置所有让电池开始从正极的电线开始递归调用显示。把Points下的对象的CheckPoint.cs换成InPole.cs和OutPole.cs。
android版《手工接水管》--unity3d制作的
nate的专栏
08-08 5249
打打广告看看能不能挣到钱，呵呵http://dlnuchunge.gouwuke.com/search-android%E6%89%8B%E6%9C%BA.html?oid=245860&gsid=513132   这几天没事做，随便做了一个小demo，因为不会美术，所以就没有继续做下去，我的悲哀啊~~~ 这是一个接水管的小demo，原本是flash游戏，下面看看我的例子吧~~~~
使用unity实现划线接水小游戏
qq_36044120的博客
05-04 448
首先选用流水插件场景选择定义目录标题)
杂谈：编程解决水管工游戏
weixin_30876945的博客
12-10 334
杂谈：编程解决水管工问题 程序设计是一门极难上手的技能，仅仅凭着课堂上的知识，只能是熟悉一门编程语言的语法。但要是用计算机来解决一些实际的问题，哪怕是智力问题，课本上的知识是远远不够的。 编程就像学游泳。学游泳一定要在水里学，要在水里摸索体会。学编程也是如此。 下面给大家带来一个有趣的小问题，希望大家能够学习到其中的程序设计思维与方法，尤其是中间建立模型的过程，相当精彩，大家欣赏一下...
水管工游戏
一只小菜鸟
06-24 2897
一 题目一块矩形土地被分为N*M的单位正方形，现在这块土地上已经埋设有一些水管，水管将从坐标为(1,1)左上角左部边缘，延伸到(N,M)右下角右部边缘。水管只有2种，如下图所示。 每种管道将占据一个单位正方形土地。你现在可以旋转这些管道，使得构成一个管道系统，即创造一条从(1,1)到(N,M)的连通管道。标有树木的方格表示这里没有管道。如下图：一个5*4的土地中(2,4)处有一个树木。 我
DIY一个粒子检测器 2020-10
TSINGHUAJOKING
10-02 972
  ➤ 01粒子检测器 在 TLE207x低噪声高速JFET-输入运算放大器的噪声特性测量 中实现了TLE207x的低噪声放大器。放置在金属盒屏蔽盒内进行信号放大。 基于上面的实验电路， DIY一个粒子检测器 。其中BPX61来自 淘宝店BPX61 . 用于实验的放射源来自 离子烟雾传感器中的Am241 。 ▲ 实验中的传感器和放射源   ➤ 02组装检测器 1.实验电路 实验电路采用在 怎么DIY一个粒子检测器 的参考电路，全部电路在扁平金属盒内的面包板来实现。 ▲ 放大电路的电路
Unity自学线路图(终极版)
05-15
Unity自学线路图(终极版)
IOS 接水管代码
02-01
这是一个IOS采用cocos2d开发的接水管的游戏，可以作为参考学习用
课程里面的unity实验
04-03
unity的一个课程小型实验。做了一个简单的模型。用于unity软件的入门。
5款Unity3D制作的小游戏实例，新手必备
10-29
5款Unity3D制作的小游戏实例，新手必备 5款Unity3D制作的小游戏实例，新手必备 5款Unity3D制作的小游戏实例，新手必备 5款Unity3D制作的小游戏实例，新手必备
【Unity 实用工具篇】| 游戏多语言解决方案，官方插件Localization 实现本地化及多种语言切换
热门推荐
努力前行，总会成为自己心中的那道光
12-12 5万+
Unity的多语言本地化是一个很实用的功能，它可以帮助游戏支持多种语言，让不同语言的玩家都能够更好地体验游戏。 而实现本地化的方案也有很多种，各个方案之间也各有优劣，后面也会对多个方案进行介绍学习。 本文就来介绍一个专门作用于多语言本地化的Unity官方插件：Localization 。
【用unity实现100个游戏之17】从零开始制作一个类幸存者肉鸽(Roguelike)游戏1（附项目源码）
向宇
11-27 4615
他来了他来了，万众期待的类幸存者肉鸽(Roguelike)游戏。我将从0带大家制作一款肉鸽游戏。这款游戏采用经典的 Roguelike 游戏玩法，每次冒险都将是一次全新的体验。敌人的位置和道具都是随机生成的，确保每次游玩都充满了无限可能性。你需要运用智慧、策略和一点运气来战胜挑战，并不断提升自己的技能和装备，以应对越来越强大的敌人。准备好迎接挑战了吗？快来开始你的冒险之旅吧！本节主要实现简单的人物控制和无限地图功能。
Unity3D真实花瓣撒花散落8种花朵粒子特效 U3D游戏素材插件资源包
05-25
Unity3D真实花瓣撒花散落8种花朵粒子特效 U3D游戏素材插件资源包
U3D入门：Unity游戏开发基础与关键技术
本篇U3D基础中文教程深入介绍了Unity游戏开发的相关概念和技术，Unity作为一个强大的游戏引擎，被广泛应用于游戏制作。首先，我们了解了游戏的基础知识，包括不同类型的游戏，如角色扮演游戏（RPG）、动作游戏（ACT...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我寄人间雪满头丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值