簡介

Unity的強(qiáng)大功能主要得益于其豐富的腳本語言。你可以使用腳本來處理用戶輸入、移動場景中的物體、檢測碰撞、使用預(yù)制對象以及沿場景四周投射定向光線來增強(qiáng)你的游戲邏輯等。這聽起來有點令人生畏，但由于Unity官方提供了良好的API文檔支持，所以完成上述任務(wù)變得輕而易舉——即使對于Unity開發(fā)新手亦然！

在本教程中，你將創(chuàng)建一個基于俯視角的Unity射擊游戲。游戲中，你將使用Unity #腳本來生成敵人、控制玩家、發(fā)射炮彈以及實現(xiàn)游戲其他重要方面的控制。

【提示】本文假設(shè)你有一個C＃或類似的編程語言開發(fā)經(jīng)驗。另外，本文示例游戲使用Unity 5.3+開發(fā)而成。

準(zhǔn)備

首先，請下載本文示例啟動項目（http://www.raywenderlich.com/wp-content/uploads/2016/03/BlockBuster.zip）并解壓縮。為了在Unity中打開啟動器項目，你可以從【Start Up Wizard】下單擊【Open】命令，然后導(dǎo)航到項目文件夾。或者，您可以直接從路徑【BlockBuster/Assets/Scenes】下打開文件Main.unity。

下圖給出您的示例工程中場景的初始樣子。

首先，請觀察一下場景視圖周圍的情況。有一個小的場地，這將作為本示例游戲的戰(zhàn)場；還有一部相機(jī)，當(dāng)玩家在戰(zhàn)場上走動時相機(jī)會跟隨他們。如果您的布局與截圖有所不同，你可以選擇右上角的下拉菜單，把其中的選項改為「2 by 3」。

沒有英雄存在，那算是什么游戲呢？因此，你的第一個任務(wù)是創(chuàng)建一個游戲?qū)ο螅员硎緫?zhàn)場中的英雄。

創(chuàng)建玩家對象

在【Hierarchy】中，點擊【Create】按鈕，然后從「3D」部分選擇「Sphere」。將球體拖動到坐標(biāo)位置（0，0.5，0），并將其命名為Player，如圖所示。

從現(xiàn)在起，你將引用這一個球體作為玩家（Player）對象。

Unity使用組件系統(tǒng)來構(gòu)建它的游戲?qū)ο螅贿@意味著，在一個場景中的所有對象都可以通過組件的任何組合來創(chuàng)建。這些組合包括：用來描述一個對象位置的變換（Transform）；網(wǎng)格過濾器（Mesh Filter），其中包含圖形幾何體或者任何個數(shù)的腳本（Scripts）。

玩家（Player）對象需要響應(yīng)與場景中的其他對象的碰撞。

要做到這一點，請從【Hierarchy】中選擇「Player」。然后，從【Inspector】選項卡下點擊【Add Component】按鈕。在【Physics】類別中，選擇【Rigidbody】組件。這將使Player對象為Unity的物理引擎所控制。

現(xiàn)在，請更改Rigidody的值，如下所示：

1.Drag：1

2.Angular Drag：0

3.Constraints: Freeze Position：Y

編寫玩家運(yùn)動腳本

現(xiàn)在你有了一個Player對象。接下來，我們來編寫腳本以便接收鍵盤輸入，進(jìn)而移動玩家。

在項目瀏覽器（Project Browser）中點擊【Create】按鈕，然后選擇「Folder」。命名新文件夾為「Scripts」并在名為「Player」的文件夾下創(chuàng)建一個子文件夾。接下來，在「Player」文件夾下，點擊【Create】按鈕，并選擇【C# Script】。命名新的腳本為PlayerMovement。順序大致如下圖所示：

【提示】Player對象將包含多個腳本，各自負(fù)責(zé)其行為的不同部分。在一個單獨的文件夾下保存所有相關(guān)的腳本，使項目中文件更容易管理，并減少混亂。

現(xiàn)在，請雙擊PlayerMovement.cs腳本。在Mac上，這將打開隨同Unity一起打包的MonoDevelop開發(fā)環(huán)境；在Windows上，它應(yīng)該打開Visual Studio。本教程假設(shè)你使用MonoDevelop。

