unity3d FPS游戏教程2

FPS游戏教程2

Part 2: Enhancements第二部分增强

This intermediate-level tutorial

extends upon the Basic FPS tutorial

by introducing game elements such

as multiple weapons, damage and

enemies.

这个中级教程是FPS基本教程的扩展，介绍游

戏元素例如多种武器、毁伤和敌人。

Prerequisites

This tutorial assumes that you are familiar with the Unity interface and basic scripting concepts. Additionally, you should already be familiar with the concepts discussed in

Part 1 of the FPS tutorial series.

这个指南已经默认了你已经熟悉了Unity界面和基本的脚本概念。你已经熟悉了第一部分的FPS 概念的讨论。

Before we begin -level setup

在我们开始层面设置之前

Download FPS_Tutorial.zip, unzip, and open the project folder in Unity. If you

have completed Part 1, then unzip the files to a new folder.

下载FPS_Tutorial.zip解压缩并且在U你体验中打开项目，如果你有已完成的第一部分，这时解压缩它们到一个新的目录。

Import the Standard Assets Unity Package.

导入Standard Assets标准资源包

Add the mainLevelMesh and FPS controller prefab to the scene.

增加mainLevelMesh和FPS控制预制物体到场景中。

NOTE In this tutorial no new scripts need to created. We’ll be using the ones that

were downloaded from the Unity Package.

注意在这个指南中没有新的脚本需要建立，我们将使用下载的Unity软件包中的一些东西。

Weapon switching 武器开关

Before we discuss how to create each individual weapon, we need to write some code to manage how the weapons are initialized and switched from one to another. Let’s look at the Javascript for PlayerWeapons.js:

在我们讨论如何建立每一个个体的武器之前，我们需要写一些代码以便管理这些武器怎么被初始化并且能被另一个（武器）关闭，让我们看一下PlayerWeapons.js:这个脚本代码：

This function initializes weapon 0 as the default weapon.

这个函数初始化武器0 为缺省的武器。

This function detects keyboard input; the fire button, the “1” button for weapon 1 or the “2” button for weapon 2. The weapons will be children objects of the Main Camera.

这个函数检测键盘输入；开火按钮，?1?按钮是武器1，?2?按钮时武器2。武器将被作为主照相机的子对象。

This activates the corresponding weapon depending on keyboard input.

Let ’s use the above code.

激活响应的武器依赖键盘输入，让我们看上面的代码

Create an empty game object called Weapons. Move this so that it is a child object

to Main Camera (inside FPS controller). Our weapons will be added as children

of this object.

建立一个空的叫?Weapons ?的游戏对象，移动它以便将它作为主照相机的子对象（在FPS 控制器内），我们的武器将被增加为它的子对象。

Assign the PlayerWeapons.js script to the Weapons game object under Main

Camera.

分配PlayerWeapons.js 脚本到主照相机下的Weapons 游戏对象上。

We ’ll now create our first weapon.

我们将建立我们的第一个武器

Rocket Launcher 火箭发射器

This section will describe how to make a rocket launcher style weapon.

这一节将描述如何制造一个火箭发射器类型的武器

Launcher 发射器

The rocket launcher is responsible for instantiating a rocket and giving it an initial velocity. The rocket will be launched directly at wherever the user is pointing and will be destroyed

whenever it collides with another collider.

这个火箭发射器将承担初始化一个火箭并且给它一个初始速度的任务。这个火箭将被发射到用户指定的任何地方并且当它另一个碰撞器发生碰撞时火箭随即被销毁。

Add an empty game object and name it RocketLauncher. Position the game object in the approximate position where the FPS Controller’s hands would be.

增加一个空的游戏对象并且命名它为RocketLauncher。定位游戏对象到FPS控制器的手的附近

Add the RocketLauncher as a child to the Weapons game object inside the Main Camera in the Hierarchy View. This allows us to shoot wherever the camera is pointing and also makes sure that the RocketLauncher game object follows the FPS Controller as it moves around (as Main Camera is a child of FPS Controller).

在层次面板视窗中的主照相机的Weapons游戏对象上增加RocketLauncher子对象。

Click on Objects/weapons/rocketLauncher in the Project window and make sure

that the FBXImporter Scale Factor is set to 1, otherwise the model will import at

