保龄球游戏Demo

记录的一个简单课后作业...

1、分析需求文案策划

---

 阅读Unity3D保龄球案例设计和积分规则，最后整理游戏规则：

2、搭建游戏场景

---

导入场景资源包，发现运行资源包的场景发现报错，原因大体是因为网格内陷导致网格碰撞器出现了些小问题，这通常出现在早期Unity版本资源包。

通过勾选每个保龄球的Collider中Convex选项，将不报错。

 

加载各种模型资源，一系列的操作，最后搭建将场景搭建完毕。把所有的保龄球放在一个AllBowls空物体下，把AllBowls和ball制作成一个预制体。

 3、编写保龄球的控制脚本

---

新建一个BallController.cs脚本组件，用来管理球的发射方法。普通情况下，正常情况玩保龄球，会有以下几种操作：

1. 捡球
2. 带球到到发球线
3. 给球施加一个方向的力

用射线的方式可以达到需求，但是具体如何实现还得需要分析：

我们可以通过射线找到两个关键点扔球点和发球点，两点确定发球方向。在扔球点捡起球，在发球点发射。

根据场景我选择世界坐标Z=8这个轴作为发球面，这有很大的瑕疵，以后会逐渐修正。

BallController.cs代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 保龄球的控制
/// </summary>
public class BallController : MonoBehaviour
{

    #region 射线相关

    /// <summary>
    /// 射线碰撞信息
    /// </summary>
    private RaycastHit hit;
    /// <summary>
    /// 图层遮罩
    /// </summary>
    private LayerMask mask;
    /// <summary>
    /// 球的位置
    /// </summary>
    public Transform ballTrans;

    #endregion

    /// <summary>
    /// 推力范围
    /// </summary>
    public Transform pushArea;
    /// <summary>
    /// 球的半径
    /// </summary>
    [SerializeField]
    private float ballRadius;
    /// <summary>
    /// 扔球点
    /// </summary>
    private Vector3 ballPushOrgin;
    /// <summary>
    /// 球左右方向差量
    /// </summary>
    private Vector3 ballPushDir;

    //是否推出去
    static bool pushed = false;
    private void Start()
    {
        //获取球的半径
        ballRadius = ballTrans.GetComponent<SphereCollider>().radius;
        GetComponent<Rigidbody>().isKinematic =true;
    }

    private void Update()
    {
        //发射一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        //如果还没有推出去这个球
        if (!pushed)
        {
            //推球逻辑
            if (Physics.Raycast(ray, out hit, 1000, LayerMask.GetMask("AreaFloor")))
            {
                //推出去
                Vector3 _ballPushTrans = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                if (hit.transform == pushArea)
                {
                    _ballPushTrans = new Vector3(hit.point.x, hit.point.y + 0.3f, hit.point.z);//球的位置
                    ballTrans.position = _ballPushTrans;
                    ballPushOrgin = hit.point; ;//记录球的起点
                    //Debug.Log(hit.point.x + "," + hit.point.y + "," + hit.point.z);
                }
                else
                {
                    if (!pushed && hit.point.z < 8f && ballPushOrgin != Vector3.zero)//捡起保龄球并且它的发射距离超过世界坐标Z=8f（没有）
                    {
                        Vector3 _ballPushDir = hit.point;//记录一下球的终点
                        Debug.Log(ballPushOrgin);
                        ballPushDir = _ballPushDir - ballPushOrgin;
                        pushed = true;
                        ballTrans.position = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                        GetComponent<Rigidbody>().isKinematic = false;
                        ballTrans.GetComponent<Rigidbody>().AddForce((transform.forward + ballPushDir) * 20, ForceMode.Impulse);

                    }
                }
            }
        }
    }
}

到现在为止发球功能可以实现。

4、每球得分计算

---

新建一个Bowl.cs脚本组件，检测得分情况。让每个保龄球均挂载该组件。

        

关于如何判断这个保龄球是否倒了，选择使用transform.localRotation中X和Z属性，如果他们的绝对值大于0.3f，我们就认为这个保龄球倒了。当然我们可以有其他更好的方法，比如碰撞器和触发器，不过通过计算网格的接触点，这会稍微增加一点小小的性能消耗，这个方法会更精准但是我们并不需要这么精准的操作。

Bowl.cs代码如下：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 保龄球
/// </summary>
public class Bowl : MonoBehaviour
{
    /// <summary>
    /// 是否得分
    /// </summary>
    public bool GetScore;

    private void FixedUpdate()
    {
        if (!GetScore)
        {
            if (Mathf.Abs(transform.localRotation.x) > 0.3f || Mathf.Abs(transform.localRotation.z) > 0.3f)
            {

                GetScore = true;
                Debug.LogWarning("分数加+1");
            }
        }
    }
}

 最后运行测试一下：

 

5、UI统计分数面板

---

 UI的搭建选择使用UGUI，首先建立一个新画布和相机，修改命名。

对Player_UI_Camera和Player_UI_Canvas进行调整，以适应场景。

    

接下来就是UI界面搭建。

新建一个脚本GameManage.cs组件，用来游戏管理。挂载到Player_UI_Panel对象上。可是如何进行游戏管理？把所有的UIText设置更新都写在GameManage.cs里？这无疑对GamManage.cs产生较大的功能负担，所以我们新建的GameManage.cs先不编辑，建一个ScoreItem.cs类，这个东西负责统计存储和修改每轮分数。然后让GameManage去管理它。

编写ScoreItem.cs:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class ScoreItem : MonoBehaviour
{
    /// <summary>
    /// 所有分数文字
    /// </summary>
    public Text[] SocreTexts;
    /// <summary>
    /// 每轮分数
    /// </summary>
    [SerializeField]
    private int[] Scores;
    /// <summary>
    /// 本轮分数总和
    /// </summary>
    public int AllScoreItemNum;
    /// <summary>
    /// 本轮全中？
    /// </summary>
    public bool isStrike = false;
    /// <summary>
    /// 本轮补中？
    /// </summary>
    public bool isSpare = false;

    public void Start()
    {
        Scores = new int[SocreTexts.Length - 1];//每轮分数初始化
    }
    /// <summary>
    /// 每轮分数设置索引为_index的分数文本的值为_score
    /// </summary>
    /// <param name="_index">SocreTexts索引</param>
    /// <param name="_score">分数</param>
    public void SetScoreText(int _index, int _score)
    {
        Scores = new int[SocreTexts.Length];//更新设置分数
        Scores[_index] = _score;//更新并存储分数
        AllScoreItemNum = 0;
        foreach (var item in Scores)
        {
            AllScoreItemNum += item;//累加本轮分数总和
        }
    }
    /// <summary>
    /// 显示所有分数
    /// </summary>
    public void ShowScore()
    {
        //设置每轮
        for (int i = 0; i < SocreTexts.Length - 1; i++)
        {
            SocreTexts[i].text = Scores[i].ToString();
        }
        SocreTexts[SocreTexts.Length - 1].text = AllScoreItemNum.ToString();//总分设置

    }
}

 我们为每个ScoreItem（前九局）和FinalScore（最后一局）这些对象都挂载ScoreItem.cs组件并绑定每个ScoreItem中的ScoreTexts。

其中ScoreItem（前九局）绑定每个子对象的文本对象如下：

  

最后一个FinalScore绑定如下：

绑定完毕后，我们只要获取每个ScoreItem就能直接更新每局数据了。所以我们要在GameManage内编写这些对象的引用，GameManage只有一个，所以我们可以把它单例，全局调用，SocreItems数组存储每局ScoreItem。我们先简单编写GameManage一下：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class GameManage : MonoBehaviour
{
    #region 单例

    private static GameManage _Instacne;
    /// <summary>
    /// 游戏管理单例
    /// </summary>
    public static GameManage Instacne
    {
        get
        {
            return _Instacne;
        }

    }
    private void Awake()
    {
        _Instacne = this;
    }
    #endregion
    /// <summary>
    /// 每局分数块游戏对象
    /// </summary>
    public ScoreItem[] SocreItems;

    /// <summary>
    /// 每球的临时得分
    /// </summary>
    public int _tempScore;

    /// <summary>
    /// 保龄球瓶预制体
    /// </summary>
    public GameObject bowlsPrefabs;

    /// <summary>
    /// 保龄球控制预制体
    /// </summary>
    public BallController ballController;


}

 把刚才的ScoreItem那些组件绑定，并顺手绑定一下BowlsPrefabs：

 绑定结束。

