精华内容
下载资源
问答
  • C#开发Unity游戏教程循环遍历做出判断及Unity游戏示例

    C#开发Unity游戏教程循环遍历做出判断及Unity游戏示例

    Unity中循环遍历每个数据,并做出判断

    很多时候,游戏在玩家做出判断以后,游戏程序会遍历玩家身上大量的所需数据,然后做出判断,即首先判定玩家是否有权限做出这种选择,然后才决定是否为玩家执行此选择。例如,《仙剑奇侠传》这款游戏,进入剧情“荷叶迷宫时”,会要求玩家击碎迷宫里的5尊雕塑,如图5-12所示。但是击碎的前提是,玩家身上必须携带有“锤子”。也就是说系统会遍历玩家身上所有的资源,如果有锤子才能击碎雕塑。


    5-12  《仙剑奇侠传》,荷叶迷宫全图

    判断是否有指定的数据,可以使用本章前面所学的if语句来解决。但是目前还存在两个其它的问题:

    • q  如何在脚本中存储和引用这大量的数据,如果使用变量,显然要声明大量的变量,这样做显然不妥;

    • q  如果已经得到了大量的数据,该使用什么方式去一一判别呢,难道说要使用大量if语句,去对数据一一判别,这样做显然也不妥;

    C#倒是提供了两种机制,可以很有效的解决以上的两个问题,本节会逐个详解介绍它们。

    Unity中大量数据的存储与引用

    C#指定了3种存储与引用大量数据的方法,分别是:数组、列表和字典。本小节会使用简单的小示例依次讲解它们,至于大的游戏示例,会在本章讲解完所有的知识点以后给出。

    1.数组

    数组可以存储大量同类型的数据,它的声明格式为:

    • 数据类型[ ] 数组名;

    • q  所有常用的数据类型,在本书第3章中已经使用表格列出了;

    • q  数据类型后面跟着的是一对中括号“[ ]”;

    • q  数组名与变量名一样,必须遵循C#的命名规定;

    例如,下面的代码语句声明,并且初始化了数组:

    • int[] myIntArray = {1,3,5,7,9};

    读者应该可以从这条语句中看出,声明的是int类型的数组,数组名为myIntArray,存储了5int类型的数据,分别是13579

    引用数组中指定数据的格式为:

    • 数组名[下标];

    • q  下标是从0开始的整数,当下标为0时,表示引用的是数组中的第1个数据;若为3时,表示引用的是数组中的第4个数据;其它数据的引用方式依此类推;

    为脚本MyScript添加下面的代码:

    • 01     using UnityEngine;

    • 02     using System.Collections;

    • 03    

    • 04     public class MyScript : MonoBehaviour

    • 05     {

    • 06              private int[] myIntArray = {1,3,5,7,9};                //数组的声明和初始化

    • 07              void Start()

    • 08              {

    • 09                        Debug.Log ("数组中的第1个数据是:" + myIntArray[0]);          //数组数据的引用

    • 10                        Debug.Log ("数组中的第5个数据是:" + myIntArray[4]);          //数组数据的引用

    • 11              }

    • 12     }

    运行游戏,在Console视图里查看脚本输出的信息,如图5-13所示。


    5-13  使用数组的示例

    2.列表

    列表与数组类似,同样用于存储大量同类的数据。但是似乎C#开发人员相对于数组,更偏爱列表一些。除非逼不得已,否则他们不会从列表和数组二者间选择后者,基本上是因为下面的几个原因:

    • q  数组在被声明了以后,存储的数据的个数就是固定的了,而列表则比较灵活,没有这方面的限制,如果开发者需要,它还可以存储更多的数据;

    • q  列表可以更方便的增加和删除存储于其中的数据;

    这次作者打算在演示一个示例以后,在具体介绍列表的声明和使用等等。为脚本MyScript添加下面的代码:

    • 01     using UnityEngine;

    • 02     using System.Collections.Generic;                                                                 //必须添加的语句

    • 03    

    • 04     public class MyScript : MonoBehaviour

    • 05     {

    • 06              private List<int> myIntList = new List<int>();                                       //声明列表

    • 07              void Start()

    • 08              {

    • 09                       myIntList.Add (1);                                                                               //添加数据到列表

    • 10                       myIntList.Add (3);

    • 11                       myIntList.Add (5);

    • 12                        Debug.Log ("列表中总共存储的数据个数是:" + myIntList.Count);

    • 13                        Debug.Log ("列表中第1个数据是:" + myIntList[0]);                 //引用列表中的数据

    • 14                        Debug.Log ("列表中第3个数据是:" + myIntList[2]);

    • 15    

    • 16                       myIntList.Add (7);

    • 17                        Debug.Log ("列表中第4个数据是:" + myIntList[3]);

    • 18              }

    • 19     }

    运行游戏,在Console视图里查看脚本输出的信息,如图5-14所示。


    5-14  使用列表的示例

    • q  脚本02行的语句,与以往不同,需要读者主动修改成这个样子,此语句是在脚本中使用列表的前提,顺便提及新建脚本时,语句是下面的这个样子:

    • 02     using System.Collections;

    • q  脚本06行的语句如下:

    • 06              private List<int> myIntList = new List<int>();                                       //声明列表

    此语句声明了列表,其名为myIntList,目前还没有存储任何数据;和数组一样,声明列表时也需要指定指定列表中可以存储的数据的类型,本示例中存储的类型是int

    • q  脚本09~11行编写了类似于下面的语句:

    • 09                       myIntList.Add (1);                                                                               //添加数据到列表

    通过这种方式,一个int类型的数据1,才被存储到了列表中。

    • q  脚本1314行,引用列表数据的方式如下:

    • 09                       myIntList[0]

    单从编写样式上看,它的引用方式与数组引用自身数据的方式一模一样,而且它的下标也是从0开始,表示存储的第1个数据,其它数据的存储下标以此类推。

    • q  脚本1617行,是列表区别于数组的使用方法,因为列表中可以存储的数据的个数是没有限定的;

    3.字典

    字典的使用方法与列表类似,但是它的声明需要指定一对数据类型,即键(Key)和值(Value)这两个数据的数据类型。使用字典最大的好处就是,可以通过Key,找到与之对应的Value。对于游戏的实际意义是,一个网络游戏一定需要存储大量用户的游戏信息,而游戏程序定位这些信息的方式通常是使用ID。也就是说,一个玩家就有一个ID,而ID关联了用户的所有信息,所以只要知道用户的ID,就不愁找不到玩家的其它游戏信息了。

    在讲解字典的语法前,同样先演示一个示例,为脚本MyScript添加下面的代码:

    • 01     using UnityEngine;

    • 02     using System.Collections.Generic;

    • 03    

    • 04     public class MyScript : MonoBehaviour

    • 05     {

    • 06              private Dictionary<int,string> myDic = new Dictionary<int,string>();              //声明字典

    • 07              void Start()

    • 08              {

    • 09                       myDic.Add(10,"Monday");                                   //添加数据到字典

    • 10                       myDic.Add(20,"Tuesday");

    • 11                       myDic[30] = "Wednesday";

    • 12                        Debug.Log ("字典中总共存储的数据个数是:" + myDic.Count);

    • 13                        Debug.Log ("字典中key10的数据是:" + myDic[10]);                   //引用字典中的数据

    • 14                        Debug.Log ("字典中key20的数据是:" + myDic[20]);

    • 15                       myDic[40] = "Thursday";

    • 16                        Debug.Log ("字典中key40的数据:" + myDic[40]);

    • 17              }

    • 18     }

    运行游戏,在Console视图里查看脚本输出的信息,如图5-15所示。


    5-15  使用字典的示例

    • q  脚本02行的语句,对于在脚本中使用字典同样是不可缺少的,

    • q  脚本06行的语句:

    • 06              private Dictionary<int,string> myDic = new Dictionary<int,string>();

    是字典的声明部分,从格式上来看与列表的声明方式十分相近。只不过声明字典需要同时指定键和值两个数据的数据类型。

    • q  脚本09~10行,为字典添加数据的方式与列表相似:

    • 09                       myDic.Add(10,"Monday");                                   //添加数据到字典

    但是字典还有其它的方式,即脚本11行的代码

    • 11                       myDic[30] = "Wednesday";

    这种方式,乍看之下与数组存储数据的方式一样,但是此种方式里,中括号“[ ]”里的数字可不是“下标”,而是“键”。

    • q  脚本131416行,字典引用数据的形式与数组和列表一致,但是中括号“[ ]”里的数字可不是“下标”,而是“键”。

    • 13                        myDic[10]

    Unity中遍历大量的数据

    如果需要在脚本中使用同样的操作去一一判别大量的数据,C#倒是提供了一种不错的机制,读者或许会有兴趣,就是“循环”。C#里有3种用于实现循环的语句,分别是:foreachforwhile。本小节打算依次介绍它们的使用方法,最后再将这种机制应用到游戏中。

    1.foreach循环

    为了更好的说明foreach循环的使用方法,下面将演示一个示例,此示例会使用foreach循环遍历数组、列表和字典里的所有数据,并使用if语句选择所需的数据。为MyScript脚本添加下面的代码:

    • 01     using UnityEngine;

    • 02     using System.Collections.Generic;

    • 03    

    • 04     public class MyScript : MonoBehaviour

    • 05     {

    • 06              void Start()

    • 07              {

    • 08                       string[] myArray = new string[] {"Monday","Tuesday","Wednessday"};

    • 09                       foreach(string myStrArray in myArray)                                        //循环遍历数组

    • 10                       {

    • 11                                 if(myStrArray == "Monday")

    • 12                                          Debug.Log("There is "+myStrArray+" in array.");

    • 13                       }

    • 14    

    • 15                       List<string> myList = new List<string> {"Monday","Tuesday","Wednessday"};

    • 16                       foreach(string myStrList in myList)                                              //循环遍历列表

    • 17                       {

    • 18                                 if(myStrList == "Tuesday")

    • 19                                          Debug.Log("There is "+myStrList+" in list.");

    • 20                       }

    • 21    

    • 22                       Dictionary<int,string> myDict = new Dictionary<int,string>

    • 23                                          {{10,"Monday"},{20,"Tuesday"},{30,"Wednessday"}};

    • 24                       foreach(KeyValuePair<int,string> myStrDic in myDict)          //循环遍历字典

    • 25                       {

    • 26                                 if(myStrDic.Key == 30)

    • 27                                          Debug.Log ("There is "+myStrDic.Value+" in dictionary");

    • 28                       }

    • 29              }

    • 30     }

    运行游戏,在Console视图里查看脚本输出的信息,如图5-16所示。


    5-16  使用foreach循环的示例

    • q  脚本081522行的代码,分别声明了数组、列表和字典,并且为它们初始化了3组数据;

    • q  脚本091624行的代码,则分别开始使用foreach语句遍历数组、列表和字典。以09行的语句为例:

    • 09                       foreach(string myStrArray in myArray)                                        //循环遍历数组

    foreach后括号“( )”里的语句,表示的含义是:要遍历的是myArray数组,而数组中的每个数据都将先被存储于同类型的myStrArray变量中。语句的书写格式如下:

    • foreach(数据类型 变量名 in 数组名)

    • q  脚本111826行的代码,分别使用if语句判断变量中的数据,是否是指定的数据。以11行的代码为例:

    • 11                                 if(myStrArray == "Monday")

    if后括号“( )”里的语句,是一个关系表达式,当变量myStrArray里的数据字符串是Monday时,表达式的值才是true

    • q  脚本121927行的代码,则表示当使用if语句判断出数组、列表和字典中存在指定数据时,会输出文字信息到Console视图。以12行的代码为例:

    • 12                                          Debug.Log("There is "+myStrArray+" in array.");

    如果数组中存在数据“Monday”,则会在Console视图里输出“There is Monday in array”。

    2.for循环

    for循环也可以遍历数组、列表与字典中的所有数据,但是它与foreach语句的些许区别在于,for循环表达的含义更像是:让一段代码执行指定的次数。例如,执行5次输出语句,做10次同样的操作等等。下面是使用for循环的一个简单示例:

    • 01     using UnityEngine;

    • 02     using System.Collections.Generic;

    • 03    

    • 04     public class MyScript : MonoBehaviour

    • 05     {

    • 06              void Start()

    • 07              {

    • 08                       List<string> myList = new List<string> {"Monday","Tuesday","Wednessday"};

    • 09                       for(int i = 0;i < myList.Count;i++)

    • 10                       {

    • 11                                 Debug.Log(myList[i]);

    • 12                                 if(myList[i] == "Tuesday")

    • 13                                          Debug.Log("There is "+myList[i]+" in list.");

    • 14                       }

    • 15              }

    • 16     }

    运行游戏,在Console视图里查看脚本输出的信息,如图5-17所示。


    5-17  使用for循环的示例

    • q  脚本08行的代码,声明了一个列表,且为列表添加了3组数据

    • q  脚本09行的代码,就是一个for语句,如下:

    • 09                       for(int i = 0;i < myList.Count;i++)

    for后面括号里的语句,所表示的含义是:一共要循环myList.Count次。变量i类似于一个计数器,记录着当前循环的次数。例如,要循环15次,可以使用下面的for循环语句:

    • for(int i = 0;i < 15;i++)

    • q  脚本11~13行的多条语句,是要执行指定循环次数的代码。其中11行的语句用于在Console视图中输出列表中的所有数据;1213行的代码,是一个if语句,用于判断列表中是否存在指定的数据,如果存在就会输出相应的信息到Console视图;

    3.while循环

    while循环与for循环的操作效果是相同的,即让循环执行一定的次数。但不同的是,从for循环的语句中可以很明确的看出循环的次数,在达到指定次数以后就停止。while循环表达的没有这么明确,但它会明确的告诉Unity,什么时候停止循环。下面的脚本代码,是将for循环的示例改写成了while循环,如下:

    • 01     using UnityEngine;

    • 02     using System.Collections.Generic;

    • 03    

    • 04     public class MyScript : MonoBehaviour

    • 05     {

    • 06              void Start()

    • 07              {

    • 08                       List<string> myList = new List<string> {"Monday","Tuesday","Wednessday"};

    • 09                       int i = 0;

    • 10                       while(i < myList.Count)

    • 11                       {

    • 12                                 Debug.Log(myList[i]);

    • 13                                 if(myList[i] == "Tuesday")

    • 14                                          Debug.Log("There is "+myList[i]+" in list.");

    • 15                                 i++;

    • 16                       }

    • 17              }

    • 18     }

    运行游戏,在Console视图里查看脚本输出的信息,如图5-18所示。


    5-18  使用while循环的示例

    • q  脚本10行的语句,就是while循环语句,它后面的括号里,只有一个关系表达式,此关系表达式决定了循环在什么时候结束;

    其它部分与for循环的示例一样,这里就不做重复说明了。

    Unity游戏示例

    本章先后学习了C#语法里,3个部分的内容。这3个部分是:

    • q  判断语句,包括ifif-elseif-else-ifswitch

    • q  数据存储方式,包括数组(array)、列表(list)和字典(dictionary);

    • q  大量数据的遍历方式,包括foreachforwhile

    为了更方便的说明各部分的语法实现,以及书写方式,前面多以非游戏的示例来说明。但是读者也许并不知道它们在游戏中的应用是怎样的,因此本节应用本章所学习的知识编写了本节的游戏示例。

    Unity游戏运行效果

    本游戏想要实现的效果是:游戏会要求玩家按照顺序依次按下指定的几个按键,如果玩家成功的按下这组按键,就给出表示成功的图片提示;反之,就给出表示失败的图片提示。游戏运行效果如图5-195-205-21所示。


    5-19  游戏视图中给出了3组预定义的组合键


    5-20  按照组合键2的提示                        5-21  没有按照任何组合键的提示

    补充:此游戏示例的灵感来源于,《拳皇》打斗时的组合键。玩过此游戏的读者,应该知道在此种游戏中,只有玩家按下了指定的按键以后,角色才会打出绝技!如图5-22所示。


    5-22  《拳皇》中,按下指定的按键以后,所展示出的绝技

    虽然本游戏示例没有这么精彩的打斗画面,但是却和它有着一样的对特定按键组合的判断,也就是说,程序首先需要知道玩家是否按下了指定的组合键,然后才决定是否展示特定的特技。而本示例就是运用了本节所学的知识,实现了前一部分的功能。

    Unity游戏实现步骤

    游戏的具体实现步骤如下:

    1为游戏项目导入6张图片,其中4个是用于表示方向的,2个是用于表示成功和失败时的表情的。本游戏示例导入的6张图片,如图5-23所示。


    5-23  为游戏项目导入的6张图片

    2新建游戏项目时,新的游戏场景也被创建了,而且此游戏场景中还有一个游戏对象——Main Camera。本节所创建的游戏示例,由于是通过界面的绘制实现的,因此不需要读者继续往游戏场景里添加其它游戏对象了。

    3Project视图里,新建一个脚本,命名为MyScript。本游戏的所有运行逻辑都将在此脚本中实现。此脚本将被赋予Main Camera游戏对象。

    Unity游戏脚本的编写

    脚本的代码,涉及了游戏的所有运行逻辑,内容较多,就将其划分成了一个小节。本小节也因此得以为读者详细介绍脚本代码的思考和编写过程。

    1.声明变量

    1游戏项目中有6张图片,脚本会操作这6张图片,然后按照指定的游戏逻辑,将它们显示在游戏视图中。因此脚本中需要声明存储这6张图片(数据)的变量,如下:

    •          public Texture[] image;

    既然都是图片,联想到本章所学的知识,就很容易想到使用数组,当然读者也可以选择使用列表。

    提示:TextureUnity脚本中是表示用于存储图片这种数据的数据类型。

    因为变量被public修饰,所以它会以属性的形式,出现在Inspector视图的组件下。读者需要在此视图里,将图片作为属性值,赋予这个数组。具体的赋值方式就是拖动,即将图片从Project视图,拖动到Inspector视图,如图5-24所示。


    5-24  脚本组件属性的设置

    提示:读者一定要注意数组各图片数据的排列顺序,因为后面要编写的脚本代码将直接使用下标,引用数组中存储的图片数据。对于本示例,图片数组中的存储顺序是:updownleftrightsuccessfail

    2同样需要声明数组的地方,还有表示预定义的3组组合键的数据,如下:

    •          int[,] Sample =

    •          {

    •                    //++++空格

    •                    {KEY_UP,KEY_DOWN,KEY_LEFT,KEY_RIGHT,KEY_SPACE},

    •                    //++++空格

    •                    {KEY_UP,KEY_DOWN,KEY_UP,KEY_DOWN,KEY_SPACE},

    •                    //+++

    •                    {KEY_LEFT,KEY_RIGHT,KEY_LEFT,KEY_RIGHT,KEY_SPACE},

    •          };

    代码中声明的是“二维数组”,而本节详细介绍的是“一维数组”,关于二维数组的介绍读者可以参考专业的书籍。实际上,读者可以简单的将“二维数组”看作是“一维数组中存储的数据是一维数组”。这段代码在声明二维数组的时候,还对数组进行了初始化。初始化的数据是预定义的3组组合键,从代码的注释中,读者很容易就可以看出哪些按键,及其顺序构成了组合键。但是,读者也许对于那些大些字母感到陌生,它们实际上是“整型常量”,同样需要声明在MyScript脚本中,如下:

    •          public const int KEY_UP = 0;

    •          public const int KEY_DOWN = 1;

    •          public const int KEY_LEFT = 2;

    •          public const int KEY_RIGHT = 3;

    •          public const int KEY_SPACE = 4;

    3脚本还需要声明的变量有:

    • q  实时记录玩家按下了哪些按键的变量,由于玩家肯定会按下不只一个按键,因此这里选择列表存储这类数据,如下:

    •          private List<int> playerInput;

    • q  玩家在一个时间点,按下的是何种按键:

    •          private int currentKeyDown;

    • q  玩家是否成功的按下了一组组合按键:

    •          private bool isSuccess = false;

    2.定义方法

    1在声明表示列表的变量,并不意味着就为列表变量分配了存储空间。因此,脚本需要在被初始化时,为列表分配存储空间,如下:

    •          void Start()

    •          {

    •                    playerInput = new List<int>();

    •          }

    Start()方法是Unity定义的方法,此方法会在脚本被初始化时调用,因此将为列表分配存储空间的代码置于此方法中,再合适不过。

    2在脚本中,自己定义一个方法,用于记录每一个时刻,玩家按下的指定按键,如下:

    •          void UpdateKey()

    •          {

    •                    if(Input.GetKeyDown (KeyCode.UpArrow))

    •                             currentKeyDown = KEY_UP;

    •                    if(Input.GetKeyDown (KeyCode.DownArrow))

    •                             currentKeyDown = KEY_DOWN;

    •                    if(Input.GetKeyDown (KeyCode.LeftArrow))

    •                             currentKeyDown = KEY_LEFT;

    •                    if(Input.GetKeyDown (KeyCode.RightArrow))

    •                             currentKeyDown = KEY_RIGHT;

    •                    if(Input.GetKeyDown (KeyCode.Space))

    •                             currentKeyDown = KEY_SPACE;

    •          }

    判断玩家是否按下了指定按键,可以使用if语句,如果按下的话,就将表示此按键的数据存储于变量currentKeyDown中。if语句的判断部分,是用于检测键盘上的按键是否被按下的Unity定义的方法。从此段代码中可以看出,游戏检测的按键有5个,包括键盘上的4个方向键和1个空格键。

    3Unity每帧调用的Update()方法中,添加表示下列用途的代码:

    • q  要想确保前面定义的方法UpdateKey(),在游戏中的每个时刻都被调用,最好借助于Update()方法;

    • q  脚本还需要时刻将玩家按下的按键,存储于列表中;

    • q  当列表中有5个数据的时候,就去与预定义的组合键做比较,如果一致就表示输入成功,不一致就表示输入失败;

    • q  无论失败与否,都需要将列表清空,因为列表还需要存储下一轮玩家按下的按键。

    具体的代码实现过程如下:

    • 01              void Update()

    • 02              {

    • 03                        //检测当前玩家按下的按键

    • 04                       UpdateKey ();

    • 05                        //当前有任何按键被按下的时候

    • 06                       if(Input.anyKeyDown)

    • 07                       {

    • 08                                 if(isSuccess)

    • 09                                 {

    • 10                                          isSuccess = false;

    • 11                                          playerInput.Clear ();

    • 12                                 }

    • 13                                 //将玩家按下的方向键添加到列表中

    • 14                                 playerInput.Add (currentKeyDown);

    • 15                                 //获取当前列表数据个数

    • 16                                 int listCount = playerInput.Count;

    • 17                                 //如果已经按下了5个键,就判断是否是组合键

    • 18                                 if(listCount == 5)

    • 19                                 {

    • 20                                          for(int i = 0;i < 3;i++)

    • 21                                          {

    • 22                                                   int SuccessCount = 0;

    • 23                                                   for(int j = 0;j < 5;j++)

    • 24                                                   {

    • 25                                                             int tempKey = playerInput[j];

    • 26                                                             if(tempKey == Sample[i,j])

    • 27                                                                      SuccessCount++;

    • 28                                                   }

    • 29                                                   if(SuccessCount == 5)

    • 30                                                             isSuccess = true;

    • 31                                          }

    • 32                                 }

    • 33                                 if(listCount > 5)

    • 34                                          playerInput.Clear();

    • 35                       }

    • 36              }

    4对于本游戏示例,游戏视图需要实时显示的元素有,如图5-25所示。

    • q  玩家此时按下了哪些预定义的按键,即“上、下、左、右”4个方向键中的哪一个,至于“空格”按键嘛,由于没有表示此按键的图片,所以就不显示了;

    • q  表示玩家是否按下了5个指定按键的图片,即successfail所表示的图片;

    • q  用于提示玩家有哪些组合按键的文字信息;


    5-25  游戏视图上,各元素的显示

    因为Unity是通过调用OnGUI()方法来决定,在游戏视图上绘制哪些界面元素的,因此需要将显示上面所列元素的代码,置于此方法中,如下:

    • 01              void OnGUI()

    • 02              {

    • 03                       GUILayout.BeginHorizontal();

    • 04                        //表示链表中存储的数据个数

    • 05                       int listCount = playerInput.Count;

    • 06                        //遍历链表中的所有数据

    • 07                       for(int i = 0;i < listCount;i++)

    • 08                       {

    • 09                                 //显示方向按键对应的图片到游戏视图

    • 10                                 int key = playerInput[i];

    • 11                                 Texture tempTex = null;

    • 12                                 switch(key)

    • 13                                 {

    • 14                                 case KEY_UP:

    • 15                                          tempTex = image[0];

    • 16                                          break;

    • 17                                 case KEY_DOWN:

    • 18                                          tempTex = image[1];

    • 19                                          break;

    • 20                                 case KEY_LEFT:

    • 21                                          tempTex = image[2];

    • 22                                          break;

    • 23                                 case KEY_RIGHT:

    • 24                                          tempTex = image[3];

    • 25                                          break;

    • 26                                 }

    • 27                                 if(tempTex != null)

    • 28                                          GUILayout.Label (tempTex,GUILayout.Width (70),GUILayout.Height (70));

    • 29                       }

    • 30                       if(isSuccess)

    • 31                                 GUILayout.Label (image[4],GUILayout.Width (70),GUILayout.Height (70));

    • 32                       else if(!isSuccess && listCount == 5)

    • 33                                 GUILayout.Label (image[5],GUILayout.Width (70),GUILayout.Height (70));

    • 34                       GUILayout.EndHorizontal();

    • 35                       GUILayout.Space (20);

    • 36                        GUILayout.Label ("组合键1:上、下、左、右、空格");

    • 37                        GUILayout.Label ("组合键2:上、下、上、下、空格");

    • 38                        GUILayout.Label ("组合键3:左、右、左、右、空格");

    • 39              }

    3.脚本代码概览

    前面已经详细的介绍了在脚本中,方法的声明、方法的定义,以及变量和方法对于游戏效果的意义。但是读者也许还无法将它们组合成一个整体,相信下面的脚本代码概览对读者有帮助,如下:

    • 01     using UnityEngine;

    • 02     using System.Collections.Generic;

    • 03    

    • 04     public class MyScript : MonoBehaviour

    • 05     {

    • 06              //4个方向图片,2个表示按键成功和失败的图标

    • 07              public Texture[] image;

    • 08              //自定义方向键的存储值

    • 09              public const int KEY_UP = 0;

    • 10              public const int KEY_DOWN = 1;

    • 11              public const int KEY_LEFT = 2;

    • 12              public const int KEY_RIGHT = 3;

    • 13              public const int KEY_SPACE = 4;

    • 14              //表示各组合键

    • 15              int[,] Sample =

    • 16              {

    • 17                        //++++空格

    • 18                       {KEY_UP,KEY_DOWN,KEY_LEFT,KEY_RIGHT,KEY_SPACE},

    • 19                        //++++空格

    • 20                       {KEY_UP,KEY_DOWN,KEY_UP,KEY_DOWN,KEY_SPACE},

    • 21                        //+++

    • 22                       {KEY_LEFT,KEY_RIGHT,KEY_LEFT,KEY_RIGHT,KEY_SPACE},

    • 23              };

    • 24              //记录玩家按下的所有键

    • 25              private List<int> playerInput;

    • 26              //记录当前的按键

    • 27              private int currentKeyDown;

    • 28              //表示是否成功的按下了组合键

    • 29              private bool isSuccess = false;

    • 30              //初始化脚本

    • 31              void Start()

    • 32              {

    • 33                       playerInput = new List<int>();

    • 34              }

    • 35              //获取玩家按下的方向键

    • 36              void UpdateKey()

    • 37              {

    • 38                        …                                                                       //省略

    • 39              }

    • 40              void Update()

    • 41              {

    • 42                        …                                                                       //省略

    • 43              }

    • 44              //绘制游戏视图的界面元素

    • 45              void OnGUI()

    • 46              {

    • 47                        …                                                                       //省略

    • 48              }

    • 49     }

    小结

    一款游戏,玩家可以百玩不厌,究其原因就在于游戏允许玩家通过选择,进而左右游戏剧情的发展。游戏本身则需要判断玩家做出了怎样的选择,判断的方式就是使用判断语句,因此本章介绍了ifswitch。又由于玩家有时需要从大量的数据中做出选择,例如,玩家的角色会数十种技能,要从中选择一个技能。这又涉及到大量数据的存储,因此本章介绍了数组、列表和字典。游戏本身要从大量数据中判断出玩家选择的是哪一个数据,因此最后介绍了遍历大量数据的方式,即foreachforwhile循环。本章的末尾,还以一个较大的游戏示例,展示了本章所学知识在游戏中的应用。

    本文选自:C#游戏开发快速入门大学霸内部资料,转载请注明出处,尊重技术尊重IT人!

    展开全文
  • Unity 动画结束事件

    千次阅读 2017-07-04 20:31:24
    在用Unity开发游戏 动画播到某一帧就要干什么事情. 希望能得到回调.   函数名字记得在使用这个动画的物体的脚本里面写好,否则会报错。 用你的鼠标在时间上点一下就会有一条红线。 点击事件帧 能看到插入动画...

    在用Unity开发游戏  动画播到某一帧就要干什么事情. 希望能得到回调.  

     

    函数名字记得在使用这个动画的物体的脚本里面写好,否则会报错。

    用你的鼠标在时间上点一下就会有一条红线。

    点击事件帧  能看到插入动画里。然后右键Edit Animation Event.


    会看到这个,添加一个函数名字记得在使用这个动画的物体的脚本里面写好。



    展开全文
  • Unity 游戏退出代码

    2021-06-15 19:46:01
    Unity 游戏退出代码 记录 public void OnExitGame() { #if UNITY_EDITOR//在编辑器模式退出 UnityEditor.EditorApplication.isPlaying = false; #else//发布后退出 Application.Quit(); #endif }

    在编辑模式下的退出方法以及在发布后的退出方法
        public void OnExitGame()
        {
    #if UNITY_EDITOR//在编辑器模式退出
            UnityEditor.EditorApplication.isPlaying = false;
    #else//发布后退出
            Application.Quit();
    #endif
        }
    
    展开全文
  • 本课程,结合了Unity引擎动画模块的使用技巧和C#脚本游戏逻辑的编写,学习并掌握动画设计模块的可扩展性。 课程的主要内容深度讲解了Unity Animation先关组件的具体使用方式及注意事项。同时还实例讲解了Player ...

    Unity动画系统的深度教学

    本课程,结合了Unity引擎动画模块的使用技巧和C#脚本游戏逻辑的编写,学习并掌握动画设计模块的可扩展性。

    课程的主要内容深度讲解了Unity Animation先关组件的具体使用方式及注意事项。同时还实例讲解了Player Controller、寻路与动画的配置和实用流程。

    预估学习&练习时间:16小时      难易度:进阶

    动画基础组件

    1. Unity动画简介
    2. 动画视图
    3. 动画属性
    4. 动画曲线和事件

    角色动画&操作

    1. 简介
    2. NavMesh导航网格的概念
    3. 烘焙NavMesh导航网格
    4. EventSystem事件系统
    5. AnimatorController介绍以及参数配置
    6. State动画状态机
    7. BlendTree的配置
    8. 状态过渡Transition连线条件设置
    9. 制作Player的Prefab
    10. 玩家Player的初始化代码逻辑
    11. 设计寻路过程的玩家状态
    12. 玩家Player每帧Update的游戏逻辑
    13. 实现改变寻路状态逻辑
    14. 点击响应方法实现
    15. EventTrigger关联点击方法
    16. 寻路结束与可交互对象的响应逻辑
    17. 可交互对象的点击事件

    本次课程由爪爪学 院Alex老师讲授,想要参加线下课程学习的童鞋,可参加我们每周六下午的“游戏开发‘私教营’”,线下课程除了能够快速的帮助您提升游戏开发能力,还有机会参与独立游戏项目的实战开发,欢迎到现场来参观、体验与学习。详情可搜索爪爪学 院。

    展开全文
  • 本节讲下游戏结束与重新开始的实现
  • unity 退出游戏

    2020-10-17 15:00:38
    //在 editor 模式下使用 Application.Quit()是没用的, //要用 EditorApplication.isPlaying = false;... //退出游戏 //Application.Quit(); UnityEditor.EditorApplication.isPlaying = false;
  • Unity 游戏计时

    2020-07-09 21:12:35
    (登录游戏是获取服务器当前时间:_serverTime、游戏开始到现在的时间:Time.realtimeSinceStartup、 打开游戏时记录的时间:m_UpdateTime) public int ServerTimestamp { get {return (int)(_serverTime +Time...
  • 具有强扩展性的3D冒险游戏开发实战 冒险游戏AVG是电子游戏的一种,它集中于探索未知、解决谜题等情节化和探索性的互动,强调故事线索的发掘,主要考验...本次实战项目课程,不但有Unity引擎的使用技能和C#脚本游戏...
  • 一般游戏结束后都会有个分数排名板。   接下来让分析这功能。 1.游戏结束后显示高分排列,当前玩家分数高能显示。(如果能进入排名板) 2.数据必须持久化,切换场景,关闭开启游戏都要能用。。。   流程: 游戏...
  • unity 3d游戏开发If there’s one thing cooler than playing games, it’s building games. 如果有比玩游戏更酷的一件事,那就是构建游戏。 Whether you’re building 2D games like Angry Birds, or 3D games ...
  • Unity游戏开发案例分享

    千次阅读 2018-06-20 10:04:33
    从最开始听说Unity这个游戏引擎到现在差不多一年了,在这一年中,我了解学习了Unity游戏框架,功能,组件,C#脚本,让我对游戏开发有了基本的了解。在实现这个游戏的过程中,我读了一些软件开发相关的书籍,《UML...
  • Unity游戏脚本 1、脚本操作游戏对象 1.1、创建游戏对象 创建一个空的游戏对象 GameObject obj = new GameObject("obj1"); 用该方法创建一个空的游戏对象。该游戏体的名字为GameObject的参数值并且只有一个...
  • [Unity3D]Unity3D游戏开发之跑酷游戏项目讲解

    万次阅读 多人点赞 2014-05-11 00:24:02
    大家晚上好,我是秦元培,欢迎大家关注我的博客,我的博客地址是blog.csdn.net/...所以,今天的博客的主题就是《Unity3D游戏开发之跑酷游戏项目讲解》。从博主自身来考虑这件事情,当你选择做自己热爱的事情的时
  • Unity 游戏脚本解密

    千次阅读 2016-04-12 16:48:43
    现在用Unity游戏大多都加密了Assembly-CSharp.dll, 这篇文章给出一个通用的解密方法。
  • Unity 退出游戏

    万次阅读 2019-05-27 10:34:18
     if (Input.GetKeyDown(KeyCode.Escape)){//按下ESC键则退出游戏 #if UNITY_EDITOR  UnityEditor.EditorApplication.isPlaying = false; #else  Application.Quit(); #endif  }  } }   如果...
  • Unity游戏中的图形渲染优化 转载自:Unity游戏中的图形渲染优化 技术文章翻译原文链接 Unity官方教程中的一篇文章,虽然讲得不深,但是比较系统全面,对寻找问题,优化性能还是有帮助的,分享给大家把。英语渣,...
  • 游戏结束条件:没血 实现方式: 如果没血,则游戏结束 利用挂载在主角身上的控制脚本进行计数,如果达到击杀数量就激活任务完成的提示文本 游戏结束代码: 任务完成代码: 第一部分、子弹脚本: 第二...
  • Unity4.3版本以后,Unity3D推出了基于Box2D的2D组件,使得Unity3D成为一个可以支持2D游戏开发的游戏引擎。在Unity3D推出这一功能之前,大家对使用Unity3D开发2D游戏已经进行了大量的研究。所以,Unity3D推出2D组件...
  • Unity游戏积分/计分UI系统制作方法

    千次阅读 多人点赞 2020-12-23 00:44:40
    Unity游戏积分/计分制作方法 前言: 本篇博客是我学习unity基础的最后一篇学习笔记,如果以后有实用的开发方法还是会分享出来。之后我准备制作一个具有完整客户端和服务端的游戏项目,并写一个客户端和服务端入门...
  • 本篇将游戏暂停、结束与重新开始。
  •    1*创建物体 ... 结束脚本 ... if(gameObject.transform.position.z>5... 游戏分享 https://pan.baidu.com/s/1u-WGBJbdgMpEgKjuJ9u4-A  密码 wi8w   谢谢大家关注一下 [支持原创] @ 怪体杰
  • [Unity3D]Unity3D游戏开发之截屏保存精彩瞬间

    万次阅读 多人点赞 2014-09-10 20:28:00
    作为一名热爱单机游戏的玩家,博主每次在玩游戏的同时截取游戏中比较喜欢的画面,特别是学习了Unity3D以后玩游戏的时候更多地是从一个游戏设计者的角度来看待游戏,换句话说,可能关注技术的成分更多一点吧。...
  • Unity笔记 《Unity游戏设计与实现》

    千次阅读 2015-11-10 10:52:36
    介绍了一些Unity基础。 camera控制:alt、ctrl + alt、F按键 的使用。 一个小例子不断polish的过程。 物理控制的经验: 1)避免漂浮感,调整物体大小(rigidbody 1.0 = 1米)或在PhysicsManager中提高...
  • C#开发Unity游戏教程之使用脚本变量

    千次阅读 2015-07-08 09:55:12
    C#开发Unity游戏教程之使用脚本变量
  • Unity游戏倒计时

    千次阅读 2019-04-17 10:41:35
    倒计时是游戏中经常用到的一个机制,原先也写过几次,但是都感觉比较麻烦,这次看见的简单的方法就先加下来。最后输出的是0:00这样的样式。 public class TimeManager : MonoBehaviour { private float ...
  • Unity 游戏开发技巧集锦》

    千次阅读 2015-05-21 17:28:42
    Unity 游戏开发技巧集锦》 我们的宗旨是:我们只做最专业的技术传播者!为了让广大程序员花最少的时间,掌握最新的技术! 《Unity 游戏开发技巧集锦》目录 第1章 熟悉Unity及其...
  • Unity制作飞机大战。本篇文章完整的介绍了使用Unity引擎制作一个飞机大战的小游戏,附带游戏过程,截图和讲解,最后附带工程源码,请品尝!
  • Unity退出游戏

    千次阅读 2018-10-05 17:23:27
    public void QuitApplication() { #if UNITY_EDITOR UnityEditor.EditorApplication.isPlaying=false; #else Application.Quit(); #endif }
  • unity游戏开发为什么工作这么难找

    万次阅读 多人点赞 2018-03-26 12:19:12
    在2016年年中,由于学校课程的关系,我接触了unity。从那以后,我就决定,我以后要从事游戏开发。但是,从事游戏开发是就这样说说就可以的吗?于是,我作为艺术生开始学习编程,室友嘲笑我:呵呵,你学编程?别开...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,291
精华内容 4,916
关键字:

unity游戏结束