a very small scale.

在项目窗口中单击Objects/weapons/rocketLauncher并且确保使FBXImporter Scale Factor （比例因子）被设置为1，否则模型将以一个非常小的比例被导入

Drag Objects/weapson/rocketLauncher model so that it is a child of the RocketLauncher game object.

拖拽Objects/weapson/rocketLauncher模型以便它作为RocketLauncher游戏对象的子对象。The code for the RocketLauncher.js script is as follows:

随后是RocketLauncher.js的脚本代码：

var projectile : Rigidbody;

var initialSpeed = 20.0;

var reloadTime = 0.5;

var ammoCount = 20;

private var lastShot = -10.0;

function Fire ()

{

// Did the time exceed the reload time?难道时间超过重载时间了？

if (Time.time > reloadTime + lastShot && ammoCount > 0)

{

// create a new projectile, use the same position and rotation as the Launcher.

//就像发射器一样，在同样的位置建一个新的发射体

var instantiatedProjectile : Rigidbody = Instantiate (projectile,

transform.position, transform.rotation);

// Give it an initial forward velocity. The direction is along the z-axis of

// the missile launcher's transform.

//给它一个初始方向速度，沿着导弹发射器的Z轴

instantiatedProjectile.velocity = transform.TransformDirection(

This code ensures that the weapon can’t fire faster than reloadTime. It also checks that

the user can fire only when they have sufficient ammo.

这段代码确保了武器开火速度不能比重装（弹药）的时间还快，它还可以检查用户是否有足够的弹药开火

The behavior for the RocketLauncher is similar to that in the previous FPS tutorial with the exception of the reload time and ammo count described above.

这个RocketLauncher的行为与以前的FPS教程中的相似，除了上面所说的重载时间和弹药计数以外。

that you are not attaching this script to the rocketLauncher child game object.

附加RocketLauncher.js脚本到RocketLauncher游戏对象上，要确保你不是把脚本附加到rocketLauncher子游戏对象上了。

Rocket 火箭

We will now build the rocket in the scene and upload the final version to a prefab.

我们现在在场景中构建火箭并且上载最后的版本到一个预制物体上。

FBXImporter Scale Factor is set to 1, otherwise the model will import at a very small scale.

在项目窗口的Objects/weapons/rocket上单击并且确保FBXImporter Scale Factor（比例因子）

被设置为1，模型将以一个非常小的比例被导入

拖拽Objects/weapons/rocket模型到场景视窗中。

附加WeaponScripts/Rocket.js脚本给它

the actual rocket to prevent tunneling of collisions. Tunneling of collisions is what happens when small, fast game objects avoid collision detection due to their size and speed. Making the box collider z-axis larger ensures collisions work correctly for these objects.

增加一个盒子碰撞器给火箭游戏对象。使盒子碰撞器稍稍大于实际的火箭，以阻止穿透碰撞。

当碰撞器很小时穿透碰撞就会发生，快的游戏对象避免碰撞检测取决于它们的尺寸和速度，使得盒子碰撞器的在Z轴变得更大以确保这些对象的碰撞工作能正确的发生。

In the Rigidbody of the rocket game object, deselect Use Gravity. This ensures that the rocket does not fall under gravity.

在火箭游戏对象的刚体中，不选择使用Use Gravity选项，这能确保火箭不会再重力作用下坠落。

Create a particle system: Game Object >Create Other >Particle System.

建立一个粒子系统：Game Object >Create Other >Particle System

Modify the Ellipsoid x,y,z sizes to 0.1.

编辑Ellipsoid的X、Y、Z的尺寸到0.1

Modify the Rnd Velocity to 0.1 in each axis also.

编辑Rnd Velocity的每个轴向数据到0.1

Change the particle emitter Min Size and Max Size to 0.5.

改变例子发射器的最小尺寸和最大尺寸到0.5

Change the number of particles emitted to 100 (Min and Max Emission).

改变粒子发射器的数目到100（最小和最大排放物数目）

Drag the Particle Effects/smoke onto the particle system.

拖拽粒子效果/烟雾到粒子系统上

In the Particle Animator section, set each of the World Rotation Axis values to 0.5.

在例子的动画片段，设置每个世界旋转轴的坐标值为0.5

Set the Size Grow variable to 3.

设置尺寸生长变量到3

Enable Autodestruct on the particle system. This ensures that the particle system is removed from the game after the rocket has been destroyed.

选中粒子系统中的自毁选项，这能确保在火箭被销毁以后粒子系统也能被从游戏中删除

Drag the particle system in the Hierarchy View so that it is a child of the rocket. Reset the transform of the particle system so that it is centred on the rocket,then modify the position so that it is at the rear of the rocket.

在层次视窗中拖拽粒子系统以便它作为火箭的一个子对象，重设粒子系统的transform以便它位于火箭的中心，然后编辑它的位置让它靠近火箭。

Select the rocket in the Hierarchy view and check that the smoke trail follows it around in the Scene view if you move it around.

在层次视窗中选择火箭并且在周围移动它，在场景视图中检查烟尾。

We’ve now made our rocket, complete with smoke trail. We’re now ready to upload

our changes to the prefab.

我们现在制造火箭，完成烟尾.准备上载（火箭）到预制物体中。

Firstly, create an empty prefab to upload our changes to. Call the prefab ‘Rocket’. 首先，建立一个空的预制物体以上载我们的改变，叫预制物体为‘Rocket’

Select the rocket in the Hierarchy view and drag it onto the new Rocket prefab.

在层次面板视窗中选择火箭并且拖动它到新的火箭预制物体上。

Create a new directory in the Project view called ‘WeaponPrefabs’to store our weapon prefabs in.

在项目视窗中建立一个新的目录叫‘WeaponPrefabs’，在里面存储我们的武器预制物体。Here’s the Javascript for Rocket.js:

这里是Rocket.js的Javascript脚本

The Kill function, firstly, finds the particle emitter in the child hierarchy and turns its

emitter off. Next, it detaches any children (e.g. Smoke trail particle system) from the object the script is attached to (the rocket) and destroys the rocket.

Kill 函数，首先，在子层次上找到粒子发射器并且关闭它的发射，下一步，它被分派到被附加脚本的对象的另一个子对象（例如烟尾粒子系统）并且销毁火箭。

The most important line is the transform.DetachChildren() function. This is called prior to destroying the gameObject (the rocket) so that when the rocket is destroyed the trail will now remain as it is no longer a child.

最重要的行是transform.DetachChildren()函数，它被在销毁游戏对象（火箭）前调用，以便当火箭被销毁时烟尾将保持，而不再是个子对象。

The

command ensures that a Rigidbody is attached to the component that the script is attached to (as the script requires a Rigidbody).

@script 命令确保了一个刚体被附着到一个附加脚本的组件上（脚本要求一个刚体）

Once a rocket instance collides with another collider, we want to destroy the rocket game object. However, if the trail is directly attached to the rocket, this will be destroyed also, and function OnCollisionEnter (collision : Collision) {

// Instantiate explosion at the impact point and rotate the explosion

//在碰撞点初始化爆炸物体并且调整爆炸物体方向

// so that the y-axis faces along the surface normal

//以便（爆炸物体的）Y 轴朝向正常的表面

var contact : ContactPoint = collision.contacts[0];

var rotation = Quaternion.FromToRotation(Vector3.up, contact.normal);

Instantiate (explosion, contact.point, rotation);

// And kill our selves 并且杀死我们自己

Kill ();

}

function Kill ()

{

// Stop emitting particles in any children

//在任意的子对象中停止发射粒子

var emitter : ParticleEmitter= GetComponentInChildren(ParticleEmitter);

if (emitter)

emitter.emit = false;

// Detach children - We do this to detach the trail rendererer which

// should be set up to auto destruct

//分离子对象-我们做了这些后，尾部渲染器将自动析构

transform.DetachChildren();

the trail will disappear suddenly. It is important to detach the smoke trail from the rocket before destroying the rocket.

一旦火箭实例与另一个碰撞器发生碰撞，我们就想销毁火箭游戏对象，然而，如果烟尾直接附着在火箭上的话，它也会被销毁，并且烟尾会突然不再显示。这是非常重要的在销毁火箭之前从火箭对象中分离出烟尾对象。

Notice that the rocket can be killed in one of two ways, either it is destroyed if it has survived for more then 3 seconds (e.g. shot into the air), or it is destroyed if it collides with an object.

注意火箭能被用两种方法删除，一种是它存在超过3秒钟（例如在空气中射击），或者它在和另一个对象发生碰撞时被销毁。

Select the RocketLauncher game object.

选择RocketLauncher游戏对象

Drag the Rocket prefab from WeaponPrefabs onto the Projectile slot in the Inspector. 从WeaponPrefabs目录下拖拽火箭预制物体到检查窗口的Projectile变量位置

Play the game, when you fire a rocket, it should have a smoke trail following it.

运行游戏，当你发射一个火箭时，将会看到有一个烟的尾巴跟随着它

Explosions 爆炸

You probably noticed that when you fired a rocket there was no explosion when it collided. We’ll add one in now.

你可能注意到当你发射一个火箭当他发生碰撞时并没有发生爆炸，我们现在增加一个。

Drag the Standard Assets/Particles/Small explosion prefab onto the exposed variable Explosion in the Rocket component of the Rocket prefab.

拖拽Standard Assets/Particles/Small explosion预制物体到Rocket预制物体的火箭组件的暴露变量Explosion上。

We still need to define the behavior of our explosion. Here’s the code for the ExplosionSimple.js script:

我们一直需要定义我们的爆炸的行为，这里是ExplosionSimple.js脚本的代码：Array This returns an array of colliders within the volume of the sphere.

这些返回了大量的球体中的碰撞器的数组。

This adds an upward force to all rigidbodies within range of the explosion (the sphere).

这些给所有在爆炸范围内的刚体（球体）一个向上的作用力。

Basically this makes the explosion look good!

大体上这些能使爆炸看起来很好！

This calculates how much damage to apply to each rigidbody caught in the explosion. The degree of damage decreases the further a rigidbody is from the centre of the explosion.

这些计算在爆炸中每个刚体上应用了多少毁伤。毁伤角度减弱离爆炸中心点远的物体的毁伤。

This sends a message to apply the damage to the rigidbody.

这里发出了一个应用到刚体上的毁伤信息

explosion script can be used as a generic explosion script for any game object that requires explosions. To tailor the script to suit each specific case, just modify variables such as:

增加一个ExplosionSimple脚本作为一个小的爆炸预制物体组件。这个爆炸脚本能被作为一个一般爆炸脚本使用在任何需要爆炸的游戏对象上。剪裁脚本以适应不同的情况，例如恰好编辑变量：

?explosionPower the degree of force with which the explosion will cause nearby objects to move.

爆炸能量，能使附近对象移动

?explosionDamage how many hit points the explosion will cause.

爆炸将引起多少打击点

?explosionRadius the effect radius of the explosion.

爆炸作用力的半径

The Explosion script is very similar to that used in the previous FPS tutorial with the main difference being the introduction of hit points. The hit points variable scales the explosionDamage variable based on distance, with object at the outer edge of the radius having lesser damage than those at the center of the explosion.

爆炸脚本与以前的FPS教程很像，主要的不同是多了打击点的介绍。打击点变量在距离上缩小放大explosionDamage变量的值，在半径范围以外的物体比在爆炸中心点的对象受到的伤害要小。

This means it’s now possible for an explosion to inflict damage to objects near to where it collided. How to use hit points for each object will be discussed in more detail later.

这意味着它可能现在一个爆炸会使碰撞地点附近的对象承受到伤害，至于每个对象怎么使用打

击点将在以后被讨论。

运行游戏

Machine Gun机枪

The machine gun style weapon offers a faster rate of fire than the rocket launcher however each bullet impact does less damage.

机枪类型的武器提供了一个比火箭发射器相对快速的发射火力，然而子弹的伤害也小

Weapons in the Hierarchy View.

建立一个空的游戏对象并且命名它为MachineGun。在层次视窗中增加为Weapons的子对象。

Add Objects/weapons/machineGun to the empty MachineGun game object.

增加Objects/weapons/machineGun 到空的MachineGun 游戏对象上。

Assign the MachineGun.js script to the MachineGun game object.

分配MachineGun.js 脚本到MachineGun 游戏对象上

Assign muzzle_flash (it ’s a child of machineGun) to the Muzzle Flash variable of the Machine Gun component of the MachineGun game object.

分配枪口闪光对象（它作为机枪的一个子对象）到机枪游戏对象的机枪组件的Muzzle Flash 变量上。

Here ’s the complete code for MachineGun.js :

这里是完成的MachineGun.js:脚本的代码：

The Start function is really just initializing the particle emitter (bullet spark) so that it is turned off.

Start 函数实际上是用来初始化粒子发射器（子弹的火花）所以在这里被关掉了。

var range = 100.0;

var fireRate = 0.05;

var force = 10.0;

var damage = 5.0;

var bulletsPerClip = 40; //弹夹中的弹药数

var clips = 20;

//弹夹数

var reloadTime = 0.5; //换弹夹的时间

private var hitParticles : ParticleEmitter;

var muzzleFlash : Renderer;

private var bulletsLeft : int = 0; //枪中的弹药数

private var nextFireTime = 0.0; //实际上是指最后一颗子弹打完的时间

private var m_LastFrameShot = -1;

function Start ()

{

hitParticles = GetComponentInChildren(ParticleEmitter);

// We don't want to emit particles all the time, only when we hit something.

//我们不想让粒子发射系统在所有时候都发射，只有在我们击中了一些物体时才发射 if (hitParticles) hitParticles.emit = false;

bulletsLeft = bulletsPerClip; //让枪中的弹药等于弹夹中的弹药

}

muzzleFlash.transform.localRotation =

Quaternion.AngleAxis(Random.Range(0, 359), Vector3.forward);

muzzleFlash.enabled = true;

if (audio)

{

if (!audio.isPlaying) audio.Play();

audio.loop = true;

}

}

// We didn't, disable the muzzle flash

//使枪口火星失效

else

{

muzzleFlash.enabled = false;

enabled = false;

// Play sound

if (audio)

{

audio.loop = false;

}

}

}

}

The LateUpdate function is automatically called after an Update function is called. Note that the Update function is called in the PlayWeapons script which is attached to the Weapons game object (it’s a parent of MachineGun). Generally the LateUpdate function will be used whenever you want to react to something that happened in Update. In this case, the player if firing in the Update function, and in LateUpdate we’re applying the muzzle flash.

LateUpdate函数在一个Update函数调用之后会被自动调用，注意Update函数是在PlayWeapons 脚本中被调用的，脚本被附加到武器游戏对象上了。（它是机枪对象的父对象），一般地LateUpdate函数将被使用在你想随时在Update中发生的想做出响应的一些事情上，在这个例子中，游戏者在Update函数中开火，并且在LateUpdate函数中应用枪口闪光对象。

The Fire function calculates if the player should be able to fire based on the fire rate of the machine gun.

Fire函数用来计算如果游戏者能够开火时的机枪的开火速度。

注意这一段比较难看懂，特别说明如下：

Time.Time是指自游戏开始以来累计的时间

Time.deltaTime是指自游戏开始以来到最后一帧的时间

fireRate是指开火时间间隔

nextFireTime实际上是指最后一颗子弹打完的时间

游戏的时间划分是一帧一帧的，但进入Fire函数可能时间已经有累积了一段，nextFireTime 初始化的时间为0，而开火时间间隔fireRate的时间是个常数，if (Time.time - fireRate > nextFireTime) nextFireTime = Time.time - Time.deltaTime;这一句在第一次循环时实际上nextFireTime等于最后一帧结束以来累计的时间，是个整数，这个时间肯定小于总计的时间Time.time，因此，当另一个条件子弹数大于0时，进入循环nextFireTime += fireRate，循环一次nextFireTime值增加一个开火时间间隔，直到把Time.time时间内能打的子弹数打完，退出循环，退出这个调用过程，在进入下一帧的触发，重新进入Fire函数，这时的nextFireTime 值很大，是最后一颗子弹打完的时间，Time.time - fireRate > nextFireTime正好是判断自最后一颗子弹打完后累积的时间是否大于开火时间间隔。

var hit : RaycastHit;

// Did we hit anything? 我们向谁射击？

if (Physics.Raycast (transform.position, direction, hit, range))

{

// Apply a force to the rigidbody we hit 应用一个作用力到我们打击的刚体上

if (hit.rigidbody) hit.rigidbody.AddForceAtPosition(force * direction, hit.point);

// Place the particle system for spawing out of place where we hit the surface!

//定位用来在我们打击的对象表面向外界发散粒子的粒子系统

// And spawn a couple of particles

//并且产生大量粒子

if (hitParticles)

{

hitParticles.transform.position = hit.point;

hitParticles.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal);

hitParticles.Emit();

}

// Send a damage message to the hit object

//发送一个毁伤信息给打击的对象

hit.collider.SendMessageUpwards("ApplyDamage", damage,

SendMessageOptions.DontRequireReceiver);

}