在類中聲明下面兩個公共變量：

public float acceleration;

public float maxSpeed;

其中，acceleration用于描述玩家的速度如何隨時間增加，而maxSpeed代表“速度極限”。制作一個public類型的變量將會使之顯示于【Inspector】之中，這樣你就可以通過Unity界面來設(shè)置它的值，并根據(jù)需要調(diào)整它。

緊接著上面的聲明，再聲明以下變量：

private Rigidbody rigidBody;

private KeyCode[] inputKeys;

private Vector3[] directionsForKeys;

注意，私有變量無法通過【Inspector】進(jìn)行設(shè)置。因此，需要由程序員在適當(dāng)?shù)臅r候以完全手動方式對它們進(jìn)行初始化。

接下來，把Start()函數(shù)修改成如下所示的代碼：

void Start () { 
  inputKeys = new KeyCode[] { KeyCode.W, KeyCode.A, KeyCode.S, KeyCode.D }; 
  directionsForKeys = new Vector3[] { Vector3.forward, Vector3.left, Vector3.back, Vector3.right }; 
  rigidBody = GetComponent<Rigidbody>(); 
} 

上述代碼中的inputKeys數(shù)組包含了您將用于移動玩家的鍵碼。directionsForKeys包含相應(yīng)于每個鍵的方向；例如，按下W用于向前移動對象。至于最后一行代碼，你還記得前面添加的剛體嗎？這是可以得到對該組件的引用的一種方式。

要移動玩家，你就必須處理來自于鍵盤的輸入。

現(xiàn)在，請重命名函數(shù)Update()為FixedUpdate()，并給它添加以下代碼：

// 1 
void FixedUpdate () { 
  for (int i = 0; i < inputKeys.Length; i++){ 
    var key = inputKeys[i]; 
  
    // 2 
    if(Input.GetKey(key)) { 
      // 3 
      Vector3 movement = directionsForKeys[i] * acceleration * Time.deltaTime; 
    } 
  } 
} 

這里發(fā)生了幾件重要的事情：

1.FixedUpdate()函數(shù)是幀速率獨立的，在操作剛體時應(yīng)該調(diào)用此函數(shù)。

2.這個循環(huán)檢查是否有任何輸入鍵被按下。

3.在這里，你得到按鍵的方向，并把它乘以加速度和完成最后一幀的修復(fù)所耗費(fèi)的秒數(shù)。這將產(chǎn)生您創(chuàng)建一個矢量，正是使用它來移動Player對象。

注意，當(dāng)您創(chuàng)建一個新的Unity腳本時，你實際上是創(chuàng)建一個新的MonoBehaviour對象。如果你熟悉iOS編程世界，那么你會知道它是一個UIViewController的等價物；也就是說，你可以使用這個對象來響應(yīng)Unity內(nèi)的事件，從而訪問你自己的數(shù)據(jù)對象。

MonoBehaviours有很多不同的方法，它們分別對各種事件作出響應(yīng)。舉例來說，當(dāng)MonoBehaviour實例化時如果你想初始化一些變量，那么你就可以實現(xiàn)方法Awake()。在MonoBehaviour被禁用時為了運(yùn)行代碼，你可以實現(xiàn)方法OnDisable()。

【提示】如果你想研究這些事件的完整列表，請訪問Unity官方文檔，地址是 http://docs.unity3d.com/ScriptReference/MonoBehaviour.html。

如果你是游戲編程新手，你可能會問自己，為什么必須乘以Time.deltaTime？一般的規(guī)律是，當(dāng)你每隔固定的時間幀數(shù)執(zhí)行一個動作時，你需要乘以Time.deltaTime。在本例情況下，你想要沿按鍵方向加速移動玩家，加速數(shù)值為固定的更新時間。

接下來，在方法FixedUpdate（）下面添加以下方法：

void movePlayer(Vector3 movement) { 
  if(rigidBody.velocity.magnitude * acceleration > maxSpeed) { 
    rigidBody.AddForce(movement * -1); 
  } else { 
    rigidBody.AddForce(movement); 
  } 
} 

上述方法用于對剛體施加力作用，使其移動。如果當(dāng)前速度超過maxSpeed，力會變成相反的方向......這有點像一個速度極限。

