南 京 工 程 学 院
毕业设计说明书(论文)
作 者： 学 号： 院 系： 专 业： 计算机科学与技术 题 目： 基于Unity的射击类游戏开发
指导者：
评阅者：
2013年6 月
毕业设计说明书（论文）中文摘要
随着虚拟现实和游戏事业的快速发展，unity3D作为一款能够快速开发和应用的3D虚拟现实开发软在市场上正在逐步升温。文本的主要内容是介绍用unity3D软件做一款简单的射击类游戏。 本文从前期的相关技术介绍、开发软件系统以及环境的介绍、项目的功能需求分析和详细设计、系统的运行、成品的打包等方面介绍了系统的开发过程。本设计主要为坦克类的射击游戏，设计平台为unity3D 3.5.5版本，系统中还用到了3dsMAX软件，photoshop软件中的一些相关技术，设计语言使用的是C#语言，系统主要实现一些模型移动、开火等基本的相关操作并在此基础上能够充分发挥开发者的能力进行更多复杂的逻辑设计。 关键字 3D技术 unity3D 射击类游戏 毕业设计说明书（论文）外文摘要
Title The shutting game implement based on Unity3D Abstract With the rapid development of virtual reality and game career, unity3D as a rapid development and application of the 3D virtual reality software on the market is gradually warming up. Main content of the text is to introduce the using unity3D software to design a simple shooting game. This paper introduces the system development process such as the related technology, the development of software system, the project function analysis and design, system implementation, system testing,. The design of the main is tank class shooting game. Th design platform is the unity3D version of 3.5.5, the system also uses 3dsMAX software. some related technologies uses Photoshop software to finish and design language is used C# language. system is mainly to achieve some model of moveing, fire and other basic related operations . on this basis,the designer also can give more abilities for more complex logic design. Keywords 3DTechnology Unity3D the shooting game 目 录
前 言 ..................................................... 1 第一章 绪论 .................................................. 2 1.1 引言 ................................................... 2 1.2 研究内容 ............................................... 2 1.3 本章小结 ............................................... 3 第二章 技术介绍 .............................................. 4 2.1 UNITY3D软件概述 ........................................ 4 2.2 C#介绍 ................................................. 4 2.3 VISUAL STUDIO 2010 ....................................... 4 2.4 PHOTOSHOP简介 ........................................... 5 2.5 3DSMAX简介 ............................................. 5 2.6 系统开发运行环境 ....................................... 5 2.8 本章小结 ............................................... 5 第三章 系统的需求分析和设计 .................................. 6 3.1 需求分析 ............................................... 6 3.2 系统的设计 ............................................. 6 3.3 本章小结 ............................................... 7 第四章 游戏系统的实现 ........................................ 8 4.1 UNITY3D软件的界面 ...................................... 8 4.2 游戏开始界面制作 ....................................... 9 4.3游戏的制作 ............................................ 13 4.4 游戏的打包和导出 ...................................... 33 4.5 本章小结 .............................................. 34 第五章 游戏的运行和改进 ..................................... 36 5.1 游戏的开始运行 ........................................ 36 5.2 游戏系统的改进 ........................................ 38 5.3 本章小结 .............................................. 38
- i -
结 论 .................................................... 39 参考文献 .................................................... 40 致 谢 .................................................... 41 附录：英文技术资料翻译 ...................................... 42
- ii -
南京工程学院毕业设计说明书（论文）
前 言
随着社会科技水平和经济水平的迅速发展，虚拟现实技术逐步的迈入人们生活，其涉及的领域十分广泛，在商业、游戏等有着惊人的发展，正因为如此Unity3D作为一款虚拟3D开发的软件正在逐步升温，他以其跨平台的优势，良好的界面环境，强大的功能设计渐渐的被广大虚拟现实的设计者们所使用。
本文详细介绍了采用unity3D软件，设计一个射击类游戏，模仿的是现实坦克的射击，并在此基础上发挥制作者的创新力和设计能力。
Unity3D开发软件是一款多平台的综合性的开发工具，Unity相似于Director,Blender game engine, Virtools等使用交互的图型化的集成开发环境为首要处理方式的软件，其编辑器能够运行在时下主流的Windows 和Mac OS X下，制作的成品可发布至Windows、Mac、Wii、iPhone以及安卓平台。该软件支持的语言包括C#，JS等高级脚本语言。其功能强大，API丰富，因此开发者们不必要去自己写相关的方法，这样就给与开发者们更多创新的时间与空间。
本游戏界面简单友好，游戏内容丰富，功能包括坦克的开炮，移动，游戏中还包括敌人，道具的获得和技能的使用等。
1
南京工程学院毕业设计说明书（论文）
第一章 绪论
1.1 引言
无论是3D化的谷歌地图，还是现在脍炙人口3D游戏，甚至是集娱乐和运动于一体的室内体感游戏，这一切都是虚拟现实技术的应用。如今的社会，不仅仅是游戏，3D技术已经被广泛的开发并且用作商业应用，比如模拟车展，火箭升空，3D旅行等，因此，在3D虚拟如此盛行的今天，用Unity3D做一款3D游戏也算是赶上时代的脉搏了。
Unity3D其开发的综合性平台和其丰富的脚本语言，开发界面友好，功能强大等有利因素，被我选择作为制作一款射击类游戏的开发工具。通过对3D游戏的设计，来充分了解虚拟现实在社会中的应用以及如何将该技术广泛的应用在各大领域。
该软件的各项功能，让我发现了很多游戏以及3D技术使用的影子。比如我们了解的第三人称与第一人称之间的来回切换，在U3D中完成这一操作仅仅只要对摄像机使用脚本语言来回切换，因为U3D丰富并强大的API使得原本在虚拟世界中看起来复杂的行为变得简单易得，这就是U3D为什么如此火的原因。
在本篇论文中，第一章主要介绍了虚拟现实的使用领域、发展和研究内容，第二章主要介绍了完成该游戏所用的到软件以及涉及到的技术知识，第三章主要介绍了系统的需求分析、系统的整体设计和详细设计，第四章主要介绍了游戏完成的整个过程、游戏的创意性设计、游戏的打包和导出。第五章主要介绍游戏运行结果。
1.2 研究内容
运用Unity3D软件，结合photoshop、3Dmax等基础的使用方法，完成一个简单的设计类游戏，该游戏涉及到得是坦克的现实模拟，能够使模型完成开火等一系列的运动方式，并在此基础上做一些创新性的实施。
2
南京工程学院毕业设计说明书（论文）
1.3 本章小结
本章主要介绍了3D虚拟技术的应用领域和现状，Unity3D开发3D游戏的优势以及本文主要的研究内容。
3
南京工程学院毕业设计说明书（论文）
第二章 技术介绍
2.1 Unity3D软件概述
Unity3D（以下简称U3D）是一款3D跨平台次世代游戏引擎。
1）提供了非常完美的跨平台系统。平台之间的差别常常会影响到产品的开发速度和进度，因此大部分开发者们要在这上面花费大量的时间，而unity则能在近10种主流平台之间完美移植。
2）提供了多种脚本语言编译的常用环境，并且可以根据需求将默认的编译环境做出调整。Unity3D支持C#、Javascript、Boo三种脚本语言。
3）提供了一个交互良好的操作界面，能够完美的在windows和Mac OS下部署。该软件自带的五个工程视图框架能够让你很好的观察你制作游戏的进程。
Unity3D丰富的API能够帮你完成各种想要完成的需求。它的界面系统能够更好的帮助设计者分类游戏中的对象。其中包括project视图，该视图主要存放游戏中的资源文件，hierarchy视图主要放置游戏场景中具体的游戏对象，inspector视图主要来描述游戏资源的信息，scene视图主要存放游戏中模型资源，game视图是用来观察已经完成的游戏运行成果。
2.2 C#介绍
Microsoft Visual C#（读作 C sharp）是一种常用的编程语言。C# 语法很简单、功能非常强大、类型相对安全，并且是面向对象的。C# 凭借着它创新的心法，在保证C 语言样式的表现方式的同时，完全实现了应用程序的相对快速的开发，该语言作为U3D中的脚本语言能够更好的符合他面向对象的特征。
2.3 Visual studio 2010
Visual studio2010（以下简称VS10）是微软公司自主推出的开发环境。
4
南京工程学院毕业设计说明书（论文）
其中它支持了最新的集成开发环境。VS10也带来了NET Framework4.0、Microsoft Visual Studio 2010 CTP并且支持开发者面向win7的应用程序开发。除了Microsoft SQL Sever，它还支持IBM，Oracle数据库等。
2.4 Photoshop简介
Adobe Photoshop，简称“PS”，是由Adobe Systems开发并发行的一款图像处理软件。Photoshop主要用来处理以像素所构成的数字图像。使用其丰富的修改编辑工具与绘图工具，可以更高效良好的进行图片编辑工作。
2.5 3dsMax简介
3D Studio Max，简称为3ds Max或MAX，是discreet公司开发的一款基于PC操作系统的三维动画渲染和三维对象制作软件。其前身是基于DOS操作系统的3D Studio软件。在windowsNET出现之前，专业级的CG制作被SGI图形工作站所垄断。3D Studio Max + Windows NT组合的出现瞬间就降低了CG制作的难度，软件初始时是运用于电脑游戏中制作动画，后进一步用于参与影视片中的特效制作。
2.6 系统开发运行环境
操作系统：Microsoft Windows XP 开发环境：Unity3D 3.5.5
开发工具：Microsoft Visual Studio 2010 Photoshop 3dsmax9.0 开发语言：C#语言
2.8 本章小结
本章主要介绍了制作射击类游戏所用到得开发工具、开发语言和所用到得相关技术以及系统开发运行的环境。
5
南京工程学院毕业设计说明书（论文）
第三章 系统的需求分析和设计
3.1 需求分析
游戏需要一个开始界面用来开始游戏、了解游戏的玩法、以及退出游戏，初始界面至少要有这三个选项。
场景的设计以及各种触发事件，并且在此基础上有所创新。
在游戏的GUI上面有主角的血条，装填炮弹，还有一些创新性的技能设计，让游戏更加丰富多彩。
游戏中还应该存在敌人，敌人会主动瞄准主角并攻击。
3.2 系统的设计
3.2.1 系统的开始界面设计
系统包括场景1和场景2。场景1中所要设计的就是游戏的开始界面。 界面中包含了3个按钮，分别完成各项功能。
按钮1）开始游戏：用来进入场景2，即进入游戏。用户只要通过鼠标按下该按钮，就可以载入所要进行的游戏。
按钮2）游戏帮助：用来进入帮助界面。帮助界面主要用来告知玩家如何进行游戏等等注意事项。为一些刚解除该游戏的玩家提供帮助。
按钮3）退出游戏：主要用来退出游戏。
3.2.2 系统的场景设计
系统中的场景2就是我们所要进行游戏的场景。场景中包含的对象有： 1）地形：对象都放在这上面。还包括一些植物和水池。
2）主角对象：这里的主角对象是一辆坦克，包括了坦克的移动、开火、还有与其相关联的GUI。
3）敌方对象：这里的对象包括的敌方的坦克，炮台等，他们都有自己的AI。
4）特殊道具：有些特殊道具可以被摧毁。有些特殊道具可以被拾取并触
6
南京工程学院毕业设计说明书（论文）
发有意思的事件。
3.3 本章小结
本章对该游戏进行了一些需求和系统的分析，整体列出来了该游戏中所要包含的一切对象，下一章就是要具体设计这些对象并给予逻辑命令。
7
南京工程学院毕业设计说明书（论文）
第四章 游戏系统的实现
4.1 Unity3D软件的界面
图4-1 Unity3D界面
Unity3D的交互界面非常友好，并且能够变换多种视图分布方式直到你找到最合适自己的分布方式。
工具栏中的window->Layouts里面有很多分布选项。
8
南京工程学院毕业设计说明书（论文）
4.2 游戏开始界面制作
图 4-2 创建工程
在制作开始界面之前，我们应该创建一个工程，在工具栏中选择File->Newproject 菜单项，之后则会弹出Project Wizard，选择Create new Project，在Project Directory中点击Set按钮设置游戏工程保存路径与项目名称，然后再点击Import the following packages中引入系统提供的标准资源包。
为了更好的将对象分类，我们首先应该在project视图中创建几个文件夹名字分别为界面，在界面字文件夹中再创建贴图文件夹，这些文件夹用来分类放置你所需要的东西。
我们在网上搜索了几张开始界面以及游戏结束的背景图，放在贴图文件夹中以便制作背景时使用。
在制作背景之前，我们首先应该将U3D默认的脚本编辑器设置为VS10，在Edit中的preference中可以设置。我们在project中创建一个C#脚本。
首先我们使用
GUI.DrawTexture(new Rect(0, 0, Screen.width,
Screen.height), textureBG)方法来给整个屏幕附上textureBG贴图，rect方法是用来创建一个矩形框，它的参数表示Rect（距离左边屏幕的距离，距
9
南京工程学院毕业设计说明书（论文）
离上边屏幕的距离，举行的宽，矩形的高），这是制作界面背景的一种方法。
然后我们使用状态机的方法来给界面设计他的执行按钮所要完成的需求。 在我们创建一个C#脚本的时候，已经默认的继承MonoBehaviour接口，因此在VS10中会自动生成两个方法，分别为void start（）函数，该函数用来给游戏刚开始时给对象赋予的操作，只在项目开始的时候执行一次，void update（）函数式在每一帧都执行这里面的代码。
我们在游戏的脚本代码中给摄像机赋予了4种状态机，分别是当前画面状态，开始后的状态，按下帮助后的状态，按下退出后的状态，分别给这些状态写了方法，即mainmenu()，helpmenu（），quitmenu（）。 具体脚本代码和结果如图4-3所示： using UnityEngine;
using System.Collections;
public class jiemian : MonoBehaviour { private const int game_main = 0; private const int game_start = 1; private const int game_quit = 2; private const int game_help = 3; public GUISkin mySkin;
public Texture textureBG;//背景贴图接口 public Texture texturetuichu;//退出贴图 public Texture texturebangzhu;
private int gamenow;//当前游戏状态
void Start () {
gamenow=game_main; }
void OnGUI() {
switch(gamenow)
{ case game_main: mainmenu(); break;
case game_start:
Application.LoadLevel(\"场景1\"); break;
case game_help: helpmenu(); break;
case game_quit: quitmenu();
10
南京工程学院毕业设计说明书（论文）
break; } }
void mainmenu() {
GUI.skin = mySkin;
GUI.DrawTexture(new Rect(0, 0, Screen.width, Screen.height), textureBG);
if (GUI.Button(new Rect(0, 20, 150, 50), \" 开始游戏\")) {
gamenow = game_start; }
if (GUI.Button(new Rect(0, 500,120,50), \"结束游戏\")) {
gamenow = game_quit; }
if(GUI.Button(new Rect(0,250,150,50),\" 帮助\")) {
gamenow=game_help; } }
void helpmenu() {
GUI.skin = mySkin;
GUI.DrawTexture(new Rect(0, 0, Screen.width, Screen.height), texturebangzhu);
if (GUI.Button(new Rect(0, 500, 150, 50), \" 返回\")) {
gamenow = game_main; } }
void quitmenu() {
GUI.skin=mySkin; GUI.DrawTexture(new
Rect(0,0,Screen.width,Screen.height),texturetuichu);
/* if(GUI.Button(new Rect(0,200,150,50),\" 返回\")) {
gamenow=game_main; }*/ }
// Use this for initialization // Update is called once per frame void Update () {} }
11
南京工程学院毕业设计说明书（论文）
脚本代码完成后，将这段脚本拖给界面中的主摄像机，如图4-3所示：
图4-3 赋予给摄像机脚本
然后单击主摄像机，会发现右下角多出了一个脚本控制，然后将刚在在脚
本中创建的图片接口用适当的图片拖入，这样就可以完成相应的界面设计了。
具体界面成果如图4-4所示：
图4-4 制作完成的界面
12
南京工程学院毕业设计说明书（论文）
4.3游戏的制作
游戏的界面已经基本完成，Unity3D中不仅有自带的按钮格式，更可以自己定义按钮的风格。在界面中我就自己定义了按钮的风格，使鼠标放在按钮上，按钮会产生一个碎裂的效果。
游戏的制作将分为三块，第一块就是场景的制作，使对象在具体的一个场景环境中活动，第二块就是对象的制作，包含场景中的静态对象和动态对象，第三块就是创新设计。
4.3.1 场景的制作
Unity中自带的平面系统能很好的为我们创建我们想到要的地形场景。 在工具栏中选择Terrain->Create Terrain便可以创建一个平面。
图 4-5 创建一个自带平面
在Terrain中的SET…..选项中可以修改平面的大小，我们在最右侧视图中
可以发现该平面的属性，在Terrain（sprict）下的几个按钮可以用来修饰平面，前三个按钮可以将平台的地势加高，加平缓，第四个按钮是用来给平面附上地形贴图，第五个按钮是用来创造树，第六个按钮是用来创造花草植物，按下Edit Details便可以为这些物体选择所需的贴图。
在刚刚创建的平面中我们发现整个场景都十分灰暗，这是就要在Create
13
南京工程学院毕业设计说明书（论文）
Object选项中的Create Other中选择Direction light来放在场景中，你会发现场景变得更加亮了。
为了让整个场景更加唯美，U3D中自带了天空盒系统（SKYBOX）， 在工具栏中选择Edit->Render Steting菜单，打开渲染设置的界面，在Skybox Material选项中设置天空盒的材质，即将天空盒包中的天空盒材质拖入其中便可。这样美轮美奂的场景就基本设置完成了。
在创建工程时我们还导入了水体的包裹，这样我们也可以在场景中还可以加入一些水体效果。
图 4-6 完成后的地形
U3D中自带的地形编辑器功能十分强大，可以打造任何你想要的场景，沙漠、雪山任何你想到的场景风格，他基本都能模拟出来。上图就是我个人制作的地形。
4.3.2 游戏对象的制作
4.3.2.1主角对象
1）主角模型
14
南京工程学院毕业设计说明书（论文）
首先我们要将玩家所要控制的对象设计出来，即主角对象，这里使用的是一款坦克模型。在网上找到相应的坦克模型的.max文件，而Unity3D（一下简称U3D）所支持的是.FBX模型，这里我将.max模型文件导入到3DSmax中，再将其的格式导出为.FBX格式，这样就可以将该模型拖入到U3D中了。
图 4-7 主角的设计
2）移动方式
在场景中调整好坦克的大小之后，就必须要给坦克主角添加行动脚本了。现实中的坦克只能往前移动，并不能左右平移，但可以原地旋转身体。
U3D中使用方法transform.Translate()来移动身体，此方法的唯一参数为平移模型的方向。使用方法transform.Rotate()来旋转身体，此方法的参数为旋转的速度和旋转方向。
具体代码为：
using UnityEngine;
using System.Collections;
public class shentiyidong : MonoBehaviour { private int speed = 10; private GameObject obj;
// private int speedrotate = 20; // Use this for initialization void Start () { }
// Update is called once per frame
15
南京工程学院毕业设计说明书（论文）
void Update() {
//if (fashe.baozoumoshi == 0) {
if (Input.GetKey(KeyCode.W)) {
transform.Translate(Vector3.forward * Time.deltaTime * speed);
}
if (Input.GetKey(KeyCode.S)) {
transform.Translate(Vector3.forward * Time.deltaTime * -speed);
}
if (Input.GetKey(KeyCode.A)) {
transform.Rotate(new Vector3(0, -2, 0));
}
if (Input.GetKey(KeyCode.D)) {
transform.Rotate(new Vector3(0, 2, 0));
} } }
将这一段脚本代码拖入到整个坦克中，就可以在场景中实现坦克的前后移动和身体的旋转，其中Vector3这是一个方向容器，其中参数表示(X轴，Y轴，Z轴)。
3）炮头旋转
之后我们来设计坦克的炮头旋转方式，方法任然为Rotate（）方法 具体代码为：
using UnityEngine;
using System.Collections;
public class Nxuanzhuanpaotou : MonoBehaviour { private int speed=100;
// Use this for initialization void Start () {
16
南京工程学院毕业设计说明书（论文）
}
// Update is called once per frame void Update () {
transform.Rotate(new Vector3(0, 0, Input.GetAxis(\"Mouse X\")) * Time.deltaTime * speed);
} }
将该段代码拖给坦克中的炮头，就可以旋转炮头了。 4）炮弹的设计与开火实现
在工具栏中选择Create Object->Create Other->sphere来创建一个球型物体，调整大小，并在网上找一些金属高亮的材质赋予给球体。在project视图中我们创建一个prefab预制对象，将场景中的炮弹球体拖入该预制对象中改名为bullet，然后删除场景中的炮弹对象。这样我们所要的炮弹就有了，之后便是发射炮弹的实现。
创建一个空的对象，在工具栏上选择Create Object->Create Empty，将该空对象拖到炮口附近，将其改名为firepoint，并将它拖入到炮头中，使其成为炮头的子对象。如图4-8所示：
图 4-8 设计完成开炮的逻辑
我们给firepoint这个空对象给与一些脚本代码来完成发射炮弹的效果。 代码如下：
if (Input.GetMouseButtonDown(0))
17
南京工程学院毕业设计说明书（论文）
{
if (canshot == 1) {
creationtime = Time.time; // Debug.Log(creationtime); Rigidbody clone;
clone = Instantiate(bullet, firePiont.rotation) as Rigidbody; clone.velocity
transform.TransformDirection(Vector3.forward * 250); Instantiate(paokouhuohua, firePiont.rotation);
canshot = 0; }
}
if (Time.time > (creationtime + 2)) {
canshot = 1; }
firePiont.position,
=
firePiont.position,
在发射炮弹的脚本代码中，我们使用了Instantiate（）方法，该方法用来实例化一个克隆对象，参数为（实例化的对象，产生的位置，产生的方向），transform.TransformDirection（）方法用来给创建的克隆实例给一个方向力，参数为力的方向。使用了GetMouseButton（0）方法来完成左键鼠标就可以实例化一个炮弹，并且按照方向发射出去。定义了一个canshot整形用来判定炮弹是否能发射。
在游戏中运行时，我们发现炮弹能够发射并且会被撞到的物体弹开，下面就是要设计炮弹的爆炸与火花。
与炮弹的设计相同，在火花效果的包中找到一个fireworks效果，调整效果至爆炸的样子，然后将它放入一个预制对象之中名字改为火花。
我们添加如下代码使得炮弹碰撞到地方就消失并且产生一个火花，火花的产生与消失。
具体代码为：
using UnityEngine;
using System.Collections;
public class paodan : MonoBehaviour { public Transform boom;
void OnCollisionStay(Collision collision) {
18
南京工程学院毕业设计说明书（论文）
Instantiate(boom, this.transform.rotation);
Destroy(gameObject); }
// Use this for initialization void Start () { }
// Update is called once per frame void Update () }
}
this.transform.position,
将这段代码拖给炮弹，目的是让炮弹碰撞到物体就消失，并且在消失的地方实例化一个火花。这里使用了OnCollisionStay（Collsion collision）方法，这是U3D中的一种碰撞检测。
火花的消失代码为：
using UnityEngine;
using System.Collections;
public class huohuaxiaoshi : MonoBehaviour {
private float creationtime; // Use this for initialization void Start () { }
void Awake() {
creationtime = Time.time; } // Update is called once per frame void Update () {
if (Time.time > (creationtime + 0.6)) {
Destroy(gameObject); } } }
Awake（）方法是在物体创建的时候记录时间用的，在创建火花到0.6秒时删除该对象，这样看起来就像是炮弹打中的地方产生火花的效果。
到此我们主角的设计基本都完成了，将主角坦克放入场景中，运行游戏的时候我们会发现主角无法停留在地形上，因为这里的坦克仅仅是一个模型，不存在碰撞效果，在工具栏中选择component->Physis->box Collider给与坦克模型一个盒子碰撞模型，调整盒子碰撞模型的大小为坦克大小，这样坦克就可以稳稳的站立在地形上了，如图4-9所示。
19
南京工程学院毕业设计说明书（论文）
图 4-9 坦克在场景中设计完成 4.3.2.2敌人对象
与主角对象一样，从网上找来一个坦克和火炮的模型，调整大小，为了降低游戏的难度，这里的敌人对象是无法移动的，但是他们会主动寻找主角并打击主角，这里就是有关对人AI的设定了。
我们任然像给与主角发射炮弹的能力来给敌人的炮头附上发射炮弹的功能，代码和主角代码如出一辙。设计敌人的关键之处就在于敌人的AI设定，以下的代码就是敌人AI的代码。
using UnityEngine;
using System.Collections;
public class dapaoAI : MonoBehaviour {
private GameObject hero;//主角对象 private int diren_distance = 150; // private GameObject paotou1; private GameObject paotou; public Rigidbody bullet;
public Transform firepointdapao; private double creationtime; private int canshot = 1;
public Transform paokouhuohua;
// Use this for initialization void Start() {
hero = GameObject.Find(\"mytank修改\");
20
南京工程学院毕业设计说明书（论文）
paotou = GameObject.Find(\"paotou\");
}
// Update is called once per frame void Update() {
if (hero == true) {
if (Vector3.Distance(this.transform.position, hero.transform.position) < diren_distance)//进入攻击范围
{
this.transform.Rotate(new Vector3(0, 1, 0)); this.transform.LookAt(paotou.transform); if (canshot == 1) {
Rigidbody clone = Instantiate(bullet, firepointdapao.position, firepointdapao.rotation) as Rigidbody;
Instantiate(paokouhuohua, firepointdapao.position, firepointdapao.rotation);
creationtime = Time.time; clone.velocity = transform.TransformDirection(Vector3.forward * 250);
canshot = 0; }
if (Time.time > (creationtime + 2)) {
canshot = 1; } } } } }
这里使用了Vector3.Distance（）方法用来检测主角是否进入敌人的攻击范围，参数为该物体的方位和相对物的方位，diren_distance就是预先设定的敌人侦查范围的大小，如果小于该侦查范围，就执行transform.LookAt（）方法，朝向主角，并发射炮弹，如图4-10所示。
21
南京工程学院毕业设计说明书（论文）
图 4-10 敌人向主角开火
这样主角坦克和敌人的设计基本就完成了。 4.3.2.3场景中一些其他对象
为了使场景的环境不显得单调，可以创作自己想要的一些其他东西在场景中，比如可以破坏的房屋，油桶，树木等，这些道具不仅仅可以丰富场景内容，也可以使用这些道具来配合游戏的创新性。
4.3.3 游戏的创新性制作
为了使游戏更具有可玩性和观赏性，在游戏中加入必要的界面设计和功能设计是必不可少的。 4.3.3.3游戏中的GUI
让主角的血量、开火的间隔、技能的设定与GUI所联动，接下来就是所要涉及到得游戏创新性设计。
使主角和敌人获得血量并且在界面上画出主角血量的多少。 脚本代码如下：
using UnityEngine;
using System.Collections;
public class xuetiaohekouxue : MonoBehaviour {
public Transform maoyan1; public Transform maoyan2; public Transform maoyan3;
22
南京工程学院毕业设计说明书（论文）
public Transform yanwu; private int life =100; public Texture2D texture; public Texture2D texture1; public Texture2D texture2; public Texture2D jinengkong; public Texture2D jinengtietu;
public Texture2D jinengfeijikong; public Texture2D jinengfeiji;
private GameObject NPC; private GameObject obj; private GameObject feiji;
private GameObject nengliangkuai;
static public string str = \"1.暴走\";
// Use this for initialization
void OnCollisionEnter(Collision collision) {
foreach (ContactPoint contact in collision.contacts) {
if (contact.otherCollider.name == \"炮弹(Clone)\")
{
life = life -5; }
if (contact.otherCollider.name == \"能量块(Clone)\") {
fashe.nengliang=fashe.nengliang +1; // Debug.Log(fashe.nengliang); // Destroy(nengliangkuai); }
if (contact.otherCollider.name == \"NPC友军坦克?\") {
fashe.canbaozoumoshi = 1;//调用fashe函数中的暴走模式º?
fashe.zhushoutishi = 1; Destroy(NPC);
23
南京工程学院毕业设计说明书（论文）
}
if (contact.otherCollider.name == \"飞机\") {
feijichansheng.kongxi = 1; Destroy(feiji); }
if (life <= 0) {
Destroy(gameObject); } } }
void OnGUI() {
GUI.Label(new Rect(0, 90, 100, 30), \"能量\"); GUI.Label(new Rect(120, 0, 80, 20), str);
GUI.Label(new Rect(250, 0, 80, 20), \"2.空袭\"); if (feijichansheng.kongxi == 1) {
GUI.DrawTexture(new Rect(250, 20, 48, 30), jinengfeiji); }
if(feijichansheng.kongxi==0) {
GUI.DrawTexture(new Rect(250, 20, 48, 30), jinengfeijikong); }
if (fashe.canbaozoumoshi == 1) {
GUI.DrawTexture(new Rect(120, 20, 45, 30), jinengtietu); }
if (fashe.canbaozoumoshi == 0) {
GUI.DrawTexture(new Rect(120, 20, 45, 30), jinengkong); }
// Debug.Log(life);
GUILayout.Label(\"生命值\"); int width=50*life/100; if (life <= 100&&life>80) {
GUI.DrawTexture(new Rect(0, 20, width, 15), texture); }
else if (life >40) {
GUI.DrawTexture(new Rect(0, 20, width, 15), texture1); }
24
南京工程学院毕业设计说明书（论文）
else if (life >= 0) {
GUI.DrawTexture(new Rect(0, 20, width, 15), texture2); } }
void Start () {
feiji = GameObject.Find(\"飞机\"); obj = GameObject.Find(\"Camera\"); fashe.nengliang = 0;
NPC=GameObject.Find(\"NPC友军坦克\");
nengliangkuai = GameObject.Find(\"能量块\"); }
// Update is called once per frame void Update () {
if (life < 80) {
Instantiate(yanwu, maoyan1.position, maoyan1.rotation); }
if (life < 60) {
Instantiate(yanwu, maoyan2.position, maoyan2.rotation); }
if (life < 30) {
Instantiate(yanwu, maoyan3.position, maoyan3.rotation); } } }
代码中给与主角的生命值为100，这里使用了一个GUI（）函数，用来在界面上画出所学要的文字，图片等，GUI（）函数每一帧都会执行。因此这里设定当血量少于100大于80则画出一张图片，当血量少于80大于40时则画出一张图片以此类推，图片的方位需要调整。这样就将血量和GUI进行了联动设计。关于发射炮弹的间隔联动也可以根据这个来设计。
当主角的血量少于0时，主角便会消失，并且跳入GAME OVER的界面。界面中存在两个按钮，一个是返回开始界面，一个是重新开始。
具体代码实现如下：
using UnityEngine;
25
南京工程学院毕业设计说明书（论文）
using System.Collections;
public class zhujiaosiwanghoujiemian : MonoBehaviour { public Texture2D texture;
// Use this for initialization void Start () { }
void OnGUI() {
GUI.DrawTexture(new Rect(0, 0, Screen.width, Screen.height), texture);
if(GUI.Button(new Rect(0,0,100,50),\"重新开始\")) {
Application.LoadLevel(\"场景1\"); }
if(GUI.Button(new Rect(0,500,100,50),\"返回开始界面\")) {
Application.LoadLevel(\"界面\"); } }
// Update is called once per frame void Update () { } }
我们在游戏场景中再添加一个摄像机并把该脚本代码拖入，但仅仅有这些代码是不够的，我们还需要一段脚本代码，用来判定主角已经死亡。
代码如下：
using UnityEngine;
using System.Collections;
public class shexiangjiqiehuan : MonoBehaviour {
public GameObject camera3; private GameObject obj;
// Use this for initialization void Start () {
camera1.active = true; camera2.active = false; camera3.active = false;
obj = GameObject.Find(\"mytank修改\"); }
// Update is called once per frame void Update()
26
南京工程学院毕业设计说明书（论文）
{
if (obj == false) {
Screen.showCursor = true; camera3.active = true; } }
敌人也给与的血量和死亡的特性，与主角得到的方式差不多，这里便不再累赘。
成果如图4-11所示：
图4-11 游戏结束时的画面
4.3.2.3主角技能的制作
给主角添加一些技能能够使游戏玩法更加丰富多彩。
第一个技能为暴走技能，触发时没有射击间隔，移动速度，旋转速度加快 在主角的fashe脚本中，我添加了如下代码，当满足条件时就可以执行：
if(baozoumoshi==1)//暴走模式下
{
if (Input.GetMouseButton(0)) {
Rigidbody clone; clone = Instantiate(bullet, firePiont.rotation) as Rigidbody; clone.velocity
27
firePiont.position,
=
南京工程学院毕业设计说明书（论文）
transform.TransformDirection(Vector3.forward * 250); Instantiate(paokouhuohua, firePiont.position, firePiont.rotation); }
if (Time.time > (creationtimebaozou +20)) {
baozoumoshi = 0; canbaozoumoshi=0;
xuetiaohekouxue.str =\"1.暴走\"; } }
if (canbaozoumoshi == 1)//暴走能触发 {
if (Input.GetKeyDown(KeyCode.Alpha1))//暴走能触发 且必须按下数字键1¹ {
xuetiaohekouxue.str = \"暴走模式中\"; baozoumoshi = 1;
guimoshi = 1;//判定GUI的画-法
creationtimebaozou = Time.time;//暴走开始的时间 } }
这里有一个判定变量canbaozoumoshi该变量是一个静态公共变量，用来记录是否能够进入暴走这个技能。为了使canbaozoumoshi能够变为1，我们添加如下一段脚本代码，使得主角碰撞到特定的物体就可以时该变量变为1，
代码如下：
void OnCollisionEnter(Collision collision) {
foreach (ContactPoint contact in collision.contacts) {
if (contact.otherCollider.name == \"炮弹(Clone)\")
{
life = life -5; }
if (contact.otherCollider.name == \"能量块(Clone)\") {
fashe.nengliang=fashe.nengliang +1; // Debug.Log(fashe.nengliang); // Destroy(nengliangkuai);
28
南京工程学院毕业设计说明书（论文）
}
if (contact.otherCollider.name == \"NPC友军坦克\") {
fashe.canbaozoumoshi = 1;//调用fashe函数中的暴走模式
fashe.zhushoutishi = 1; Destroy(NPC); }
}
这里使用了一个OnCollisionEnter（）碰撞检测函数，并且遍历了碰撞的所有对象如果有对象为炮弹（Clone），生命就减去5直到为0时主角死亡，当碰到其他特定物体时能够触发判定，这样就可以满足释放技能的条件了。为了显示技能的false和true，所有给与了技能贴图，如果技能为空时，贴图为黑白色，使用photoshop软件将图片设置为黑白色，如果技能可以使用时就贴上彩色的图片，这里使用的是GUI（）方法，用法与血条和发射炮弹的联动相似。
技能效果如图4-12所示：
图4-12 技能在游戏中的应用
第二个技能空中支援 这个技能的设计方法与其他技能不同，该技能不是在原有的坦克上面做修改，而是要重新创建飞机这个对象。
飞机的脚本代码如下：
using UnityEngine;
using System.Collections;
29
南京工程学院毕业设计说明书（论文）
public class feijichansheng : MonoBehaviour { public Transform feijipoint; public Transform feijipoint1; public Rigidbody feiji;
static public int kongxi =0; // Use this for initialization void Start () { }
// Update is called once per frame void Update() {
if (kongxi == 1) {
if (Input.GetKeyDown(KeyCode.Alpha2)) {
Rigidbody clone;
clone = Instantiate(feiji, feijipoint.position, feijipoint.rotation) as Rigidbody;
clone.velocity = transform.TransformDirection(Vector3.forward * 100);
Rigidbody clone1;
clone1 = Instantiate(feiji, feijipoint1.position, feijipoint1.rotation) as Rigidbody;
clone1.velocity = transform.TransformDirection(Vector3.forward * 100);
kongxi = 0; } } } }
我们在坦克的后方放上两个空对象，并成为坦克的子对象，这样我们就能随时随地根据坦克的方位来召唤飞机了，飞机产生5秒左右，期间会投下炸弹，炸弹的产生于上面空对象的产生方法相同，火花脚本也基本一样。
技能效果如图4-13所示：
30
南京工程学院毕业设计说明书（论文）
图4-13 技能效果图
旋转炮头这个技能与其他技能的获得方式有所不同，该技能要获得存放在油桶中的能量块，并且要集齐5个能量块才能触发该技能的使用。
4.3.3.4镜头的切换
为了满足各种视角切换，从第一人称到第三人称，从第三人称到第一人称。 代码如下：
using UnityEngine;
using System.Collections;
public class shexiangjiqiehuan : MonoBehaviour { public GameObject camera1; public GameObject camera2; public GameObject camera3; private GameObject obj;
// Use this for initialization void Start () {
camera1.active = true; camera2.active = false; camera3.active = false;
obj = GameObject.Find(\"mytank修T改?\"); }
// Update is called once per frame void Update() {
if (Input.GetKeyDown(KeyCode.C)) {
camera1.active = false;
31
南京工程学院毕业设计说明书（论文）
camera2.active = true;
}
if (Input.GetKeyDown(KeyCode.V)) {
camera1.active = true; camera2.active = false; }
if (obj == false) {
Screen.showCursor = true; camera3.active = true; } }
第三人称视角效果如图4-14所示：
图4-14 游戏视角的切换
第一人称视角效果如图4-15所示：
32
南京工程学院毕业设计说明书（论文）
图4-15 游戏视角的切换
4.4 游戏的打包和导出
游戏的设计已经基本完成，接下来就是要将游戏打包发布，在工具栏中选择File->Build Settings，在scenes In Build中可以将你需要加载的场景导入进去，这样就可以实现场景的切换，关卡的设置，在左下角可以导出的模式有PC，Android，flash，ios等等。
如图4-16所示：
33
南京工程学院毕业设计说明书（论文）
图4-16 游戏的打包以及导出格式
单击Build按钮就可以选择打包，将打包后的游戏放在相应的路径中就可以了
图4-17 完整的导出游戏
4.5 本章小结
本章详细介绍了如何制作一个游戏，从游戏的开始界面，到游戏的整体设计，细分到游戏的场景，游戏的对象，并在游戏完成的基础上加了一点创新的
34
南京工程学院毕业设计说明书（论文）
地方，角色的血条，敌人的AI，技能的实现等等。最后我们将做好的游戏打包成在PC系统下能够运行的游戏，至此我们的游戏制作已经基本完成了。
35
南京工程学院毕业设计说明书（论文）
第五章 游戏的运行和改进
5.1 游戏的开始运行
我们找到在上一章打包的游戏并双击打开，如图5-1所示：
图5-1 游戏的基本设置
在界面中可以选择游戏的分辨率，是否为窗口化，渲染效果等选项，在Input选项窗口中可以调整游戏的按键。
如图5-2所示：
36
南京工程学院毕业设计说明书（论文）
图5-2 按键修改
单击Play按钮，刚刚我们所设计的游戏就可以开始运行了。
图5-3 游戏的开始界面
37
南京工程学院毕业设计说明书（论文）
5.2 游戏系统的改进
游戏的基本功能已经完成，但是因为人数和时间的限制，只制作了一个关卡，美工方面也略有不足，细节表现的也不是很完美，仅仅只是用了Unity3D很少一部分的功能完成的游戏，因此必须要在以后的工作中慢慢完善游戏。
5.3 本章小结
本章主要介绍了如何打开制作的游戏，并且如何设置游戏的画面，按键等等以及总结了一些游戏的不足之处。
38
南京工程学院毕业设计说明书（论文）
结 论
本论文主要介绍了射击类游戏的整个开发过程，包括系统开发准备和相关技术介绍、系统需求分析、系统的整体和详细设计、游戏的开始运行和改进之处等等。
这款设计类游戏系统基本完成了预期的功能，模型使用的是坦克，游戏有自己的开始界面，包含了退出，帮助，开始游戏等功能，具体实现了坦克的移动、坦克的射击、敌人的设计还包括了一些创新，比如血条和炮弹发射的联动，还设计了一些技能来丰富游戏的玩法，关卡的变换才，场景的设计等等。
本系统界面简单友好、功能齐全、操作方便，经过多次测试，排除了一些问题。游戏运行稳定，unity3D打包的游戏具有一定的安全性，但还有一些不足之处，场景细节描述不够完美，关卡过于单一，游戏的美工也比较粗糙，模型也是从网上导入等，这些问题将在今后的工作中进一步完善。
39
南京工程学院毕业设计说明书（论文）
参考文献
[01] 梅纳德．Unity游戏开发实战．机械工业出版社，2012 [02] 宣雨松．Unity 3D游戏开发．人民邮电出版社，2012
[03] 程明智，王一夫．Unity游戏开发技术．国防工业出版社，2012 [04] 吴亚峰，于复兴．Unity 3D游戏开发技术详解与典型案例．人民邮电出版社，2012
[05] 明日科技. C#从入门到精通. 清华大学出版社，2012
[06] 曾建超, 俞志.虚拟现实的技术及其应用【M】.清华大学出版社,1996 [07] 倪乐波, 戚鹏, 遇丽娜. Unity3d产品虚拟展示技术的研究与应用[J]. 数字技术与应用, 2010年09期
[08] 郭海新. Unity3D与HTML交互吉利的研究[J].煤炭技术,2011年 09期 [09] 林荣荣. 虚拟仿真技术在网络教学中的应用. 科技信息,2011年21期 [10] Daniel Schuller著. 《c# Game Programming For Serious Game Creation》 ,2010 格式
40
南京工程学院毕业设计说明书（论文）
致 谢
在整个毕业设计过程中，老师一直非常关心我们的毕业设计，督促我每个星期都要记录好完成情况，并且每一周都会和我们进行交流，针对我们设计的成果提出宝贵的建议。每次老师都非常认真的审核和批阅我们提交的设计内容，并耐心的指导和帮助我们。老师给与我们的帮助使我们受益匪浅，她认真的态度是我们学习的榜样。
成功的完成了毕业设计，除了要感谢老师，还有跟我一组的同学，他们给了我十分宝贵的意见，并积极的和我讨论研究该课题，当然也有很多网络上的匿名朋友，他们也提供给我珍贵的资料，让我能尽快的掌握软件的各种功能。最后再次衷心感谢给过我帮助的所有人。
41
南京工程学院毕业设计说明书（论文）
附录：英文技术资料翻译
英文原文：
Unity Temple
Creating Scenes
Scenes contain the objects of your game. They can be used to create a main menu, individual levels, and anything else. Think of each unique Scene file as a unique level. In each Scene, you will place your environments, obstacles, and decorations, essentially designing and building your game in pieces. Instancing Prefabs
Use the method described in the last section to create a Prefab. You can also read more details about Prefabs here. Once you've created a Prefab, you can quickly and easily make copies of the Prefab, called an Instance. To create an instance of any Prefab, drag the Prefab from the Project View to the Hierarchy or Scene View. Now you have a unique instance of your Prefab to position and tweak as you like. Adding Component & Scripts
When you have a Prefab or any GameObject highlighted, you can add additional functionality to it by using Components. Please view the Component Reference for details about all the different Components. Scripts are a type of Component. To add a Component, just highlight your GameObject and select a Component from the Component menu. You will then see the Component appear in the Inspector of the GameObject. Scripts are also contained in the Component menu by default Placing GameObjects
Once your GameObject is in the scene, you can use the Transform Tools to position it wherever you like. Additionally, you can use the Transform values in the Inspector to fine-tune placement and rotation.
42
南京工程学院毕业设计说明书（论文）
Please view the Transform Component page for more information about positioning and rotating GameObje Working with Cameras
Cameras are the eyes of your game. Everything the player will see when playing is through one or more cameras. You can position, rotate, and parent cameras just like any other GameObject. A camera is just a GameObject with a Camera Component attached to it. Therefore it can do anything a regular GameObject can do, and then some camera-specific functions too. There are also some helpful Camera scripts that are installed with the standard assets package when you create a new project. You can find them in Components->Camera-Control from the menu. There are some additional aspects to cameras which will be good to understand. To read about cameras, view the Camera component page. Lights
Except for some very few cases, you will always need to add Lights to your scene. There are three different types of lights, and all of them behave a little differently from each other. The important thing is that they add atmosphere and ambience to your game. Different lighting can completely change the mood of your game, and using lights effectively will be an important subject to learn. To read about the different lights, please view the Light component page. Create Rough Asset
Use any supported 3D modeling package to create a rough version of your asset. Our example will use Maya. Work with the asset until you are ready to save. For a list of applications that are supported by Unity, please see this page. Import
When you save your asset initially, you should save it normally to the Assets folder in your Project folder. When you open the Unity project, the asset will be detected and imported into the project. When you look
43
南京工程学院毕业设计说明书（论文）
in the Project View, you'll see the asset located there, right where you saved it. Please note that Unity uses the FBX exporter provided by your modeling package to convert your models to the FBX file format. You will need to have the FBX exporter of your modeling package available for Unity to use. Alternatively, you can directly export as FBX from your application and save in the Projects folder. For a list of applications that are supported by Unity, please see this page. Import Settings
If you select the asset in the Project View the import settings for this asset will appear in the Inspector. The options that are displayed will change based on the type of asset that is selected Adding Asset to the Scene
Simply click and drag the mesh from the Project View to the Hierarchy or Scene View to add it to the Scene. When you drag a mesh to the scene, you are creating a GameObject that has a Mesh Renderer Component. If you are working with a texture or a sound file, you will have to add it to a GameObject that already exists in the Scene or Project. Transparent Properties
This shader can make mesh geometry partially or fully transparent by reading the alpha channel of the main texture. In the alpha, 0 (black) is completely transparent while 255 (white) is completely opaque. If your main texture does not have an alpha channel, the object will appear completely opaque.
Using transparent objects in your game can be tricky, as there are traditional graphical programming problems that can present sorting issues in your game. For example, if you see odd results when looking through two windows at once, you're experiencing the classical problem with using transparency. The general rule is to be aware that there are some cases in which one transparent object may be drawn in front of another in an unusual way, especially if the objects are intersecting,
44
南京工程学院毕业设计说明书（论文）
enclose each other or are of very different sizes. For this reason, you should use transparent objects if you need them, and try not to let them become excessive. You should also make your designer(s) aware that such sorting problems can occur, and have them prepare to change some design to work around these issues Normal Mapped Properties
Like a Diffuse shader, this computes a simple (Lambertian) lighting model. The lighting on the surface decreases as the angle between it and the light decreases. The lighting depends only on the this angle, and does not change as the camera moves or rotates around.
Normal mapping simulates small surface details using a texture, instead of spending more polygons to actually carve out details. It does not actually change the shape of the object, but uses a special texture called a Normal Map to achieve this effect. In the normal map, each pixel's color value represents the angle of the surface normal. Then by using this value instead of the one from geometry, lighting is computed. The normal map effectively overrides the mesh's geometry when calculating lighting of the object. Creating Normal maps
You can import a regular grayscale image and convert it to a Normal Map from within Unity. To learn how to do this, please read the Normal map FAQ page.
Technical Details
The Normal Map is a tangent space type of normal map. Tangent space is the space that \"follows the surface\" of the model geometry. In this space, Z always points away from the surface. Tangent space Normal Maps are a bit more expensive than the other \"object space\" type Normal Maps, but have some advantages: Diffuse Properties
Diffuse computes a simple (Lambertian) lighting model. The lighting on
45
南京工程学院毕业设计说明书（论文）
the surface decreases as the angle between it and the light decreases. The lighting depends only on the this angle, and does not change as the camera moves or rotates around. Web Player Streaming
Streaming Web Players allow your Web Player games to begin playing as soon as Scene 0 is finished loading. If you have a game with 10 levels, it doesn't make much sense to force the player to wait and download all assets for levels 2-10 before they can start playing level 1. When you publish a Streaming Web Player, the assets that must be downloaded will be sequenced in the order of the Scene file they appear in. As soon as all assets contained in Scene 0 are finished downloading, the Web Player will begin playing.
Offline webplayer deployment
If the Offline Deployment option is enabled for a webplayer then the UnityObject.js file (used to interface the player with the host page) will be placed alongside the player during the build. This enables the player to work with the local script file even when there is no network connection; normally, UnityObject.js is downloaded from Unity's webserver so as to make use of the latest version. Building standalone players
With Unity you can build standalone applications for Windows and Mac (Intel, PowerPC or Universal, which runs on both architectures). It's simply a matter of choosing the build target in the build settings dialog, and hitting the 'Build' button. When building standalone players, the resulting files will vary depending on the build target. On Windows an executable file (.exe) will be built, along with a Data folder which contains all the resources for your application. On Mac an app bundle will be built, containing the file needed to run the application, as well as the resources.
Distributing your standalone on Mac is just to provide the app bundle
46
南京工程学院毕业设计说明书（论文）
(everything is packed in there). On Windows you need to provide both the .exe file and the Data folder for others to run it. Think of it like this: Other people must have the same files on their computer, as the resulting files that Unity builds for you, in order to run your game. Inside the build process
The building process will place a blank copy of the built game application wherever you specify. Then it will work through the scene list in the build settings, open them in the editor one at a time, optimize them, and integrate them into the application package. It will also calculate all the assets that are required by the included scenes and store that data in a separate file within the application package. Any GameObject in a scene that is tagged with 'EditorOnly' will be not be included in the published build. This is useful for debugging scripts that don't need to be included in the final game.
When a new level loads, all the objects in the previous level are destroyed. To prevent this, use DontDestroyOnLoad() on any objects you don't want destroyed. This is most commonly used for keeping music playing while loading a level, or for game controller scripts which keep game state and progress.
• After the loading of a new level is finished, the message:
OnLevelWasLoaded() will be sent to all active game objects.
• For more information on how to best create a game with multiple
scenes, for instance a main menu, a high-score screen, and actual game levels, see the Scripting Tutorial.pdf
Texture Compression
Under Build Settings you'll also find the Texture Compression option. By default, Unity uses ETC1/RGBA16 texture format for textures that
47
南京工程学院毕业设计说明书（论文）
don't have individual texture format overrides (see Texture 2D / Per-Platform Overrides).
If you want to build an application archive (.apk file) targeting a specific hardware architecture, you can use the Texture Compression option to override this default behavior. Any texture that uses texture format overrides will be left alone; only textures set to Automatic Compressed will use the format selected in the Texture Compression option
To make sure the application is only deployed on devices which support the selected texture compression, Unity will edit the AndroidManifest to include tags matching the particular format selected. This will enable the Android Market filtering mechanism to only serve the application to devices with the appropriate graphics hardware. Preloading
Published builds automatically preload all assets in a scene when the scene loads. The exception to this rule is scene 0. This is because the first scene is usually a splashscreen, which you want to display as quickly as possible. To make sure all your content is preloaded, you can create an empty scene which calls Application.LoadLevel(1). In the build settings make this empty scene's index 0. All subsequent levels will be preloaded.
You're ready to build games
By now, you have learned how to use Unity's interface, how to use assets, how to create scenes, and how to publish your builds. There is nothing stopping you from creating the game of your dreams. You'll certainly learn much more along the way, and we're here to help.
48
南京工程学院毕业设计说明书（论文）
中文译文：
Unity 圣典
创建场景
场景包含你的游戏中的对象，它们可用于创建一个主菜单、独立关卡（是这个意思吗？）和其他任何东西。可以将每一个独特的场景文件想象成一个独特的关卡，在每个场景中，你可以放置你的环境、障碍和装饰物，用这些碎片拼凑，设计，创建你的游戏。 实例化预置
使用上一节描述的方法创建一个预置，你也可以在这里阅读更多有关预置的细节。一旦你创建了一个预置，您可以快速方便地创建一个预置的副本，称之为一个实例。要创建任意预置的实例，从项目视图中拖动预置到层次视图或场景视图中即可。现在你有了一个预置的唯一实例，按照你喜欢的模样定位和调整它。
添加组件和脚本
当你有一个预置或高亮的游戏对象，你可以通过使用组件为它添加额外的功能，请查看组件参考了解关于所有不同组件的详细资料。脚本也是一种组件。要添加一个组件，只需高亮游戏对象，然后从组件菜单中选择一个组件，你将会看到组件出现在对象的检视视图中。脚本也包含在默认组件菜单中。 如果添加一个组件破坏了游戏对象和预置之间的关联，你始终可以通过菜单GameObject->Apply Changes to Prefab重新建立连接。 放置游戏对象
一旦你的游戏对象在场景中，你可以使用变换工具来把它放到任何你喜欢的地方。此外，你可以在检视视图中使用Transform值来微调它的位置和旋转角度。查看更多关于定位和旋转游戏对象的信息Transform Component pagects. 使用相机
相机是游戏的眼睛。玩家看到的一切都是通过一个或多个摄像机播放的。你可以像其他游戏对象一样定位、旋转、及parent摄像机。相机只是一个附加了相机组件的游戏对象。因此，它可以做任何普通游戏对象可以做的事情，并且还有一些相机特有的功能。还有一些有用的摄像机脚本，它们是在你创建一个新工程时随标准资源包一起安装的。你可以通过菜单
49
南京工程学院毕业设计说明书（论文）
Components->Camera-Control找到它们。要了解如何更好地使用相机，请查看Camera component page。 光源
除了一些极少数的情况，你总是需要为你的场景添加光源。有三种不同类型的光源，它们的表现有所不同，重要的是，它们能为你的游戏增加气氛和氛围。不同的光源可以完全改变你的游戏的情境，有效地利用光源将是一个重要的学习课题。要了解有关不同的光源，请查看Light component page。 资源工作流程
这里我们讲解Unity的单一资源的使用步骤，这些步骤是通用的且仅作为基本动作的概述，例如，我们将讨论如何使用一个三维网格。 创建粗糙资源
使用任何Unity所支持的3D建模软件来创建一个粗制版资源，我们的例子将使用Maya，使用资源工作，直到你准备好保存。要查看Unity所支持的应用程序列表，请参阅这个页面。 导入
当你最初保存你的资源时，你应该将它保存到项目文件夹的资源文件夹中，当你打开Unity的项目，资源将被检测并导入项目中，查看项目视图，你会看到保存的资源已经在那里了。请注意，Unity使用FBX输出模型组件把你的模型转换为FBX文件格式。你需要有Unity可使用的FBX输出模型组件，或者，你可以从应用程序直接导出为FBX并保存在项目文件夹中。要查看Unity所支持的应用程序列表，请参阅这个页面。 导入设置
如果你在项目视图中选中一个资源，该资源的导入设置将出现在检视面板中，其中显示的可以改变的选项是以选中的资源类型为基础的。 添加资源到场景中
只需从项目视图点击拖动网格层次视图或场景视图就可将其添加到场景中。当你将其拖动到场景中时，你就已经创建了一个具有网格渲染器组件的游戏对象。如果你要使用一个纹理或声音文件，你必须将它添加到一个已存在于场景或项目中的游戏对象上。 透明属性
50
南京工程学院毕业设计说明书（论文）
这个着色器能够通过读取主要贴图纹理的alpha使网格几何体部分或者全部透明。在alpha表达中，0（纯黑）代表完全透明而255（纯白）代表完全不透明。如果你的主要贴图纹理不含有alpha则对象就完全不透明显示。
在游戏中使用透明对象可能会比较棘手，因为传统图形编程中的一些问题会在你的游戏中出现。例如，如果你在透过两个窗子观察看到奇怪的结果时，你在体验使用透明的的经典问题。一般的规则是要知道有些情况下在一个透明对象前面绘制另外一个透明对象的时候会出现不正常的现象，特别是在透明对象相交、互为包含或者尺寸上有着很大的差异。因此，如果你需要使用透明对象，要注意不要让它们过大。你也需要告诉美工师这些问题让他们在设计上做出适当的修改。 法线贴图属性
类似于漫反射着色器，这是一个简单的（兰伯特）光照模型。对象表面上的光照随着与入射光夹角的减小而减小。光照效果只与这个夹角有关，与摄像机的移动位置与旋转角度无关。
法线映射使用纹理贴图来模拟表面细节，而不是使用更多的多边形真正的雕刻出来。它没有真正的改变对象的形状，而是使用了一种命名为法线贴图的特殊纹理贴图获得效果。在法线贴图中，每个像素的颜色值代表了表面法线的角度。光照根据这个贴图来计算入射角度而不是真正的参考光源与对象的关系。法线贴图在进行对象光照计算时有效的节省了几何体的网格数。 创建法线贴图
你可以输入一个常规的灰度图像并在Unity中将它转化成法线贴图。想学习如何做到这一点，可以参考Normal map FAQ page（法线贴图常见问题页面）。 技术细节
法线贴图是切线空间类型，切线空间是指“沿着表面变化”的空间。在这个空间中，Z轴总是从表面指向外面的。切线空间法线贴图会比其它“对象空间”类型的法线贴图昂贵一点（指资源消耗方面---译者注），但有着些许优势。 漫反射属性
漫反射运算是一个简单的（兰伯特）光照模型。对象表面上的光照随着与入射光夹角的减小而减小。光照效果只与这个夹角有关，与摄像机移动位置与旋转角度无关
51
南京工程学院毕业设计说明书（论文）
网络流媒体播放器
流媒体播放器使你的网页游戏完成加载就立即开始播放场景0。如果你的游戏有10个关卡，并没有多大意义，这将迫使玩家要等待下载完2-10所有关卡，才可以开始玩第一关。当你发布了一个网页游戏，要让下载完的必需资源尽快按顺序出现在场景文件中，场景0所包含的资源一经加载完成，则游戏开始。 离线部署网络播放器
如果一个网络播放器离线部署选项被开启，UnityObject.js文件，（使用带有主页的播放器）播放器编译时被放置在一起。这个启用，播放器带有本地脚本文件正常工作，即使没有网络连接；通常UnityObject.js从Unity的服务器下载，因此，确保最新版本。 创建独立游戏
使用Unity你可以创建可用于Windows和Mac系统（Intel, PowerPC or Universal，在这两种架构上运行）的独立应用程序，只需在创建设置对话框中选择目标，并按下了\"Build\"按钮。当创建独立游戏时，产生的文件将因不同的目标而决定。在Windows系统中将创建可执行文件（.exe），以及一个数据文件夹，其中包含所有应用程序的资源。在Mac系统中将创建一个应用程序包，包含程序运行所需要的文件及资源。（Intel、PowerPc、Universal在这里是指Mac系统使用的处理器。Intel英特尔不用说了，地球人都知道；PowerPc是由IBM、苹果、摩托罗拉联合开发的处理器；Universal则是通用处理器） 内部生成过程
在创建过程中将会把一个游戏程序的空白副本放到你指定的地方。然后，将通过使用发布设置中的场景列表，在编辑器中依次打开它们，对其进行优化，整合到程序包中。它还将计算包括场景在内的所有资源数据，并存储到程序包里一个单独的文件中。
任何一个标有'EditorOnly'标签的游戏对象将不包含在发布的作品中，这对于调试那些不需要包含在最终游戏里的脚本是非常有用的。
当加载一个新的关卡时，所有上一关的对象将被销毁。为了防止这种情况，在你不想破坏的对象上使用DontDestroyOnLoad( )函数，这是最常用的方式，可以将它用于加载一个关卡时保持音乐播放，或用于保存游戏状态和进度的控制脚本。
52
南京工程学院毕业设计说明书（论文）
何以最佳方式创建一个多场景游戏，例如一个主菜单，一个记分屏，和当前关卡显示，请参阅Scripting Tutorial.pdf 纹理压缩
在编译设置，你还会发现纹理压缩选项。默认，Unity为没有单独的纹理格式重写的纹理，使用ETC1/RGBA16纹理格式。
如果你想生成一个应用程序包（.apk 文件）针对一个特定的硬件架构，可以使用纹理压缩来覆盖默认的行为。任何纹理使用纹理格式覆盖将保留格式；仅纹理设置为自动压缩将使用纹理压缩选项中选择的格式。
确保应用程序部署的设备支持选择的纹理压缩格式，Unity将编辑AndroidManifest包含标签匹配所选的特定格式。这将启用 Android Market filtering mechanism 过滤机制，仅用于带有相应图形硬件的设备启用应用程序。 预加载
发布的作品将在加载场景时自动预装场景中的所有资源， scene 0是例外，这是因为第一个场景通常是一个启动画面，你要尽可能快地显示它。
要想确保所有内容完成预加载，你可以创建一个空场景调用Application.LoadLevel（1），在发布设置里让这个空场景的索引为0，这样所有后续关卡将会预加载。 你已准备好建立游戏了
现在，你已经学会如何使用Unity的界面，如何使用资源，如何创建场景，以及如何发布你的作品。没有什么能够阻止你创建游戏的梦想。你一定沿途已经学到了很多，我们在这里提供帮助。
53
因篇幅问题不能全部显示，请点此查看更多更全内容