bulletsLeft--;

// Register that we shot this frame,

//注册我们射击的帧

// so that the LateUpdate function enabled the muzzleflash renderer for one frame

//以便LateUpdate函数能给一帧渲染枪口闪光，枪口闪光在Update的补充函数LateUpdate中，需要告诉它是哪一帧需要做枪口闪光

M_LastFrameShot = Time.frameCount;

enabled = true;

// Reload gun in reload Time

//在重载时间重新装备枪

if (bulletsLeft == 0)

Reload();

}

The FireOneShot function starts by casting out a ray in front of the FPS Controller to determine if the bullet has hit anything. We’ll limit the range of the bullet to a certain distance.

如果子弹打在任何物体上，那么FireOneShot函数开始用在FPS控制器前方射出一道光线来确定，我们在一定距离上限制子弹的范围。

If the raycast did intersect with a rigidbody, then a force is applied in the forward direction

to that rigidbody (a small force as it’s only a machine gun). Next the bullet spark is instantiated at the location where the bullet (ray) struck. The particle emitter is oriented so that it is along the normal of the surface it struck.

如果投射的线路与刚体相交，那么一个作用力就会被沿着一个向前的方向应用到那个刚体上（像机枪的作用力就比较小）。接下来在子弹击中的位置会出现火花，粒子发射器被导向以便它是沿着它正常撞击的表面