修改重新修改一下Bowl然后再发射一球

public class Bowl : MonoBehaviour
{
    /// <summary>
    /// 是否得分
    /// </summary>
    public bool GetScore;

    private void FixedUpdate()
    {
        if (!GetScore)
        {
            if (Mathf.Abs(transform.localRotation.x) > 0.3f || Mathf.Abs(transform.localRotation.z) > 0.3f)
            {

                GetScore = true;
                GameManage.Instacne._tempScore++;//这轮分数
            }
        }
    }
}

 测试一下，已经清晰的看见GameManage的TempScore变量=6，也就是这一球得分：

 

 6、刷新出球

---

发球得分已经可以获取到了，那么接下来要实现的功能就是如何结束此球结束，开始下一球，不断刷新出球。我们的思路如下：

所以我们重新修改一下GameManage.cs：

   #region 单例

    private static GameManage _Instacne;
    /// <summary>
    /// 游戏管理单例
    /// </summary>
    public static GameManage Instacne
    {
        get
        {
            return _Instacne;
        }

    }
    private void Awake()
    {
        _Instacne = this;
    }
    #endregion
    /// <summary>
    /// 每局分数块游戏对象
    /// </summary>
    public ScoreItem[] SocreItems;

    /// <summary>
    /// 每球的临时得分
    /// </summary>
    public int _tempScore;

    /// <summary>
    /// 墙壁
    /// </summary>
    public Transform roomWall;

    /// <summary>
    /// 推力范围
    /// </summary>
    public Transform pushArea;

    /// <summary>
    /// 保龄球瓶预制体
    /// </summary>
    public GameObject bowlsPrefabs;
    /// <summary>
    /// 保龄球预制体
    /// </summary>
    public GameObject ballPrefab;
    /// <summary>
    /// 保龄球对象
    /// </summary>
    public GameObject ball;
    public BallController _BallController;
    /// <summary>
    /// 出界等待时间
    /// </summary>
    [SerializeField]
    private float outAreaWaitTime = 5f;

    private float _temp;
    /// <summary>
    /// 每球声明时间
    /// </summary>
    [SerializeField]
    private float BallLifeTime = 30f;
    /// <summary>
    /// 滚动时间
    /// </summary>
    private float _tempLife;

    private void Start()
    {
        CreatBall();
    }
    private void Update()
    {
        if (ball != null)
        {
            if (_BallController.pushed)//球已经被推出去
            {
                _tempLife += Time.deltaTime;
                if (_tempLife>BallLifeTime&&!_BallController.isOutArea)//一直没出届
                {
                    Debug.Log("此球分数：" + _tempScore);
                    _tempLife = 0;
                    _tempScore = 0;//清零
                    DestroyImmediate(ball);
                    CreatBall();
                }
                if (_BallController.isOutArea)//球出界
                {
                    _temp += Time.deltaTime;
                    if (_temp > outAreaWaitTime)//超过出界时间
                    {
                        Debug.Log("此球分数：" + _tempScore);
                        _tempLife = 0;
                        _temp = 0;//重新计时
                        _tempScore = 0;//清零
                        DestroyImmediate(ball);
                        CreatBall();
                    }
                }
            }
        }
    }
    public void CreatBall()
    {
        if (ball == null)
        {
            ball = Instantiate(ballPrefab) as GameObject;
            _BallController = ball.GetComponent<BallController>();
            _BallController.Inits();
        }
    }

 再绑定一下各值。

稍微修改一下BallController.cs，添加越界的碰撞检测：

    #region 射线相关

    /// <summary>
    /// 射线碰撞信息
    /// </summary>
    private RaycastHit hit;
    /// <summary>
    /// 图层遮罩
    /// </summary>
    private LayerMask mask;
    /// <summary>
    /// 球的位置
    /// </summary>
    public Transform ballTrans;

    #endregion


    /// <summary>
    /// 球的半径
    /// </summary>
    [SerializeField]
    private float ballRadius;
    /// <summary>
    /// 扔球点
    /// </summary>
    private Vector3 ballPushOrgin;
    /// <summary>
    /// 球左右方向差量
    /// </summary>
    private Vector3 ballPushDir;

    /// <summary>
    /// 是否推出去
    /// </summary>
    public bool pushed = false;


    /// <summary>
    /// 是否撞墙
    /// </summary>
    public bool ishitWall;
    /// <summary>
    /// 出界了
    /// </summary>
    public bool isOutArea;

    /// <summary>
    /// 保龄球初始化
    /// </summary>
    public void Inits() {
        //获取球的半径
        ballRadius = ballTrans.GetComponent<SphereCollider>().radius;
        GetComponent<Rigidbody>().velocity = Vector3.zero;
        GetComponent<Rigidbody>().isKinematic = true;//不受动力
        isOutArea = false;//没有越界
        pushed = false;//没有推出去
        ishitWall =false;//没有撞墙
    }

    private void Update()
    {
        //发射一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        //如果还没有推出去这个球
        if (!pushed)
        {
            //推球逻辑
            if (Physics.Raycast(ray, out hit, 1000, LayerMask.GetMask("AreaFloor")))
            {
                //推出去
                Vector3 _ballPushTrans = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                if (hit.transform == GameManage.Instacne.pushArea)
                {
                    _ballPushTrans = new Vector3(hit.point.x, hit.point.y + 0.3f, hit.point.z);//球的位置
                    ballTrans.position = _ballPushTrans;
                    ballPushOrgin = hit.point; ;//记录球的起点
                    //Debug.Log(hit.point.x + "," + hit.point.y + "," + hit.point.z);
                }
                else
                {
                    if (!pushed && hit.point.z < 8f && ballPushOrgin != Vector3.zero)//捡起保龄球并且它的发射距离超过世界坐标Z=8f（没有）
                    {
                        Vector3 _ballPushDir = hit.point;//记录一下球的终点
                        Debug.Log(ballPushOrgin);
                        ballPushDir = new Vector3(_ballPushDir.x - ballPushOrgin.x, 0, 0);
                        pushed = true;
                        ballTrans.position = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                        GetComponent<Rigidbody>().isKinematic = false;
                        ballTrans.GetComponent<Rigidbody>().AddForce((transform.forward + ballPushDir) * 25, ForceMode.Impulse);

                    }
                }
            }
        }
    }
    /// <summary>
    /// 碰撞器检测
    /// </summary>
    /// <param name="collision"></param>
    private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.layer != 8 && pushed)
        {
            Debug.Log("球出界了！");
            isOutArea = true;
        }
    }

 截止到目前为止刷新球的功能没问题了

7、游戏逻辑实现（显示统计每轮得分）

---

 接下来的几部就实现最后游戏逻辑了，也是最麻烦的。由于前期已经做了较多的功能，所以现在已经减轻了不少代码负担。 

在GameManage.cs定义一个indexItem，记录目前第几轮。

分析一下，如果你开始每一轮第一球打出Strike（10瓶全中），第一轮直接就结束了，但是这一轮的总分还没结束，因为Strike要加下两球的得分。

如果第一球并没有打出Strike，不管第二球打出什么都会结束，第二球如果打出Spare（补中），这一轮的总分也没结束，因为Spare要加下一球的得分；第二球如果没有打出Spare（补中），这一轮的总分就可以算出来了这两球得分之和。

 我们先解决第一轮打球问题，我们在GameManage定义一个方法处理得分情况：

    /// <summary>
    /// 传递分数
    /// </summary>
    /// <param name="_score">分数值</param>
    public void SetScore(int _score)
    {
        if (indexItem < 9)//前九轮
        {
            if (_tempNumBall == 1)//第一球
            {
                SocreItems[indexItem].SetScoreText(0, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score == 10)//分数为10
                {

                    Debug.LogWarning("Strike全中！");
                    SocreItems[indexItem].isStrike = true;//设置第一球
                    indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                    _tempNumBall = 1;//开始新的一轮
                }
                else//不为10
                {
                    _tempNumBall = 2;//开始下一个球
                }
            }
            else if (_tempNumBall == 2)//第二球
            {
                SocreItems[indexItem].SetScoreText(1, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score + SocreItems[indexItem].Scores[0] == 10)//yi
                {

                    Debug.LogWarning("Spare补中！");
                    SocreItems[indexItem].isSpare = true;//设置第一球
                }
                indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                _tempNumBall = 1;//开始新的一轮
            }
        }
    }