現(xiàn)在，請在方法FixedUpdate（）中，在if語句的結(jié)束括號之前，添加以下行：

movePlayer(movement);

很好！回到Unity中。然后，在項目瀏覽器中，將PlayerMovement腳本拖動到【Hierarchy】中的Player對象上。然后，使用【Inspector】來把「Acceleration」的值設(shè)置為625并把最大速度（Max Speed）修改為4375：

現(xiàn)在，請運(yùn)行一下游戲場景，并試著使用鍵盤上的WASD鍵移動玩家對象，觀察效果：

到目前，我們僅僅實現(xiàn)了幾行代碼，這已經(jīng)算是一個相當(dāng)不錯的結(jié)果了！

然而，現(xiàn)在有一個明顯的問題：玩家可以移出人們的視線之外，這在打壞人時是個麻煩事。

編寫攝相機(jī)腳本

在「Scripts」文件夾中，創(chuàng)建一個名為CameraRig的新的腳本，并將其附加到主攝像機(jī)（Main Camera）上。

【提示】在選擇【Scripts】文件夾情況下，點擊工程瀏覽器中的【Create】按鈕，然后選擇【C# Script】。命名新的腳本為「CameraRig」。最后，把此腳本拖動到「Main Camera」對象上即可。

現(xiàn)在，在新創(chuàng)建的CameraRig類中添加下列變量：

public float moveSpeed;

public GameObject target;

private Transform rigTransform;

正如你可能已經(jīng)猜到的，moveSpeed代表了相機(jī)跟蹤目標(biāo)的速度——這可能是場景里面的任何游戲?qū)ο蟆?/p>

接下來，在Start()函數(shù)中添加以下代碼行：

rigTransform= this.transform.parent;

此代碼獲取場景層次樹中的到父Camera對象的引用。場景中的每個對象具有一個變換（Transform），其中描述了一個對象的位置旋轉(zhuǎn)和縮放等信息。

然后，在與上面同一個腳本文件中添加下面的方法：

void FixedUpdate () { 
  if(target == null){ 
    return; 
  } 
  
  rigTransform.position = Vector3.Lerp(rigTransform.position, target.transform.position, 
    Time.deltaTime * moveSpeed); 
} 

這部分CameraRig移動代碼要比在PlayerMovement中的簡單一些。這是因為你不需要一個剛體；只需要在rigTransform的位置和目標(biāo)之間進(jìn)行插值就足夠了。

Vector3.Lerp()函數(shù)使用了空間中的兩個點，還有一個界于[0，1]范圍內(nèi)的浮點數(shù)（它描述了沿兩個端點的中間的某一點）作參數(shù)。左端點為0，右側(cè)端點是1。于是，把0.5傳遞給Lerp()函數(shù)將正好返回位于兩個端點中間的一個點。

這會將rigTransform移到距目標(biāo)位置更近一些，而且略有緩動效果。總之，相機(jī)跟隨玩家運(yùn)動。

現(xiàn)在，返回到Unity。確保層次樹（Hierarchy）中的主攝像機(jī)（Main Camera）仍處于選中狀態(tài)。在【Inspector】中，把Move Speed（移動速度）設(shè)置為8，并把Target（目標(biāo)）設(shè)置為Player：

再次運(yùn)行游戲工程，沿場景四處移動；你會注意到，無論玩家走到哪里，相機(jī)都能夠平滑地跟隨目標(biāo)變換。

創(chuàng)建敵人對象

一款沒有敵人的射擊游戲很容易被擊敗，當(dāng)然也很無聊。所以，現(xiàn)在我們來通過單擊頂部菜單中的【GameObject\3D Object\Cube】創(chuàng)建一個用于表示敵人的立方體對象。然后，把此立方體重命名為「Enemy」，并添加一個Rigidbody（剛體）組件。

在【Inspector】中，首先設(shè)置立方體的變換為（0，0.5，4）。并在剛體組件的「Constraints」部分的「Freeze Position」類別下勾選「Y」選擇對應(yīng)的復(fù)選框。

很好，現(xiàn)在使你的敵人氣勢洶洶地走動吧。然后，在【Scripts】文件夾下創(chuàng)建一個命名為「Enemy」的腳本。現(xiàn)在，你應(yīng)該對這種操作很熟練了；恕不再贅述。