Next, damage is applied to the object by sending a damage message to the object that

was hit.

接下来，毁伤被应用到对象上，会给被击中的对象发送毁伤信息（这一点很重要，可以用来发送掉血的数值）

The Reload function reloads a clip of ammo (if there are any left of course). The

amount of time taken to reload can be tweaked in the inspector.

Reload函数重载弹药片段（如果这期间离开了的话）。在检查窗口中花费的重载时间数可以做调整

Configuring the particle emitter

The MachineGun needs a spark effect when bullets collide with rigidbodies, let’s create one.

机枪需要当子弹撞击到刚体时产生火花效果，让我们建立一个。（注意枪口火星和火花不是一个东西）

child of machineGun (not MachineGun) in the Hierarchy View.

从Standard Assets/Particles目录下拖拽火花Sparks预制物体以便它能作为在层次视窗中的

machineGun（不是MachineGun）的子对象

switch weapons.

就是它了！运行游戏，不要忘了按?1?和?2?来切换武器。

译者注：看不到枪口火星?，要把MachineGun的着色器（shader）的值调到specular（镜面），muzzle_flash的着色器（shader）的值调到（Particles/Additive）

Hit Points 生命值

The Explosion and MachineGun Javascripts have already shown how to calculate the degree of damage caused by a projectile (rocket or bullet), and send this value to all nearby game objects. However, game objects do not yet know how to respond to this value.

