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，存储了5个int类型的数据，各自是1、3、5、7和9。

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

• 数组名[下标];

• 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  脚本13、14行，引用列表数据的方式例如以下：

• 09                       myIntList[0]

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

• q  脚本16、17行，是列表差别于数组的用法，由于列表中能够存储的数据的个数是没有限定的；

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 ("字典中key为10的数据是：" + myDic[10]);                   //引用字典中的数据

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

• 15                       myDic[40] = "Thursday";

• 16                        Debug.Log ("字典中key为40的数据：" + 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  脚本13、14和16行。字典引用数据的形式与数组和列表一致。可是中括号“[ ]”里的数字可不是“下标”，而是“键”。

• 13                        myDic[10]

Unity中遍历大量的数据

假设须要在脚本中使用相同的操作去一一判别大量的数据。C#倒是提供了一种不错的机制。读者也许会有兴趣，就是“循环”。C#里有3种用于实现循环的语句，各自是：foreach、for和while。

本小节打算依次介绍它们的用法。最后再将这样的机制应用到游戏中。

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  脚本08、15和22行的代码。分别声明了数组、列表和字典。而且为它们初始化了3组数据；

• q  脚本09、16和24行的代码，则分别開始使用foreach语句遍历数组、列表和字典。

  以09行的语句为例：

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

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

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

• q  脚本11、18和26行的代码。分别使用if语句推断变量中的数据。是否是指定的数据。

  以11行的代码为例：

• 11                                 if(myStrArray == "Monday")

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

• q  脚本12、19和27行的代码，则表示当使用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视图中输出列表中的全部数据；12、13行的代码，是一个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  推断语句。包含if、if-else、if-else-if和switch；

• q  数据存储方式，包含数组（array）、列表（list）和字典（dictionary）；

• q  大量数据的遍历方式，包含foreach、for和while。

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

Unity游戏执行效果

本游戏想要实现的效果是：游戏会要求玩家依照顺序依次按下指定的几个按键，假设玩家成功的按下这组按键。就给出表示成功的图片提示；反之，就给出表示失败的图片提示。游戏执行效果如图5-19、5-20、5-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。本节所创建的游戏演示样例。因为是通过界面的绘制实现的，因此不须要读者继续往游戏场景里加入其他游戏对象了。

（3）在Project视图里。新建一个脚本，命名为MyScript。

本游戏的全部执行逻辑都将在此脚本中实现。

此脚本将被赋予Main Camera游戏对象。

Unity游戏脚本的编写

脚本的代码，涉及了游戏的全部执行逻辑，内容较多，就将其划分成了一个小节。本小节也因此得以为读者具体介绍脚本代码的思考和编写过程。

1.声明变量

（1）游戏项目中有6张图片，脚本会操作这6张图片，然后依照指定的游戏逻辑，将它们显示在游戏视图中。

因此脚本中须要声明存储这6张图片（数据）的变量。例如以下：

•          public Texture[] image;

既然都是图片，联想到本章所学的知识。就非常easy想到使用数组，当然读者也能够选择使用列表。

提示：Texture在Unity脚本中是表示用于存储图片这样的数据的数据类型。

由于变量被public修饰，所以它会以属性的形式，出如今Inspector视图的组件下。读者须要在此视图里，将图片作为属性值。赋予这个数组。详细的赋值方式就是拖动，即将图片从Project视图。拖动到Inspector视图。如图5-24所看到的。

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

提示：读者一定要注意数组各图片数据的排列顺序，由于后面要编写的脚本代码将直接使用下标。引用数组中存储的图片数据。

对于本演示样例。图片数组中的存储顺序是：up、down、left、right、success和fail。

（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组组合键，从代码的凝视中，读者非常easy就能够看出哪些按键，及其顺序构成了组合键。可是，读者或许对于那些大些字母感到陌生。它们实际上是“整型常量”，相同须要声明在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个空格键。

（3）在Unity每帧调用的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个指定按键的图片，即success和fail所表示的图片；

• 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     }

小结

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

本文选自：C#游戏开发高速入门大学霸内部资料，转载请注明出处。尊重技术尊重IT人！

​