接下來，在類內(nèi)部添加下列公共變量：

public float moveSpeed;

public int health;

public int damage;

public Transform targetTransform;

你也許可以很容易地確定出這些變量所代表的含義。你可以使用如前面一樣的moveSpeed變量技巧來操縱攝像機(jī)，而且它們的效果相同。Health和damage這兩個變量分別用于確定何時敵人死了以及他們死多少會傷害玩家。最后，變量targetTransform用于引用玩家對象對應(yīng)的變換。

說到玩家對象，你需要創(chuàng)建一個類來描述敵人想破壞的所有玩家的健康值。

在項目瀏覽器中，選擇「Player」文件夾，并創(chuàng)建一個名為「Player」的新腳本。這個腳本會響應(yīng)于碰撞，并跟蹤玩家的健康值。現(xiàn)在，我們通過雙擊此腳本來編輯它。

添加下列公共變量來保存玩家的健康值：

public int health = 3;

這樣便提供了玩家健康值的默認(rèn)值，但它也可以通過【Inspector】進(jìn)行修改。

為了處理沖突，添加以下方法：

void collidedWithEnemy(Enemy enemy) { 
  // Enemy attack code 
  if(health <= 0) { 
    // Todo 
  } 
} 
void OnCollisionEnter (Collision col) { 
    Enemy enemy = col.collider.gameObject.GetComponent<Enemy>(); 
    collidedWithEnemy(enemy); 
} 

當(dāng)兩個剛體發(fā)生碰撞時，OnCollisionEnter()即被觸發(fā)。其中，Collision參數(shù)中包含了諸如接觸點和沖擊速度相關(guān)的信息。在本示例情況下，我們只對碰撞物體中的Enemy組件感興趣，所以可以調(diào)用collidedWithEnemy()并執(zhí)行攻擊邏輯——接下來就會實現(xiàn)這種邏輯。

切換回文件Enemy.cs，并添加以下方法：

void FixedUpdate () { 
  if(targetTransform != null) { 
    this.transform.position = Vector3.MoveTowards(this.transform.position, targetTransform.transform.position, Time.deltaTime * moveSpeed); 
  } 
}  
public void TakeDamage(int damage) { 
  health -= damage; 
  if(health <= 0) { 
    Destroy(this.gameObject); 
  } 
} 
  
public void Attack(Player player) { 
  player.health -= this.damage; 
  Destroy(this.gameObject); 
} 

你已經(jīng)熟悉了FixedUpdate()函數(shù)，略有不同的是現(xiàn)在使用的是MoveTowards()而不是Lerp()函數(shù)。這是因為敵人應(yīng)該一直以相同的速度移動而不會在接近目標(biāo)時出現(xiàn)快速移動。當(dāng)敵人被彈丸擊中時，TakeDamage()即被調(diào)用；當(dāng)敵人到達(dá)值為0的健康值時他會自我毀滅。Attack()函數(shù)的實現(xiàn)邏輯是與之很類似的——對玩家進(jìn)行傷害，然后敵人破壞自身。

切換回Player.cs。然后，在函數(shù)collidedWithEnemy()中，使用下面代碼替換注釋// Enemy attack code：

enemy.Attack(this);

游戲中，玩家將受到傷害，而敵人在該過程中將自我毀滅。

切換回Unity。把Enemy腳本附加到 Enemy對象上；并在【Inspector】中，針對Enemy對象設(shè)置以下值：

1.Move Speed：5

2.Health：2

3.Damage：1

4.Target Transform：Player

現(xiàn)在，你應(yīng)該能夠自己做這一切了。結(jié)束后，你可以與文后完整的工程源碼進(jìn)行比較。

在游戲中，敵人與玩家碰撞，從而實現(xiàn)一種有效的敵對攻擊。使用Unity的物理碰撞檢測幾乎是一個很簡單的任務(wù)。

最后，在層次結(jié)構(gòu)中把Player腳本附加到Player對象。

運(yùn)行游戲工程，并留意在控制臺上輸出的結(jié)果：

當(dāng)敵人接觸到玩家時，它能夠成功地進(jìn)行攻擊，并把玩家的健康值變量降低到2。但是，現(xiàn)在在控制臺中拋出一個NullReferenceException異常，錯誤指向Player腳本：