对到目前为止四个核心代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class GameManage : MonoBehaviour
{
    #region 单例

    private static GameManage _Instacne;
    /// <summary>
    /// 游戏管理单例
    /// </summary>
    public static GameManage Instacne
    {
        get
        {
            return _Instacne;
        }

    }
    private void Awake()
    {
        _Instacne = this;
    }
    #endregion
    /// <summary>
    /// 每局分数块游戏对象
    /// </summary>
    public ScoreItem[] SocreItems;

    /// <summary>
    /// 每球的临时得分
    /// </summary>
    public int _tempScore;

    /// <summary>
    /// 墙壁
    /// </summary>
    public Transform roomWall;

    /// <summary>
    /// 推力范围
    /// </summary>
    public Transform pushArea;

    /// <summary>
    /// 保龄球瓶预制体
    /// </summary>
    public GameObject bowlsPrefabs;
    /// <summary>
    /// 保龄球预制体
    /// </summary>
    public GameObject ballPrefab;
    /// <summary>
    /// 保龄球对象
    /// </summary>
    public GameObject ball;
    public BallController _BallController;
    /// <summary>
    /// 出界等待时间
    /// </summary>
    [SerializeField]
    private float outAreaWaitTime = 5f;

    private float _temp;
    /// <summary>
    /// 每球声明时间
    /// </summary>
    [SerializeField]
    private float BallLifeTime = 30f;
    /// <summary>
    /// 滚动时间
    /// </summary>
    private float _tempLife;
    /// <summary>
    /// 轮数
    /// </summary>
    public int indexItem;
    /// <summary>
    /// 每轮第N球
    /// </summary>
    public int _tempNumBall;

    private void Start()
    {
        indexItem = 0;
        _tempNumBall = 1;//第1球
        CreatBall();
    }
    private void Update()
    {
        if (ball != null)
        {
            if (_BallController.pushed)//球已经被推出去
            {
                _tempLife += Time.deltaTime;
                if (_tempLife > BallLifeTime && !_BallController.isOutArea)//一直没出届
                {
                    Debug.Log("此球分数：" + _tempScore);
                    SetScore(_tempScore);
                    _tempLife = 0;
                    _tempScore = 0;//清零
                    DestroyImmediate(ball);
                    CreatBall();
                }
                if (_BallController.isOutArea)//球出界
                {
                    _temp += Time.deltaTime;
                    if (_temp > outAreaWaitTime)//超过出界时间
                    {
                        Debug.Log("球出界！此球得分：" + _tempScore);
                        SetScore(_tempScore);
                        _tempLife = 0;
                        _temp = 0;//重新计时
                        _tempScore = 0;//清零
                        DestroyImmediate(ball);
                        CreatBall();
                    }
                }
            }
        }
    }
    public void CreatBall()
    {
        if (ball == null)
        {
            ball = Instantiate(ballPrefab) as GameObject;
            _BallController = ball.GetComponent<BallController>();
            _BallController.Inits();
        }
    }
    /// <summary>
    /// 传递分数
    /// </summary>
    /// <param name="_score">分数值</param>
    public void SetScore(int _score)
    {
        //indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
        if (indexItem < 9)//前九轮
        {
            if (_tempNumBall == 1)//第一球
            {
                SocreItems[indexItem].SetScoreText(0, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score == 10)//分数为10
                {

                    Debug.LogWarning("Strike全中！");
                    SocreItems[indexItem].isStrike = true;//设置第一球
                    indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                    _tempNumBall = 1;//开始新的一轮
                }
                else//不为10
                {
                    _tempNumBall = 2;//开始下一个球
                }
            }
            else if (_tempNumBall == 2)//第二球
            {
                SocreItems[indexItem].SetScoreText(1, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score + SocreItems[indexItem].Scores[0] == 10)//yi
                {

                    Debug.LogWarning("Spare补中！");
                    SocreItems[indexItem].isSpare = true;//设置第一球
                }
                indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                _tempNumBall = 1;//开始新的一轮
            }
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 保龄球
/// </summary>
public class Bowl : MonoBehaviour
{
    /// <summary>
    /// 是否得分
    /// </summary>
    public bool GetScore;
    /// <summary>
    /// 瓶号索引
    /// </summary>
    public int Index;

    private void FixedUpdate()
    {
        if (!GetScore)
        {
            if (Mathf.Abs(transform.localRotation.x) > 0.3f || Mathf.Abs(transform.localRotation.z) > 0.3f)
            {

                GetScore = true;
                GameManage.Instacne._tempScore++;//这轮分数
            }
        }
    }

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 保龄球的控制
/// </summary>
public class BallController : MonoBehaviour
{

    #region 射线相关

    /// <summary>
    /// 射线碰撞信息
    /// </summary>
    private RaycastHit hit;
    /// <summary>
    /// 图层遮罩
    /// </summary>
    private LayerMask mask;
    /// <summary>
    /// 球的位置
    /// </summary>
    public Transform ballTrans;

    #endregion


    /// <summary>
    /// 球的半径
    /// </summary>
    [SerializeField]
    private float ballRadius;
    /// <summary>
    /// 扔球点
    /// </summary>
    private Vector3 ballPushOrgin;
    /// <summary>
    /// 球左右方向差量
    /// </summary>
    private Vector3 ballPushDir;

    /// <summary>
    /// 是否推出去
    /// </summary>
    public bool pushed = false;


    /// <summary>
    /// 是否撞墙
    /// </summary>
    public bool ishitWall;
    /// <summary>
    /// 出界了
    /// </summary>
    public bool isOutArea;

    /// <summary>
    /// 保龄球初始化
    /// </summary>
    public void Inits() {
        //获取球的半径
        ballRadius = ballTrans.GetComponent<SphereCollider>().radius;
        GetComponent<Rigidbody>().velocity = Vector3.zero;
        GetComponent<Rigidbody>().isKinematic = true;//不受动力
        isOutArea = false;//没有越界
        pushed = false;//没有推出去
        ishitWall =false;//没有撞墙
    }

    private void Update()
    {
        //发射一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        //如果还没有推出去这个球
        if (!pushed)
        {
            //推球逻辑
            if (Physics.Raycast(ray, out hit, 1000, LayerMask.GetMask("AreaFloor")))
            {
                //推出去
                Vector3 _ballPushTrans = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                if (hit.transform == GameManage.Instacne.pushArea)
                {
                    _ballPushTrans = new Vector3(hit.point.x, hit.point.y + 0.3f, hit.point.z);//球的位置
                    ballTrans.position = _ballPushTrans;
                    ballPushOrgin = hit.point; ;//记录球的起点
                    //Debug.Log(hit.point.x + "," + hit.point.y + "," + hit.point.z);
                }
                else
                {
                    if (!pushed && hit.point.z < 8f && ballPushOrgin != Vector3.zero)//捡起保龄球并且它的发射距离超过世界坐标Z=8f（没有）
                    {
                        Vector3 _ballPushDir = hit.point;//记录一下球的终点
                        Debug.Log(ballPushOrgin);
                        ballPushDir = new Vector3(_ballPushDir.x - ballPushOrgin.x, 0, 0);
                        pushed = true;
                        ballTrans.position = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                        GetComponent<Rigidbody>().isKinematic = false;
                        ballTrans.GetComponent<Rigidbody>().AddForce((transform.forward + ballPushDir) * 25, ForceMode.Impulse);

                    }
                }
            }
        }
    }
    /// <summary>
    /// 碰撞器检测
    /// </summary>
    /// <param name="collision"></param>
    private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.layer != 8 && pushed)
        {
            //Debug.Log("球出界了！");
            isOutArea = true;
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 保龄球的控制
/// </summary>
public class BallController : MonoBehaviour
{

    #region 射线相关

    /// <summary>
    /// 射线碰撞信息
    /// </summary>
    private RaycastHit hit;
    /// <summary>
    /// 图层遮罩
    /// </summary>
    private LayerMask mask;
    /// <summary>
    /// 球的位置
    /// </summary>
    public Transform ballTrans;

    #endregion


    /// <summary>
    /// 球的半径
    /// </summary>
    [SerializeField]
    private float ballRadius;
    /// <summary>
    /// 扔球点
    /// </summary>
    private Vector3 ballPushOrgin;
    /// <summary>
    /// 球左右方向差量
    /// </summary>
    private Vector3 ballPushDir;

    /// <summary>
    /// 是否推出去
    /// </summary>
    public bool pushed = false;


    /// <summary>
    /// 是否撞墙
    /// </summary>
    public bool ishitWall;
    /// <summary>
    /// 出界了
    /// </summary>
    public bool isOutArea;

    /// <summary>
    /// 保龄球初始化
    /// </summary>
    public void Inits() {
        //获取球的半径
        ballRadius = ballTrans.GetComponent<SphereCollider>().radius;
        GetComponent<Rigidbody>().velocity = Vector3.zero;
        GetComponent<Rigidbody>().isKinematic = true;//不受动力
        isOutArea = false;//没有越界
        pushed = false;//没有推出去
        ishitWall =false;//没有撞墙
    }

    private void Update()
    {
        //发射一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        //如果还没有推出去这个球
        if (!pushed)
        {
            //推球逻辑
            if (Physics.Raycast(ray, out hit, 1000, LayerMask.GetMask("AreaFloor")))
            {
                //推出去
                Vector3 _ballPushTrans = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                if (hit.transform == GameManage.Instacne.pushArea)
                {
                    _ballPushTrans = new Vector3(hit.point.x, hit.point.y + 0.3f, hit.point.z);//球的位置
                    ballTrans.position = _ballPushTrans;
                    ballPushOrgin = hit.point; ;//记录球的起点
                    //Debug.Log(hit.point.x + "," + hit.point.y + "," + hit.point.z);
                }
                else
                {
                    if (!pushed && hit.point.z < 8f && ballPushOrgin != Vector3.zero)//捡起保龄球并且它的发射距离超过世界坐标Z=8f（没有）
                    {
                        Vector3 _ballPushDir = hit.point;//记录一下球的终点
                        Debug.Log(ballPushOrgin);
                        ballPushDir = new Vector3(_ballPushDir.x - ballPushOrgin.x, 0, 0);
                        pushed = true;
                        ballTrans.position = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                        GetComponent<Rigidbody>().isKinematic = false;
                        ballTrans.GetComponent<Rigidbody>().AddForce((transform.forward + ballPushDir) * 25, ForceMode.Impulse);

                    }
                }
            }
        }
    }
    /// <summary>
    /// 碰撞器检测
    /// </summary>
    /// <param name="collision"></param>
    private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.layer != 8 && pushed)
        {
            //Debug.Log("球出界了！");
            isOutArea = true;
        }
    }
}

打第一轮测试一下效果，额，测试了八九次才打出Strike，非常理想的达到预期了的效果：

  

8、游戏逻辑实现（多次开局摆放瓶子）

---

 

保龄球每打完一局就应该把倒的瓶子清除，然后重新摆放。

 其实摆放瓶子方法也很好分析，每轮结束销毁瓶子堆，不结束就把倒得那些隐藏掉SetActive（false）。

关于何时销毁，我选择把它放在分数统计里调用，因为只有经过分数统计你才知道是否所有瓶子都倒下了。

摆放的方法放在生成新球的后面：

而摆放瓶子的方法如下：

　　 /// <summary>
    /// 摆放瓶子
    /// </summary>
    public void SetBowls()
    {
        if (bowls == null)//没有瓶子
        {
            bowls = Instantiate(bowlsPrefabs, bowlsParentTrans) as GameObject;
            AllBowls = new Bowl[10];//10个瓶
            foreach (var item in bowls.GetComponentsInChildren<Bowl>())
            {
                AllBowls[item.Index] = item;//把加载的瓶子放进数组里
            } 
        }
        else
        {
            foreach (var item in AllBowls)
            {
                if (item.GetScore)//没有倒下过显示他们
                {
                    item.gameObject.SetActive(!item.GetScore);
                }
            }
        }
    }

 关于对象的绑定：

GameManage.cs里面的代码也越来越多，整理以后的GameManage如下：

//------------------------------------------------------------------------------
// Copyright 2017 21世纪少年. All rights reserved.
// 
// Unity5.6.3f1 Editor make it
// BowlingHall_Project
//
// CreatTime: #10/7/2017#
// Author: Unity Guo
//------------------------------------------------------------------------------
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class GameManage : MonoBehaviour
{
    #region 单例

    private static GameManage _Instacne;
    /// <summary>
    /// 游戏管理单例
    /// </summary>
    public static GameManage Instacne
    {
        get
        {
            return _Instacne;
        }

    }
    private void Awake()
    {
        _Instacne = this;
    }
    #endregion


    #region 场景信息

    /// <summary>
    /// 墙壁
    /// </summary>
    public Transform roomWall;
    /// <summary>
    /// 推力范围
    /// </summary>
    public Transform pushArea;
    /// <summary>
    /// 保龄球瓶堆的父物体位置
    /// </summary>
    public Transform bowlsParentTrans;

    #endregion

    #region 游戏对象

    /// <summary>
    /// 保龄球瓶预制体
    /// </summary>
    public GameObject bowlsPrefabs;
    /// <summary>
    /// 保龄球瓶堆
    /// </summary>
    public GameObject bowls;
    /// <summary>
    /// 保龄球预制体
    /// </summary>
    public GameObject ballPrefab;
    /// <summary>
    /// 保龄球对象
    /// </summary>
    public GameObject ball;
    /// <summary>
    /// 保龄球上的控制器
    /// </summary>
    public BallController _BallController;

    #endregion

    #region 时间管理
    /// <summary>
    /// 出界等待时间
    /// </summary>
    [SerializeField]
    private float outAreaWaitTime = 5f;

    private float _temp;
    /// <summary>
    /// 每球声明时间
    /// </summary>
    [SerializeField]
    private float BallLifeTime = 30f;
    /// <summary>
    /// 滚动时间
    /// </summary>
    private float _tempLife;

    #endregion

    /// <summary>
    /// 每局分数块游戏对象
    /// </summary>
    public ScoreItem[] SocreItems;
    /// <summary>
    /// 管理所有瓶子的数组
    /// </summary>
    public Bowl[] AllBowls;
    /// <summary>
    /// 每球的临时得分
    /// </summary>
    public int _tempScore;
    /// <summary>
    /// 轮数
    /// </summary>
    public int indexItem;
    /// <summary>
    /// 每轮第N球
    /// </summary>
    public int _tempNumBall;

    private void Start()
    {
        indexItem = 0;
        _tempNumBall = 1;//第1球
        SetBall();
        SetBowls();
    }
    private void Update()
    {
        if (ball != null)
        {
            if (_BallController.pushed)//球已经被推出去
            {
                _tempLife += Time.deltaTime;
                if (_tempLife > BallLifeTime && !_BallController.isOutArea)//一直没出届
                {
                    Debug.Log("此球分数：" + _tempScore);
                    SetScore(_tempScore);
                    _tempLife = 0;
                    _tempScore = 0;//清零
                    DestroyImmediate(ball);
                    SetBall();
                    SetBowls();
                }
                if (_BallController.isOutArea)//球出界
                {
                    _temp += Time.deltaTime;
                    if (_temp > outAreaWaitTime)//超过出界时间
                    {
                        Debug.Log("球出界！此球得分：" + _tempScore);
                        SetScore(_tempScore);
                        _tempLife = 0;
                        _temp = 0;//重新计时
                        _tempScore = 0;//清零
                        DestroyImmediate(ball);
                        SetBall();
                        SetBowls();
                    }
                }
            }
        }
    }
    /// <summary>
    /// 生成新球
    /// </summary>
    public void SetBall()
    {
        if (ball == null)
        {
            ball = Instantiate(ballPrefab) as GameObject;
            _BallController = ball.GetComponent<BallController>();
            _BallController.Inits();
        }
    }
    /// <summary>
    /// 传递分数
    /// </summary>
    /// <param name="_score">分数值</param>
    public void SetScore(int _score)
    {
        //indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
        if (indexItem < 9)//前九轮
        {
            if (_tempNumBall == 1)//第一球
            {
                SocreItems[indexItem].SetScoreText(0, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score == 10)//分数为10
                {
                    Debug.LogWarning("Strike全中！");
                    SocreItems[indexItem].isStrike = true;//设置第一球
                    indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                    DestroyImmediate(bowls);//清空瓶子
                    _tempNumBall = 1;//开始新的一轮
                }
                else//不为10
                {
                    _tempNumBall = 2;//开始下一个球
                }
            }
            else if (_tempNumBall == 2)//第二球
            {
                SocreItems[indexItem].SetScoreText(1, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score + SocreItems[indexItem].Scores[0] == 10)//yi
                {
                    Debug.LogWarning("Spare补中！");
                    SocreItems[indexItem].isSpare = true;//设置第一球
                }
                indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                DestroyImmediate(bowls);//清空瓶子
                _tempNumBall = 1;//开始新的一轮
            }
        }
    }

    /// <summary>
    /// 摆放瓶子
    /// </summary>
    public void SetBowls()
    {
        if (bowls == null)//没有瓶子
        {
            bowls = Instantiate(bowlsPrefabs, bowlsParentTrans) as GameObject;
            AllBowls = new Bowl[10];//10个瓶
            foreach (var item in bowls.GetComponentsInChildren<Bowl>())
            {
                AllBowls[item.Index] = item;//把加载的瓶子放进数组里
            } 
        }
        else
        {
            foreach (var item in AllBowls)
            {
                if (item.GetScore)//没有倒下过显示他们
                {
                    item.gameObject.SetActive(!item.GetScore);
                }
            }
        }
    }
}

 9、游戏逻辑实现（Strike全中和Spare补中计分实现）

---

好了到最麻烦的地方了，分数逻辑设置重新理清一下得分思路，在前面我们写了一个SetSocre()方法设置分数，但是没法处理补分和全中，而且也没有办法处理第十轮，所以我们稍加修改，完善并添加特殊加分方法AddScore()，在ScoreItem类中，每次设置分数都让他重新设置特殊分数：

而且之前分数我们直接用int[]的数组存储，我们改进一下在，ScoreItem中添加一个特殊类Score：

/// <summary>
/// 分数信息类
/// </summary>
public class Score
{
    /// <summary>
    /// Score构造参数
    /// </summary>
    /// <param name="_value"></param>
    public Score(int _value)
    {
        value = _value;
    }
    /// <summary>
    /// 分数值
    /// </summary>
    private int value;
    /// <summary>
    /// 获取分数值
    /// </summary>
    public int Value
    {
        get
        {
            return value;
        }
    }
}

当有分数时实例化一个Score,构造传值分数赋值，而且这个分数不可修改，封装起来只能获取，保证了外界不能修改你的分数。

理清思路逻辑，接下来进行编码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// 分数信息类
/// </summary>
public class Score
{
    /// <summary>
    /// Score构造参数
    /// </summary>
    /// <param name="_value"></param>
    public Score(int _value)
    {
        value = _value;
    }
    /// <summary>
    /// 分数值
    /// </summary>
    private int value;
    /// <summary>
    /// 获取分数值
    /// </summary>
    public int Value
    {
        get
        {
            return value;
        }
    }
}
public class ScoreItem : MonoBehaviour
{
    /// <summary>
    /// 索引
    /// </summary>
    public int index;
    /// <summary>
    /// 所有分数文字
    /// </summary>
    public Text[] SocreTexts;
    /// <summary>
    /// 每轮分数
    /// </summary>
    public Score[] Scores;
    /// <summary>
    /// 本轮分数临时总和
    /// </summary>
    public int _tempScoreItem;
    /// <summary>
    /// 本轮分数总和
    /// </summary>
    public int _Score;
    /// <summary>
    /// 本轮全中？
    /// </summary>
    public bool isStrike = false;
    /// <summary>
    /// 本轮补中？
    /// </summary>
    public bool isSpare = false;
    /// <summary>
    /// 初始化
    /// </summary>
    public void Inits()
    {
        Scores = new Score[SocreTexts.Length - 1];//每轮分数初始化
    }
    /// <summary>
    /// 每轮分数设置索引为_index的分数文本的值为_score
    /// </summary>
    /// <param name="_index">索引</param>
    /// <param name="_score">分数</param>
    public void SetScoreText(int _index, int _score)
    {
        Scores[_index] = new Score(_score);
        Debug.LogWarning("第"+index+"轮："+_index+"球：分数"+_score);
        _tempScoreItem = 0;
        foreach (var item in Scores)
        {
            if (item != null)
            {
                _tempScoreItem += item.Value;//累加本轮分数总和
            }
        }
    }
    /// <summary>
    /// 显示所有分数
    /// </summary>
    public void ShowScore()
    {
        //设置每轮
        for (int i = 0; i < SocreTexts.Length - 1; i++)
        {
            if (Scores[i] != null)
            {
                SocreTexts[i].text = Scores[i].Value.ToString();
            }
            else
            {
                SocreTexts[i].text = "";
            }
        }
        //AddScore();
    }
    /// <summary>
    /// 更新添加分数
    /// </summary>
    public void AddScore()
    {
        _Score = _tempScoreItem;//分数
        int _tempTime = 0;//临时次数计数
        if (isStrike)//全中
        {
            if (index < 9)//当前是前九个分数块
            {
                foreach (var item in GameManage.Instacne.SocreItems[index + 1].Scores)//遍历下一轮所有分数
                {
                    if (item != null)//不为空加分
                    {
                        _Score += item.Value;//分数
                        _tempTime++;
                        if (_tempTime == 2)
                        {
                            break;
                        }
                    }
                    else
                    {
                        if (index <8)//前八个
                        {
                            if (GameManage.Instacne.SocreItems[index + 2].Scores[0] != null)//下一个球也是补中的情况
                            {
                                _Score += GameManage.Instacne.SocreItems[index + 2].Scores[0].Value;
                                _tempTime++;
                                break;
                            }
                        }
                    }
                }
            }
        }
        if (isSpare)
        {
            if (index <9)//前八个
            {
                if (GameManage.Instacne.SocreItems[index + 1].Scores[0] != null)
                {
                    _Score += GameManage.Instacne.SocreItems[index + 1].Scores[0].Value;
                    _tempTime++;//一次
                }
            }
            else if(index ==9)//第九个
            {
            }
        }
        SocreTexts[SocreTexts.Length - 1].text = _Score.ToString();//总分设置
    }
}

 对了再加一个IsOver，游戏结束设置为True，修改之后的GameManage：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class GameManage : MonoBehaviour
{
    #region 单例

    private static GameManage _Instacne;
    /// <summary>
    /// 游戏管理单例
    /// </summary>
    public static GameManage Instacne
    {
        get
        {
            return _Instacne;
        }

    }
    private void Awake()
    {
        _Instacne = this;
    }
    #endregion


    #region 场景信息

    /// <summary>
    /// 墙壁
    /// </summary>
    public Transform roomWall;
    /// <summary>
    /// 推力范围
    /// </summary>
    public Transform pushArea;
    /// <summary>
    /// 保龄球瓶堆的父物体位置
    /// </summary>
    public Transform bowlsParentTrans;

    #endregion

    #region 游戏对象

    /// <summary>
    /// 保龄球瓶预制体
    /// </summary>
    public GameObject bowlsPrefabs;
    /// <summary>
    /// 保龄球瓶堆
    /// </summary>
    public GameObject bowls;
    /// <summary>
    /// 保龄球预制体
    /// </summary>
    public GameObject ballPrefab;
    /// <summary>
    /// 保龄球对象
    /// </summary>
    public GameObject ball;
    /// <summary>
    /// 保龄球上的控制器
    /// </summary>
    public BallController _BallController;
    /// <summary>
    /// 管理所有瓶子的数组
    /// </summary>
    public Bowl[] AllBowls;

    #endregion

    #region 时间管理
    /// <summary>
    /// 出界等待时间
    /// </summary>
    [SerializeField]
    private float outAreaWaitTime = 5f;

    private float _temp;
    /// <summary>
    /// 每球声明时间
    /// </summary>
    [SerializeField]
    private float BallLifeTime = 30f;
    /// <summary>
    /// 滚动时间
    /// </summary>
    private float _tempLife;

    #endregion

    #region 分数管理

    /// <summary>
    /// 每局分数块游戏对象
    /// </summary>
    public ScoreItem[] SocreItems;
    /// <summary>
    /// 每球的临时得分
    /// </summary>
    public int _tempScore;
    /// <summary>
    /// 所有总分
    /// </summary>
    public int AllScore;
    /// <summary>
    /// 所有分数
    /// </summary>
    public Text AllScoreText;
    #endregion
    /// <summary>
    /// 轮数
    /// </summary>
    public int indexItem;
    /// <summary>
    /// 每轮第N球
    /// </summary>
    public int _tempNumBall;
    /// <summary>
    /// 游戏结束
    /// </summary>
    public bool IsOver;

    private void Start()
    {
        indexItem = 0;
        _tempNumBall = 1;//第1球
        SetBall();
        SetBowls();
        //分数初始化
        foreach (var item in SocreItems)
        {
            item.Inits();//初始化
            item.ShowScore();
        }
    }
    private void Update()
    {
        if (ball != null)//游戏没有结束
        {

            if (_BallController.pushed)//球已经被推出去
            {
                _tempLife += Time.deltaTime;
                if (_tempLife > BallLifeTime && !_BallController.isOutArea)//一直没出届
                {
                    Debug.Log("此球分数：" + _tempScore);
                    _tempLife = 0;
                    DestroyImmediate(ball);
                    SetScore(_tempScore);
                    _tempScore = 0;//清零
                    SetBall();
                    SetBowls();
                }
                if (_BallController.isOutArea)//球出界
                {
                    _temp += Time.deltaTime;
                    if (_temp > outAreaWaitTime)//超过出界时间
                    {
                        Debug.Log("球出界！此球得分：" + _tempScore);
                        _tempLife = 0;
                        _temp = 0;//重新计时
                        DestroyImmediate(ball);
                        SetScore(_tempScore);
                        _tempScore = 0;//清零
                        SetBall();
                        SetBowls();
                    }
                }
            }


        }
    }
    /// <summary>
    /// 生成新球
    /// </summary>
    public void SetBall()
    {
        if (ball == null)
        {
            ball = Instantiate(ballPrefab) as GameObject;
            _BallController = ball.GetComponent<BallController>();
            _BallController.Inits();
        }
    }
    /// <summary>
    /// 传递分数
    /// </summary>
    /// <param name="_score">分数值</param>
    public void SetScore(int _score)
    {
        //indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
        if (indexItem < 9)//---------------------------------------------------前九轮
        {
            if (_tempNumBall == 1)//第一球
            {
                SocreItems[indexItem].SetScoreText(0, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score == 10)//分数为10
                {
                    Debug.LogWarning("Strike全中！");
                    SocreItems[indexItem].isStrike = true;//设置第一球
                    indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                    DestroyImmediate(bowls);//清空瓶子
                    _tempNumBall = 1;//开始新的一轮
                }
                else//不为10
                {
                    _tempNumBall = 2;//开始下一个球
                }
            }
            else if (_tempNumBall == 2)//第二球
            {
                SocreItems[indexItem].SetScoreText(1, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score + SocreItems[indexItem].Scores[0].Value == 10)//yi
                {
                    Debug.LogWarning("Spare补中！");
                    SocreItems[indexItem].isSpare = true;//设置第一球
                }
                indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                DestroyImmediate(bowls);//清空瓶子
                _tempNumBall = 1;//开始新的一轮

            }
        }
        else if (indexItem == 9)//--------------------------------------------第十轮
        {
            if (_tempNumBall == 1)//第一球
            {
                if (_score == 10)
                {
                    Debug.LogWarning("Strike全中！");
                    SocreItems[indexItem].isStrike = true;//设置第一球
                    DestroyImmediate(bowls);//清空瓶子
                }
                SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                _tempNumBall = 2;//开始新的一轮
            }
            else if (_tempNumBall == 2)//第二球
            {
                if (!SocreItems[indexItem].isStrike)//不是全中
                {
                    if (SocreItems[indexItem].Scores[0].Value + _score == 10)//达成补中条件
                    {
                        Debug.LogWarning("Spare补中！");
                        SocreItems[indexItem].isSpare = true;//全中
                        DestroyImmediate(bowls);//清空瓶子
                        SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第二球分数
                        SocreItems[indexItem].ShowScore();
                        _tempNumBall = 3;//开始新的一轮,第3球
                    }
                    else
                    {
                        SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第二球分数
                        SocreItems[indexItem].ShowScore();
                        IsOver = true;
                    }
                }
                else//全中下一球
                {
                    DestroyImmediate(bowls);//清空瓶子
                    SocreItems[9].SetScoreText(_tempNumBall - 1, _score);//设置第二球分数
                    SocreItems[9].ShowScore();
                    _tempNumBall = 3;//开始新的一轮,第3球
                }
            }
            else if (_tempNumBall == 3)
            {
                DestroyImmediate(bowls);//清空瓶子
                SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第一球分数
                SocreItems[indexItem].ShowScore();

                IsOver = true;
            }
        }
        AllScore = 0;
        foreach (var item in SocreItems)//加分
        {
            item.AddScore();
            AllScore += item._Score;
        }
        AllScoreText.text = AllScore.ToString();
    }

    /// <summary>
    /// 摆放瓶子
    /// </summary>
    public void SetBowls()
    {
        if (bowls == null)//没有瓶子
        {
            bowls = Instantiate(bowlsPrefabs, bowlsParentTrans) as GameObject;
            AllBowls = new Bowl[10];//10个瓶
            foreach (var item in bowls.GetComponentsInChildren<Bowl>())
            {
                AllBowls[item.Index] = item;//把加载的瓶子放进数组里
            }
        }
        else
        {
            foreach (var item in AllBowls)
            {
                if (item.GetScore)//没有倒下过显示他们
                {
                    item.gameObject.SetActive(!item.GetScore);
                }
            }
        }
    }
}

此外修改一下BallController.cs:

这样游戏结束就捡不起来球了。

 到目前测试一下，基本上游戏大体逻辑已完全解决！但是这并不是最终代码，得分和现实已经没有问题：

 

 10、开始界面的搭建

---

 和Main场景搭建手法差不多，搭建一个Start场景。

接下来然后搭建Start的UI界面，我们发现这个按钮素材需要九宫切图，于是切一下：

经过一系列的UI布局：

关于场景的替换需要注意一下，不要用Application.loadedLevel()，导入UnityEngine.SceneManagement包，用SceneManager.LoadScene()：

我们再编写一个游戏管理的脚本StartManage.cs,让它负责场景的切换和球的表面材质替换。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class StartManage : MonoBehaviour
{
    /// <summary>
    /// 开始按键
    /// </summary>
    public Button PlayBtn;
    /// <summary>
    /// 上一个球
    /// </summary>
    public Button PrevBtn;
    /// <summary>
    /// 下一个球
    /// </summary>
    public Button NextBtn;
    /// <summary>
    /// 球的材质列表
    /// </summary>
    [SerializeField]
    private Texture[] ballTextures;
    /// <summary>
    /// 当前材质索引
    /// </summary>
    [SerializeField]
    private int _tempIndex;
    /// <summary>
    /// 球的材质贴图
    /// </summary>
    public Material ballMaterial;

    void Start()
    {
        _tempIndex = 0;
        PlayBtn.onClick.AddListener(playBtnClick);
        PrevBtn.onClick.AddListener(UpdateRevTexture);
        NextBtn.onClick.AddListener(UpdateNextTexture);
    }
    public void playBtnClick()
    {
        SceneManager.LoadScene("Main");
    }
    /// <summary>
    /// 更换上一个材质
    /// </summary>
    public void UpdateRevTexture() {
        _tempIndex--;
        if (_tempIndex==-1)
        {
            _tempIndex = ballTextures.Length - 1;
        }
        ballMaterial.SetTexture("_MainTex", ballTextures[_tempIndex]);
    }
    /// <summary>
    /// 更换下一个材质
    /// </summary>
    public void UpdateNextTexture()
    {
        _tempIndex++;
        if (_tempIndex == ballTextures.Length)
        {
            _tempIndex = 0;
        }
        ballMaterial.SetTexture("_MainTex", ballTextures[_tempIndex]);
    }
}

 绑定一下：

这样还没有完。我们还需要一个步骤，从游戏界面返回初始界面。打开Main场景，制作一个返回按键。

经过测试后，完成之后两个场景完美切换。

11、发球后的相机跟随

---

 在GameManage上声明主相机Transform变量，绑定

在BallController添加以下代码：

相机跟随实现。

修改后的BallController代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 保龄球的控制
/// </summary>
public class BallController : MonoBehaviour
{

    #region 射线相关

    /// <summary>
    /// 射线碰撞信息
    /// </summary>
    private RaycastHit hit;
    /// <summary>
    /// 图层遮罩
    /// </summary>
    private LayerMask mask;
    /// <summary>
    /// 球的位置
    /// </summary>
    public Transform ballTrans;

    #endregion


    /// <summary>
    /// 球的半径
    /// </summary>
    [SerializeField]
    private float ballRadius;
    /// <summary>
    /// 扔球点
    /// </summary>
    private Vector3 ballPushOrgin;
    /// <summary>
    /// 球左右方向差量
    /// </summary>
    private Vector3 ballPushDir;

    /// <summary>
    /// 是否推出去
    /// </summary>
    public bool pushed = false;

    /// <summary>
    /// 是否撞墙
    /// </summary>
    public bool ishitWall;
    /// <summary>
    /// 出界了
    /// </summary>
    public bool isOutArea;
    /// <summary>
    /// 与相机差距位置
    /// </summary>
    private Vector3 _tempPos;
    /// <summary>
    /// 保龄球初始化
    /// </summary>
    public void Inits()
    {
        //获取球的半径
        ballRadius = ballTrans.GetComponent<SphereCollider>().radius;
        GetComponent<Rigidbody>().velocity = Vector3.zero;
        GetComponent<Rigidbody>().isKinematic = true;//不受动力
        isOutArea = false;//没有越界
        pushed = false;//没有推出去
        ishitWall = false;//没有撞墙
        GameManage.Instacne.CameraTrans.localPosition = Vector3.zero;
        _tempPos = new Vector3(0, -0.5f, -2);
    }

    private void Update()
    {


        //发射一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        //如果还没有推出去这个球
        if (!pushed && !GameManage.Instacne.IsOver)
        {
            //推球逻辑
            if (Physics.Raycast(ray, out hit, 1000, LayerMask.GetMask("AreaFloor")))
            {
                //推出去
                Vector3 _ballPushTrans = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                if (hit.transform == GameManage.Instacne.pushArea)
                {
                    _ballPushTrans = new Vector3(hit.point.x, hit.point.y + 0.3f, hit.point.z);//球的位置
                    ballTrans.position = _ballPushTrans;
                    ballPushOrgin = hit.point; ;//记录球的起点
                                                //Debug.Log(hit.point.x + "," + hit.point.y + "," + hit.point.z);
                }
                else
                {
                    if (!pushed && hit.point.z < 8f && ballPushOrgin != Vector3.zero)//捡起保龄球并且它的发射距离超过世界坐标Z=8f（没有）
                    {
                        Vector3 _ballPushDir = hit.point;//记录一下球的终点
                                                         //Debug.Log(ballPushOrgin);
                        ballPushDir = new Vector3(_ballPushDir.x - ballPushOrgin.x, 0, 0);
                        pushed = true;
                        ballTrans.position = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                        GetComponent<Rigidbody>().isKinematic = false;
                        ballTrans.GetComponent<Rigidbody>().AddForce((transform.forward + ballPushDir) * 35, ForceMode.Impulse);
                    }
                }
            }
        }
        else if (pushed)//推出去了
        {
            if (GameManage.Instacne.CameraTrans.position.z > -7f)
            {
                GameManage.Instacne.CameraTrans.position = transform.position - _tempPos;
            }
        }
    }
    /// <summary>
    /// 碰撞器检测
    /// </summary>
    /// <param name="collision"></param>
    private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.layer != 8 && pushed)
        {
            //Debug.Log("球出界了！");
            isOutArea = true;
        }
    }
}

 12、音效的添加控制 

---

 Start场景中，初始BGM添加：

之后是球控制音效：

修改BallController：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 保龄球的控制
/// </summary>
public class BallController : MonoBehaviour
{

    #region 射线相关

    /// <summary>
    /// 射线碰撞信息
    /// </summary>
    private RaycastHit hit;
    /// <summary>
    /// 图层遮罩
    /// </summary>
    private LayerMask mask;
    /// <summary>
    /// 球的位置
    /// </summary>
    public Transform ballTrans;

    #endregion

    #region 音效管理
    /// <summary>
    /// 鼓掌音源
    /// </summary>
    public AudioClip applausSource;
    /// <summary>
    /// 正在滚动的声音
    /// </summary>
    public AudioClip pushSource;
    /// <summary>
    /// BGM
    /// </summary>
    public AudioClip BGM;
    /// <summary>
    /// 音源
    /// </summary>
    public AudioSource AS;
    /// <summary>
    /// 播放一次
    /// </summary>
    private bool Once;
    #endregion

    /// <summary>
    /// 球的半径
    /// </summary>
    [SerializeField]
    private float ballRadius;
    /// <summary>
    /// 扔球点
    /// </summary>
    private Vector3 ballPushOrgin;
    /// <summary>
    /// 球左右方向差量
    /// </summary>
    private Vector3 ballPushDir;

    /// <summary>
    /// 是否推出去
    /// </summary>
    public bool pushed = false;

    /// <summary>
    /// 是否撞墙
    /// </summary>
    public bool ishitWall;
    /// <summary>
    /// 出界了
    /// </summary>
    public bool isOutArea;
    /// <summary>
    /// 与相机差距位置
    /// </summary>
    private Vector3 _tempPos;
    /// <summary>
    /// 保龄球初始化
    /// </summary>
    public void Inits()
    {
        //获取球的半径
        ballRadius = ballTrans.GetComponent<SphereCollider>().radius;
        GetComponent<Rigidbody>().velocity = Vector3.zero;
        GetComponent<Rigidbody>().isKinematic = true;//不受动力
        isOutArea = false;//没有越界
        pushed = false;//没有推出去
        ishitWall = false;//没有撞墙
        GameManage.Instacne.CameraTrans.localPosition = Vector3.zero;
        _tempPos = new Vector3(0, -0.5f, -2);
        if (!AS.isPlaying)
        {
            if (AS.clip == null)
            {
                AS.clip = BGM;
                AS.loop = true;
                AS.Play();
            }
        }
    }

    private void Update()
    {
        //发射一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        //如果还没有推出去这个球
        if (!pushed && !GameManage.Instacne.IsOver)
        {
            //推球逻辑
            if (Physics.Raycast(ray, out hit, 1000, LayerMask.GetMask("AreaFloor")))
            {
                //推出去
                Vector3 _ballPushTrans = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                if (hit.transform == GameManage.Instacne.pushArea)
                {
                    _ballPushTrans = new Vector3(hit.point.x, hit.point.y + 0.3f, hit.point.z);//球的位置
                    ballTrans.position = _ballPushTrans;
                    ballPushOrgin = hit.point; ;//记录球的起点
                                                //Debug.Log(hit.point.x + "," + hit.point.y + "," + hit.point.z);
                }
                else
                {
                    if (!pushed && hit.point.z < 8f && ballPushOrgin != Vector3.zero)//捡起保龄球并且它的发射距离超过世界坐标Z=8f（没有）
                    {
                        Vector3 _ballPushDir = hit.point;//记录一下球的终点
                                                         //Debug.Log(ballPushOrgin);
                        ballPushDir = new Vector3(_ballPushDir.x - ballPushOrgin.x, 0, 0);
                        pushed = true;
                        ballTrans.position = new Vector3(hit.point.x, 0.558f + ballRadius * 0.01f, 8.026f);
                        GetComponent<Rigidbody>().isKinematic = false;
                        ballTrans.GetComponent<Rigidbody>().AddForce((transform.forward + ballPushDir) * 35, ForceMode.Impulse);
                    }
                }
            }
        }
        else if (pushed)//推出去了
        {
            if (GameManage.Instacne.CameraTrans.position.z > -7f)
            {
                GameManage.Instacne.CameraTrans.position = transform.position - _tempPos;
            }
        }
    }
    /// <summary>
    /// 碰撞器检测
    /// </summary>
    /// <param name="collision"></param>
    private void OnCollisionEnter(Collision collision)
    {
        if (!Once)
        {
            //滚动声音播放
            AS.Stop();
            AS.loop = false;
            AS.clip = pushSource;
            AS.Play();
            Once = true;
        }
        if (collision.gameObject.layer != 8 && pushed)
        {
            //Debug.Log("球出界了！");
            isOutArea = true;
        }
    }
}

 最后是Main场景中的掌声：

对GameManage修改：

//------------------------------------------------------------------------------
// Copyright 2017 21世纪少年. All rights reserved.
// 
// Unity5.6.3f1 Editor make it
// BowlingHall_Project
//
// CreatTime: #10/7/2017#
// Author: Unity Guo
//------------------------------------------------------------------------------
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class GameManage : MonoBehaviour
{
    #region 单例

    private static GameManage _Instacne;
    /// <summary>
    /// 游戏管理单例
    /// </summary>
    public static GameManage Instacne
    {
        get
        {
            return _Instacne;
        }

    }
    private void Awake()
    {
        _Instacne = this;
    }
    #endregion


    #region 场景信息

    /// <summary>
    /// 墙壁
    /// </summary>
    public Transform roomWall;
    /// <summary>
    /// 推力范围
    /// </summary>
    public Transform pushArea;
    /// <summary>
    /// 保龄球瓶堆的父物体位置
    /// </summary>
    public Transform bowlsParentTrans;

    #endregion

    #region 游戏对象

    /// <summary>
    /// 保龄球瓶预制体
    /// </summary>
    public GameObject bowlsPrefabs;
    /// <summary>
    /// 保龄球瓶堆
    /// </summary>
    public GameObject bowls;
    /// <summary>
    /// 保龄球预制体
    /// </summary>
    public GameObject ballPrefab;
    /// <summary>
    /// 保龄球对象
    /// </summary>
    public GameObject ball;
    /// <summary>
    /// 保龄球上的控制器
    /// </summary>
    public BallController _BallController;
    /// <summary>
    /// 管理所有瓶子的数组
    /// </summary>
    public Bowl[] AllBowls;

    #endregion

    #region 时间管理
    /// <summary>
    /// 出界等待时间
    /// </summary>
    [SerializeField]
    private float outAreaWaitTime = 5f;

    private float _temp;
    /// <summary>
    /// 每球声明时间
    /// </summary>
    [SerializeField]
    private float BallLifeTime = 30f;
    /// <summary>
    /// 滚动时间
    /// </summary>
    private float _tempLife;

    #endregion

    #region 分数管理

    /// <summary>
    /// 每局分数块游戏对象
    /// </summary>
    public ScoreItem[] SocreItems;
    /// <summary>
    /// 每球的临时得分
    /// </summary>
    public int _tempScore;
    /// <summary>
    /// 所有总分
    /// </summary>
    public int AllScore;
    /// <summary>
    /// 所有分数
    /// </summary>
    public Text AllScoreText;
    #endregion


    /// <summary>
    /// 轮数
    /// </summary>
    public int indexItem;
    /// <summary>
    /// 每轮第N球
    /// </summary>
    public int _tempNumBall;
    /// <summary>
    /// 相机位置
    /// </summary>
    public Transform CameraTrans;
    /// <summary>
    /// 返回餐单按键
    /// </summary>
    public Button RenturnBtn;
    /// <summary>
    /// 游戏结束
    /// </summary>
    public bool IsOver;

    private void Start()
    {
        RenturnBtn.onClick.AddListener(ReturnMenu);
        indexItem = 0;
        _tempNumBall = 1;//第1球
        SetBall();
        SetBowls();
        //分数初始化
        foreach (var item in SocreItems)
        {
            item.Inits();//初始化
            item.ShowScore();
        }
    }
    private void Update()
    {
        if (ball != null)//游戏没有结束
        {

            if (_BallController.pushed)//球已经被推出去
            {
                CameraTrans.GetComponent<AudioSource>().Stop();
                _tempLife += Time.deltaTime;
                if (_tempLife > BallLifeTime && !_BallController.isOutArea)//一直没出届
                {
                    Debug.Log("此球分数：" + _tempScore);
                    _tempLife = 0;
                    DestroyImmediate(ball);
                    SetScore(_tempScore);
                    _tempScore = 0;//清零
                    SetBall();
                    SetBowls();
                }
                if (_BallController.isOutArea)//球出界
                {
                    _temp += Time.deltaTime;
                    if (_temp > outAreaWaitTime)//超过出界时间
                    {
                        Debug.Log("球出界！此球得分：" + _tempScore);
                        _tempLife = 0;
                        _temp = 0;//重新计时
                        DestroyImmediate(ball);
                        SetScore(_tempScore);
                        _tempScore = 0;//清零
                        SetBall();
                        SetBowls();
                    }
                }
            }


        }
    }
    /// <summary>
    /// 生成新球
    /// </summary>
    public void SetBall()
    {
        if (ball == null)
        {
            ball = Instantiate(ballPrefab) as GameObject;
            _BallController = ball.GetComponent<BallController>();
            _BallController.Inits();
        }
    }
    /// <summary>
    /// 传递分数
    /// </summary>
    /// <param name="_score">分数值</param>
    public void SetScore(int _score)
    {
        //indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
        if (indexItem < 9)//---------------------------------------------------前九轮
        {
            if (_tempNumBall == 1)//第一球
            {
                SocreItems[indexItem].SetScoreText(0, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score == 10)//分数为10
                {
                    Debug.LogWarning("Strike全中！");
                    CameraTrans.GetComponent<AudioSource>().Play();
                    SocreItems[indexItem].isStrike = true;//设置第一球
                    indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                    DestroyImmediate(bowls);//清空瓶子
                    _tempNumBall = 1;//开始新的一轮
                }
                else//不为10
                {
                    _tempNumBall = 2;//开始下一个球
                }
            }
            else if (_tempNumBall == 2)//第二球
            {
                SocreItems[indexItem].SetScoreText(1, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                if (_score + SocreItems[indexItem].Scores[0].Value == 10)//yi
                {
                    Debug.LogWarning("Spare补中！");
                    CameraTrans.GetComponent<AudioSource>().Play();
                    SocreItems[indexItem].isSpare = true;//设置第一球
                }
                indexItem++;//轮数自加，（indexItem-1）为每局分数块游戏对象SocreItems索引
                DestroyImmediate(bowls);//清空瓶子
                _tempNumBall = 1;//开始新的一轮

            }
        }
        else if (indexItem == 9)//--------------------------------------------第十轮
        {
            if (_tempNumBall == 1)//第一球
            {
                if (_score == 10)
                {
                    Debug.LogWarning("Strike全中！");
                    CameraTrans.GetComponent<AudioSource>().Play();
                    SocreItems[indexItem].isStrike = true;//设置第一球
                    DestroyImmediate(bowls);//清空瓶子
                }
                SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第一球
                SocreItems[indexItem].ShowScore();
                _tempNumBall = 2;//开始新的一轮
            }
            else if (_tempNumBall == 2)//第二球
            {
                if (!SocreItems[indexItem].isStrike)//不是全中
                {
                    if (SocreItems[indexItem].Scores[0].Value + _score == 10)//达成补中条件
                    {
                        Debug.LogWarning("Spare补中！");
                        CameraTrans.GetComponent<AudioSource>().Play();
                        SocreItems[indexItem].isSpare = true;//全中
                        DestroyImmediate(bowls);//清空瓶子
                        SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第二球分数
                        SocreItems[indexItem].ShowScore();
                        _tempNumBall = 3;//开始新的一轮,第3球
                    }
                    else
                    {
                        SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第二球分数
                        SocreItems[indexItem].ShowScore();
                        IsOver = true;
                    }
                }
                else//全中下一球
                {
                    DestroyImmediate(bowls);//清空瓶子
                    SocreItems[9].SetScoreText(_tempNumBall - 1, _score);//设置第二球分数
                    SocreItems[9].ShowScore();
                    _tempNumBall = 3;//开始新的一轮,第3球
                }
            }
            else if (_tempNumBall == 3)
            {
                DestroyImmediate(bowls);//清空瓶子
                SocreItems[indexItem].SetScoreText(_tempNumBall - 1, _score);//设置第一球分数
                SocreItems[indexItem].ShowScore();

                IsOver = true;
            }
        }
        AllScore = 0;
        foreach (var item in SocreItems)//加分
        {
            item.AddScore();
            AllScore += item._Score;
        }
        AllScoreText.text = AllScore.ToString();
    }

    /// <summary>
    /// 摆放瓶子
    /// </summary>
    public void SetBowls()
    {
        if (bowls == null)//没有瓶子
        {
            bowls = Instantiate(bowlsPrefabs, bowlsParentTrans) as GameObject;
            AllBowls = new Bowl[10];//10个瓶
            foreach (var item in bowls.GetComponentsInChildren<Bowl>())
            {
                AllBowls[item.Index] = item;//把加载的瓶子放进数组里
            }
        }
        else
        {
            foreach (var item in AllBowls)
            {
                if (item.GetScore)//没有倒下过显示他们
                {
                    item.gameObject.SetActive(!item.GetScore);
                }
            }
        }
    }
    /// <summary>
    /// 返回菜单
    /// </summary>
    public void ReturnMenu() {
        SceneManager.LoadScene("Start");
    }
}

 最后测试。。。。

就这样完了吗？并没有...现在基本功能已经实现，你可以继续扩展更多的功能。

 如果有问题可以给我留言,谢大佬们指点=￣ω￣=。