爆破和机枪的Javascript脚本已经显示怎么通过一个发射体（火箭或子弹）怎么计算毁伤角度，并且发送这个值到所有附近的游戏对象，然而，游戏对象还不知道怎么响应这个值

Game objects can keep track of how healthy they are by using a hitPoints variable.Each object will be initialized to its own value (depending on how strong it is). Each game object that should respond to damage should also have an ApplyDamage() function (note this is the function called from the Explosion and MachineGun scripts to apply the damage). This function will decrement hit points from the game object as necessary and call functions to handle what happens when the hit points reach 0 (typically a death or explosion state).

游戏对象可以跟踪他们的健康通过使用MachineGun一个生命值变量，每个对象都将被初始化到它自己的值（这依赖它有多强壮），每个游戏对象都能响应毁伤也同样有一个ApplyDamage()函数（注意这个函数被应用毁伤的Explosion和MachineGun脚本调用）。如果需要的话这个函数将从游戏对象上减少生命值并且调用函数以处理当生命值到达了0时的怎么做（典型的是死亡和爆炸状态）

The next section will demonstrate how hitPoints and ApplyDamage() are used.

接下来的章节将演示生命值和应用毁伤怎么做

Exploding Barrels 炸药桶

The code we’re about to look at is generic, so the Javascript can be added as a component to any object that can have damage applied to it. Here is the complete code