哈哈，現(xiàn)在玩家不僅可以與敵人碰撞，也可能與游戲世界中的其他部分，如戰(zhàn)場，發(fā)生碰撞！這些游戲?qū)ο蟛]有Enemy腳本，因此GetComponent()函數(shù)將返回null。

接下來，打開文件Player.cs。然后，在OnCollisionEnter()函數(shù)中，把collidedWithEnemy()函數(shù)調(diào)用使用一個if語句包括起來，如下所示：

if(enemy) { 
  collidedWithEnemy(enemy); 
} 

此時，異常消失！

使用預(yù)制

只是簡單地在戰(zhàn)場上跑來跑去，而且避開敵人；這只能算是一個一邊倒的游戲。現(xiàn)在，我們來武裝一下玩家，使之能夠作戰(zhàn)。

單擊層次結(jié)構(gòu)中的【Create】按鈕，并選擇【3D Object/Capsule】。命名它為Projectile，并給它指定下列變換值：

1.    Position：(0, 0, 0)

2.    Rotation：(90, 0, 0)

3.    Scale：(0.075, 0.246, 0.075)

每當(dāng)玩家射擊時，他就會發(fā)射Projectile（炮彈）的一個實例。要做到這一點，你需要創(chuàng)建一個預(yù)制（Prefab）。不像場景中你已經(jīng)擁有的其他對象，預(yù)制對象是根據(jù)游戲邏輯需要而創(chuàng)建的。

現(xiàn)在，在文件夾「Assets」下創(chuàng)建一個新的文件夾，名為Prefabs。現(xiàn)在，把Projectile對象拖動到這個文件夾上。就是這樣：你創(chuàng)建了一個預(yù)制！

您的預(yù)制還需要一點腳本。現(xiàn)在，在【Scripts】文件夾內(nèi)創(chuàng)建一個名為「Projectile」的新腳本，并添加下面的類變量：

public float speed;

public int damage;

Vector3 shootDirection;

就像目前為止在本教程中任何可移動的物體一樣，這個對象也會有速度和傷害對應(yīng)的變量，因為它是戰(zhàn)斗邏輯的一部分。其中，shootDirection矢量決定了炮彈將向哪兒發(fā)射。

在類中實現(xiàn)下面的方法即可使這個矢量發(fā)揮作用：

// 1 
void FixedUpdate () { 
  this.transform.Translate(shootDirection * speed, Space.World); 
} 
// 2 
public void FireProjectile(Ray shootRay) { 
  this.shootDirection = shootRay.direction; 
  this.transform.position = shootRay.origin; 
} 
// 3 
void OnCollisionEnter (Collision col) { 
  Enemy enemy = col.collider.gameObject.GetComponent<Enemy>(); 
  if(enemy) { 
    enemy.TakeDamage(damage); 
  } 
  Destroy(this.gameObject); 
} 

在上面的代碼中發(fā)生了下面的事情：

1.炮彈在游戲中的運(yùn)動方式與其他對象不同。它不具有一個目標(biāo)，或者一直對它施加一些力；相反，它在其整個生命周期中的按照預(yù)定方向進(jìn)行運(yùn)動。

2.在這里，我們設(shè)置了預(yù)制對象的起始位置和方向。Ray參數(shù)看上去似乎很神秘吧，但你很快就會知道它是如何計算出來的。

3.如果一個炮彈與敵人發(fā)生碰撞，它會調(diào)用TakeDamage()，并進(jìn)行自我毀滅。

在場景層次中，把Projectile腳本附加到Projectile游戲?qū)ο笊稀ＴO(shè)置它的速度為0.2，并把損壞值設(shè)置為1，然后點擊【Inspector】頂部的【Apply】按鈕。這將針對這個預(yù)制的所有實例保存剛才所做的更改。

現(xiàn)在，請從場景層次樹中刪除Projectile對象，因為我們不再需要它了。 

發(fā)射炮彈

現(xiàn)在，你既然已經(jīng)擁有了可以移動并施加傷害能力的預(yù)制對象，那么，接下來你就可以開始考慮實現(xiàn)發(fā)射炮彈相關(guān)的編程了。

在Player文件夾下，創(chuàng)建一個名為PlayerShooting的新腳本，并將其附加到場景中的Player游戲?qū)ο蟆Ｈ缓螅赑layer類中，聲明以下變量：

public Projectile projectilePrefab;

public LayerMask mask;

第一個變量將包含對前面創(chuàng)建的Projectile預(yù)制對象的引用。每當(dāng)玩家發(fā)射炮彈時，您將從這個預(yù)制創(chuàng)建一個新的實例。mask變量是用來篩選游戲?qū)ο螅℅ameObject）的。

現(xiàn)在，我們要介紹一下光線投射的問題。何謂光線投射（casting Ray）？這是什么魔法？

其實，并不存在什么黑魔法。但是，有時候在你的游戲中，你的確需要知道是否在一個特定方向上存在碰撞。要做到這一點，Unity在您指定的方向上能夠從某一個點投出一條看不見的射線。你可能會遇到很多與射線相交的游戲?qū)ο螅灰虼耍褂煤Y選器可以過濾掉任何不需要參與碰撞的對象。

光線投射是非常有用的，并且可以用于各種用途。它們常用于測試是否另一名玩家已經(jīng)被炮彈擊中；而且，你也可以使用它們來測試是否在鼠標(biāo)指針下方存在任何的幾何形狀。要更多地了解關(guān)于光線投射的內(nèi)容，請參考一下Unity官方網(wǎng)站提供的在線培訓(xùn)視頻（https://unity3d.com/learn/tutorials/modules/beginner/physics/raycasting）。

下圖顯示了從一個立方體到一個錐體的光線投射情況。由于射線上有一個圖標(biāo)掩碼，因此它忽略掉游戲?qū)ο蠖到y(tǒng)給出的提示是擊中了錐體：

接下來，我們需要創(chuàng)建自己的射線了。

把如下代碼添加到文件PlayerShooting.cs：

 void shoot(RaycastHit hit){ 
 
  // 1 
 
  var projectile = Instantiate(projectilePrefab).GetComponent<Projectile>(); 
 
  // 2 
 
  var pointAboveFloor = hit.point + new Vector3(0, this.transform.position.y, 0); 
 
  // 3 
 
  var direction = pointAboveFloor - transform.position; 
 
 // 4 
 
  var shootRay = new Ray(this.transform.position, direction); 
 
  Debug.DrawRay(shootRay.origin, shootRay.direction * 100.1f, Color.green, 2);  
 
  // 5 
 
  Physics.IgnoreCollision(GetComponent<Collider>(), projectile.GetComponent<Collider>());  
 
  // 6 
 
  projectile.FireProjectile(shootRay); 
 
} 

概括來看，上面的代碼主要實現(xiàn)如下功能：

1.    實例化一個炮彈預(yù)制并獲得它的Projectile組件，從而可以把它初始化。

2.    這個坐標(biāo)點總是使用像（X，0.5，Z）這樣的格式。其中，X和Z坐標(biāo)位于地面上，正好對應(yīng)于射線投射擊中的鼠標(biāo)點擊位置的坐標(biāo)。這里的計算是很重要的，因為炮彈必須平行于地面；否則，你會向下射擊，而只有外行的玩家才會出現(xiàn)向地面射擊的情況。

3.    計算從游戲物體Player指向pointAboveFloor的方向。

4.    創(chuàng)建一條新的射線，并通過其原點和方向來共同描述炮彈軌跡。

5.    這行代碼告訴Unity的物理引擎忽略玩家與炮彈之間的碰撞。否則，在炮彈飛出去前將調(diào)用Projectile腳本中的OnCollisionEnter()方法。

6.    最后，設(shè)置炮彈的運(yùn)動軌跡。

【注意】當(dāng)光線投射不可見時，你可以使用Debug.DrawRay()方法來輔助調(diào)試程序，因為它可以幫助您更直觀地觀察光線的外觀和它所擊中的對象。

好，現(xiàn)在既然發(fā)射炮彈的邏輯已經(jīng)實現(xiàn)，請繼續(xù)添加下面的方法來讓玩家真正扣動扳機(jī)：

 // 1 
 