for DamageReceiver.js:

这段代码看起来很普通，所以Javascript脚本能作为一个组件增加到我们想击毁的任意对象上，这时DamageReceiver.js的全部代码

This function applies the damage to the game object which has been shot or caught in an explosion. If the object’s hit points are already 0 or less, then nothing is done, otherwise the hit point counter is decremented by the value passed in (damage). If the resulting hit points are now less than 0 the DelayedDetonate function is called (delays can make the explosion look cool; no other reason).

这个函数对被射击击中或爆炸扫到的游戏对象应用了伤害。如果对象击中的点的生命值已经是零或比零还小，那就什么都不做，否则被击中的点的生命值要通过伤害计算消减，如果结果小于零，就要调用DelayedDetonate函数（延迟能使爆炸看起来更酷；没有其它理由）

This calls the Detonate method on the game object and its children.

这时在游戏对象和它的子对象上调用爆炸（Detonate）方法

If there’s an explosion prefab attached to the barrel, then display that when the barrel’s hit points reach zero.

如果这里有个爆炸预制物体附着在炸药桶上，当炸药桶的生命值到达零时这时就会显示上面的调用结果。

If the game object has a dead equivalent, in this case a barrel which looks burnt out, then replace the normal game object with its dead equivalent. We make sure the object keeps traveling in the direction that it was going when its hit points reached zero.

如果一个游戏对象有一个死后的物体，在这种情况下用一个看起来就像炸开花了的炸药桶替换它的正常的游戏对象。我们确保该对象当它的生命值到达零时往某个方向移动。

Let’s set up our game to use the DamageReceiver script on some barrels. Let’s start by importing some assets.

让我们在一些炸药桶上使用DamageReceiver脚本建立我们的游戏。从我们导入一些资源开始吧

拖拽Objects/crateAndBarrel/barrel到场景中。

给炸药桶增加刚体组件。

tune the size of the box collider so that it is a better fit to the barrel. Do this by altering the Size properties of Box Collider in the Inspector View.

给炸药桶增加一个盒子碰撞器（Component >Physics >Box Collider）。你可能想去调整盒子

碰撞器的大小以便它能罩住炸药桶。在检查视窗中修改盒子碰撞器的尺寸。

在层次视窗中附着DamageReceiver脚本到炸药桶上。

the Damage Receiver component of Barrel).

分配Standard Assets/Particles/explosion prefab到Explosion属性上（在炸药桶的伤害接收

器组件上）

Create a new prefab called Barrel (note capital B, the imported barrel has a

small ‘b’).

建立一个叫炸药桶的预制物体（注意大写的B，导入的炸药桶有个小写的?b?）

Drag the barrel we have configured from the Hierarchy View into the newly created prefab in the Project View.

拖拽我们已经配置好的炸药桶到项目视窗中的新建立预制物体上。

Add several Barrels to the Scene View (use duplicate as it’s easier).

增加多个炸药桶到场景中（如果使用复制将很容易）

Play the game.

运行游戏

You’ll notice when the barrels explode they just disappear, we’ll now add a dead replacement barrel (a barrel that looks blown up).

你将注意到当炸药桶爆炸时它们恰好不显示，我们现在增加一个死亡的替代炸药桶（一个看起来会开花的炸药桶）

Create another prefab called Barreldead.

建立另一个预制物体叫做死亡炸药桶

Assign the original barrel to the prefab (the one we imported from Objects/ crateAndBarrel).

分配一个原先的炸药桶到预制物体上（就是我们从Objects/ crateAndBarrel导入的）

At the moment, the Barrel and Barreldead objects look the same, they both have a texture in common (barrel1).

现在炸药桶和死亡炸药桶看起来相同，它们都有一个共同的材质（barrel1）。

We want Barreldead to have a texture that looks different from Barrel, so the user will know when it has exploded, something that looks burnt out would do. If we modify barrel1 texture to give this effect, then the Barrel object will also be modified, as Barrel and Barreldead both share this same texture. To solve this problem, we must create a new