void raycastOnMouseClick () { 
 
  RaycastHit hit; 
 
  Ray rayToFloor = Camera.main.ScreenPointToRay(Input.mousePosition); 
 
  Debug.DrawRay(rayToFloor.origin, rayToFloor.direction * 100.1f, Color.red, 2); 
 
   if(Physics.Raycast(rayToFloor, out hit, 100.0f, mask, QueryTriggerInteraction.Collide)) { 
 
    shoot(hit); 
 
  } 
 
} 
 
// 2 
 
void Update () { 
 
  bool mouseButtonDown = Input.GetMouseButtonDown(0); 
 
  if(mouseButtonDown) { 
 
    raycastOnMouseClick();  
 
  } 
 
} 

讓我們按上面編號進(jìn)行逐個解釋：

1.這個方法把射線從攝相機(jī)射向鼠標(biāo)點擊的位置，然后檢查是否射線相交于符合給定LayerMask掩碼值的游戲?qū)ο蟆?/strong>

void rotateInShootDirection() { 
 
 Vector3 newRotation = Vector3.RotateTowards(transform.forward, shootDirection, 0.01f, 0.0f); 
 
 transform.rotation = Quaternion.LookRotation(newRotation); 

 public void FireProjectile(Ray shootRay) { 
 
  this.shootDirection = shootRay.direction; 
 
  this.transform.position = shootRay.origin; 
 
  rotateInShootDirection(); 
 
} 

 public void SpawnEnemies(bool shouldSpawn) { 
 
  if(shouldSpawn) { 
 
    player = GameObject.FindGameObjectWithTag("Player"); 
 
  } 
 
  this.shouldSpawn = shouldSpawn; 
 
} 
 
void Start () { 
 
  spawnArea = this.GetComponent<BoxCollider>().bounds; 
 
  SpawnEnemies(shouldSpawn); 
 
  InvokeRepeating("spawnEnemy", 0.5f, 1.0f); 
 
} 

 public void Initialize(Transform target, float moveSpeed, int health) { 
 
  this.targetTransform = target; 
 
  this.moveSpeed = moveSpeed; 
 
  this.health = health; 
 
} 

 Vector3 randomSpawnPosition() { 
 
  float x = Random.Range(spawnArea.min.x, spawnArea.max.x); 
 
  float z = Random.Range(spawnArea.min.z, spawnArea.max.z); 
 
  float y = 0.5f; 
 
  return new Vector3(x, y, z); 
 
}  
 
void spawnEnemy() { 
 
  if(shouldSpawn == false || player == null) { 
 
    return; 
 
  }  
 
  int index = Random.Range(0, enemyPrefabs.Length); 
 
  var newEnemy = Instantiate(enemyPrefabs[index], randomSpawnPosition(), Quaternion.identity) as Enemy; 
 
  newEnemy.Initialize(player.transform, 
 
      Random.Range(moveSpeedRange[0], moveSpeedRange[1]), 
 
      Random.Range(healthRange[0], healthRange[1])); 
 
} 

void collidedWithEnemy(Enemy enemy) { 
 
 enemy.Attack(this); 
 
 if(health <= 0) { 
 
   if(onPlayerDeath != null) { 
 
     onPlayerDeath(this); 
 
   } 
 
 } 

 void Start () { 
 
  var player = GameObject.FindGameObjectWithTag("Player").GetComponent<Player>(); 
 
  player.onPlayerDeath += onPlayerDeath; 
 
}  
 
void onPlayerDeath(Player player) { 
 
  enemyProducer.SpawnEnemies(false); 
 
  Destroy(player.gameObject);  
 
  Invoke("restartGame", 3); 
 
} 

void restartGame() { 
 
 var enemies = GameObject.FindGameObjectsWithTag("Enemy"); 
 
 foreach (var enemy in enemies) 
 
 { 
 
   Destroy(enemy); 
 
 }  
 
 var playerObject = Instantiate(playerPrefab, new Vector3(0, 0.5f, 0), Quaternion.identity) as GameObject; 
 
 var cameraRig = Camera.main.GetComponent<CameraRig>(); 
 
 cameraRig.target = playerObject; 
 
 enemyProducer.SpawnEnemies(true); 
 
 playerObject.GetComponent<Player>().onPlayerDeath += onPlayerDeath;