Unity3D作业六：打靶游戏_unity打靶

1：游戏要求：

1.1游戏内容要求：

• 靶对象为 5 环，按环计分；
• 箭对象，射中后要插在靶上
• 增强要求：射中后，箭对象产生颤抖效果，到下一次射击 或 1秒以后
• 游戏仅一轮，无限 trials；
• 增强要求：添加一个风向和强度标志，提高难度

1.2游戏编程要求

• 使用Adapter模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

2：游戏对象预制：

2.1：靶子Target：

靶子是由五个同心的圆柱体组成的预制体，每个圆柱体代表一个环，每个环的分值不一样。并且每个圆柱体都需要添加MeshCollider组件，并设置为IsTrigger,用来检测箭是否中靶。详细设置：

2.2：箭Arrow：

箭主要有两部分，箭身以及子对象箭头，设置标签为arrow详细设置如下图：

• 箭身的设置：
  
• 箭头的设置：
  

2.3： 弓bow：

弓同样由两部分组成，弓本身以及一个架在弓上的箭，所以需要添加一个箭的预制：

3：编程：

3.1 Adapter模式：

1：基类SSAction

箭的多种动作类的共同父类，使得可以统一管理箭的多种动作：

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

public class SSAction : ScriptableObject
{
    public bool enable = true;                      //是否正在进行此动作
    public bool destroy = false;                    //是否需要被销毁
    public GameObject gameobject;                   //动作对象
    public Transform transform;                     //动作对象的transform
    public ISSActionCallback callback;              //动作完成后的消息通知者

    protected SSAction() { }
    //子类可以使用下面这两个函数
    public virtual void Start()
    {
        throw new System.NotImplementedException();
    }
    public virtual void Update()
    {
        throw new System.NotImplementedException();
    }
    public virtual void FixedUpdate()
    {
        throw new System.NotImplementedException();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2：箭的射击动作 ArrowShootAction.cs

通过一个作为初始动力的冲量pulseForce和一个持续的风力windForce驱使箭飞行。在箭中靶或者脱靶，即飞行动作结束之后，回调箭的颤抖动作：

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

public class ArrowShootAction : SSAction
{
    private Vector3 pulseForce;  //射箭提供的冲量
    private Vector3 windForce;   //风力
    private ArrowShootAction(){}

    public static ArrowShootAction GetSSAction(Vector3 wind)
    {
        ArrowShootAction shootarrow = CreateInstance<ArrowShootAction>();
        shootarrow.pulseForce = new Vector3(0,0,25);
        shootarrow.windForce = wind;
        return shootarrow;
    }
    // Start is called before the first frame update
    public override void Start()
    {
        //摆脱跟随弓移动
        gameobject.transform.parent = null;
        gameobject.GetComponent<Rigidbody>().velocity = Vector3.zero;
        //添加初始的冲量
        gameobject.GetComponent<Rigidbody>().AddForce(pulseForce,ForceMode.Impulse);
        //关闭运动学控制
        gameobject.GetComponent<Rigidbody>().isKinematic = false;
    }

    // Update is called once per frame
    public  override void Update()
    {
        
    }

    public override void FixedUpdate(){
        //添加风力
        this.gameobject.GetComponent<Rigidbody>().AddForce(windForce,ForceMode.Force);
        //射击动作结束，即中靶或者脱靶，回调颤抖动作
        if(this.transform.position.z > 35 || this.gameobject.tag == "onTarget"  )
        {
            this.destroy = true;
            this.callback.SSActionEvent(this,1,this.gameobject);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

3：ArrowTrembleAction 箭的颤抖动作：

围绕箭的头部进行细微的运动，实现颤抖的效果，该动作在结束时也会调用回调函数，不过没有下一步的动作，所以回调的函数为空；

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

public class ArrowTrembleAction : SSAction
{
    float tremble_radius = 1.2f;//颤抖的程度
    float tremble_time = 1.0f; //颤抖的时间

    Vector3 arrow_pos;   //箭的原位置

    private ArrowTrembleAction(){}
    //放回一个颤抖的动作
    public static ArrowTrembleAction GetSSAction()
    {
        ArrowTrembleAction tremble_action = CreateInstance<ArrowTrembleAction>();
        return tremble_action;

    }

    // Start is called before the first frame update
    public override void Start()
    {
        //得到箭中靶时的位置
        arrow_pos = this.transform.position;
    }
    //实现箭的颤抖动作
    // Update is called once per frame
    public override  void Update()
    {   //更新时间，得到剩余的颤抖时间
        tremble_time -= Time.deltaTime;
        //需要继续颤抖
        if(tremble_time > 0){
            ///获取头部的位置
           Vector3 head_pos = this.transform.GetChild(0).position;
           //围绕箭头颤抖
           this.transform.RotateAround(head_pos,tremble_radius);  
        }
        else{
            //将箭返回一开始的位置
            transform.position = arrow_pos;
            //开始销毁动作
            this.destroy = true;
            //通过接口回调，调用新的动作，实际上没有新的动作，回调为空
            this.callback.SSActionEvent(this);
        }
    }

    public override void FixedUpdate()
    {
        
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

4：SSActionManage统一的动作管理接口：

该类维护着一个动作队列actions，在每次更新时，即Update()或者FixedUpdate()，都会添加新的动作，或者删除需要销毁的动作，并运行需要更新的动作；同时提供了一个添加新动作的方法RunAction和回调接口SSActionEvent;

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

public class SSActionManager : MonoBehaviour,ISSActionCallback
{
    private Dictionary<int,SSAction> actions = new Dictionary<int,SSAction>();  //执行动作的字典集
    //等待添加的动作
    private List<SSAction> waitingAdd = new List<SSAction>();
    //等待销毁的动作
    private List<int> waitingDelete = new List<int>();
    // Start is called before the first frame update
     

    // Update is called once per frame
    protected void Update()
    {
        //添加新增的动作
        for(int i = 0; i < waitingAdd.Count; ++i)
        {
            actions[waitingAdd[i].GetInstanceID()] = waitingAdd[i];
        }
        waitingAdd.Clear();
        //销毁需要删除的动作
        foreach (KeyValuePair<int,SSAction> kv in actions){
            SSAction t_ac = kv.Value;
            if(t_ac.destroy)
            {
                waitingDelete.Add(t_ac.GetInstanceID());

            }
            //动作不需要销毁则更新
            else if(t_ac.enable)
            {
                t_ac.Update();
            }
        }
        //销毁动作
        foreach (int key in waitingDelete){
            SSAction ac = actions[key];
            actions.Remove(key);
            DestroyObject(ac);
        }
        waitingDelete.Clear();
    }

    protected void FixedUpdate()
    {
                for(int i = 0; i < waitingAdd.Count; ++i)
        {
            actions[waitingAdd[i].GetInstanceID()] = waitingAdd[i];
        }
        waitingAdd.Clear();

        foreach (KeyValuePair<int,SSAction> kv in actions){
            SSAction t_ac = kv.Value;
            if(t_ac.destroy)
            {
                waitingDelete.Add(t_ac.GetInstanceID());

            }
            else if(t_ac.enable)
            {
                t_ac.FixedUpdate();
            }
        }

        foreach (int key in waitingDelete){
            SSAction ac = actions[key];
            actions.Remove(key);
            DestroyObject(ac);
        }
        waitingDelete.Clear();
    }
    //新增一个动作，运行该动作
    public void RunAction(GameObject gameobject, SSAction  action, ISSActionCallback manager)
    {
        action.gameobject = gameobject;
        action.transform = gameobject.transform;
        action.callback = manager;
        waitingAdd.Add(action);
        action.Start();

    }
    //回调新的动作类型
    public void SSActionEvent(SSAction source, int param = 0,GameObject arrow = null)
    {
        //执行完飞行动作，开始颤抖动作。
        if(param == 1)
        {
            ArrowTrembleAction tremble = ArrowTrembleAction.GetSSAction();
            RunAction(arrow,tremble,this);
        }
        else{
            
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

5:ArrowShootActionManager,提供一个接口用于执行箭的射击动作；

该类继承了SSActionManager,提供了一个方法ArrowShoot，这个方法调用父类的RunAction方法执行射击动作。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//
public class ArrowShootActionManager : SSActionManager
{
    //箭飞行的动作
    private ArrowShootAction shoot;                                
    public FirstSceneController scene_controller;              //当前场景的场景控制器
    
    protected void Start()
    {
        //设置firstscenecontroller的arrow——manager
        scene_controller = (FirstSceneController)SSDirector.GetInstance().CurrentScenceController;
        scene_controller.arrow_manager = this;
    }

    //箭飞行
    public void ArrowShoot(GameObject arrow,Vector3 wind)
    {
        //实例化一个飞行动作。
        shoot = ArrowShootAction.GetSSAction(wind);
        //调用SSActionmanager的方法运行动作。
        this.RunAction(arrow, shoot, this);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.2 SSDirector 导演类

提供一个单实例，用来实现界面的统一管理，此游戏只需要一个界面。

public class SSDirector : System.Object
{
    private static SSDirector _instance;                  //导演类的实例
    public ISceneController CurrentScenceController { get; set; }
    public static SSDirector GetInstance()
    {
        if (_instance == null)
        {
            _instance = new SSDirector();
        }
        return _instance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.3：Arrow Factory 工厂

用来管理箭的生产和回收，主要提供两个方法，GetArrow（）和RecycleArrow（）分别用来得到空闲的箭和回收重复利用使用过的箭：

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

public class ArrowFactory : MonoBehaviour
{
    //空闲队列
    private Queue<GameObject> FreeArrow = new Queue<GameObject>();
    //使用的箭的队列
    private List<GameObject> UsedArrow = new List<GameObject>();

   public FirstSceneController scenecontrolller;
   public GameObject arrow = null;


    public GameObject GetArrow(){
        if(FreeArrow.Count == 0){
            arrow = Instantiate(Resources.Load<GameObject>("Prefabs/arrow"));
        }
        else{
            arrow = FreeArrow.Dequeue();
            if(arrow.tag == "onTarget")//箭在靶子上
            {//使用动力学控制
                arrow.GetComponent<Rigidbody>().isKinematic = false;
                arrow.tag = "arrow";
                arrow.transform.GetChild(0).gameObject.SetActive(true);
            }
            arrow.gameObject.SetActive(true);
        }

        scenecontrolller = (FirstSceneController)SSDirector.GetInstance().CurrentScenceController;
        //得到弓箭上搭箭的位置                       
        Transform bow_mid = scenecontrolller.bow.transform.GetChild(0);
        //将箭的位置设置为弓中间的位置
        arrow.transform.position = bow_mid.transform.position;
        //箭随弓的位置变化
        arrow.transform.parent = scenecontrolller.bow.transform;
        UsedArrow.Add(arrow);
        return arrow;

    }


    public void RecycleArrow(GameObject arrow)
    {
        for(int i = 0 ; i < UsedArrow.Count; ++i)
        {
            if(arrow.GetInstanceID() == UsedArrow[i].gameObject.GetInstanceID())///
            {
                //UsedArrow[i].gameObject.SetActive(false);
                FreeArrow.Enqueue(UsedArrow[i]);
                UsedArrow.RemoveAt(i);
                break;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

3.4 相机脚本：

1：CameraFlow实现主相机跟随：

将相机的位置与弓的位置之间维持固定的位移偏差offset，即随着弓移动：

using UnityEngine;
using System.Collections;

public class CameraFlow : MonoBehaviour
{
    public GameObject bow;               //跟随的物体
    public float smothing = 5f;          //相机跟随的速度
    Vector3 offset;                      //相机与物体相对偏移位置

    void Start()
    {
        //设置相机与弓箭的位移差
        offset = new Vector3(2,0,-6);
    }

    void FixedUpdate()
    {
        //相机的目标位置
        Vector3 target = bow.transform.position + offset;
        //摄像机自身位置到目标位置平滑过渡
        transform.position = Vector3.Lerp(transform.position, target, smothing * Time.deltaTime);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2:SecondeCamera:副相机脚本

在小窗口更加详细的展示箭的中靶位置和箭的颤抖动作，设置的展示时间为每次射击后的三秒钟：

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


public class SecondCamera : MonoBehaviour
{
    public float show_time = 3f;
    public bool show = false;

    void Update(){
        if(show == true){
            show_time -= Time.deltaTime;
            //展示时间超过3秒，停止展示
            if(show_time < 0){
                show = false;
                this.gameObject.SetActive(false);
            }
        }
    }
    //展示服相机
    public void ShowCamera()
    {
        show = true;
        this.gameObject.SetActive(true);
        show_time = 3f;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3.5 RingController 环的脚本：

主要有一个成员变量RingScore用来标记当前环的分值，需要在Inspector窗口设置相应的分值；还有一个触发器检测，用来检查是否有箭击中该靶。如果有箭中靶，需要更改标签，以便调用相应的动作：

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

public class RingController : MonoBehaviour
{
    //当前环的分值
    public  int RingScore = 0;

    public ISceneController scene;
    public ScoreRecorder sc_recorder;
    // Start is called before the first frame update
    void Start()
    {
        scene = SSDirector.GetInstance().CurrentScenceController as FirstSceneController;
        sc_recorder = Singleton<ScoreRecorder>.Instance;
    }

    // Update is called once per frame
    void Update()
    {
        
    }
   //碰撞检测，如果箭击中该环，就响应。
    void OnTriggerEnter(Collider arrow_head){
        //得到箭身
        Transform  arrow = arrow_head.gameObject.transform.parent;
        if(arrow == null)
        {
            return ;
        }
        //有箭中靶
        if(arrow.tag == "arrow"){
            //将箭的速度设为0
            arrow.GetComponent<Rigidbody>().velocity = new Vector3(0,0,0);
            //使用运动学运动控制
            arrow.GetComponent<Rigidbody>().isKinematic = true;
            //计分
            sc_recorder.RecordScore(RingScore);
            //将箭头设置为消失，
            arrow_head.gameObject.SetActive(false);/
            //标记箭为中靶
            arrow.tag = "onTarget";
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

3.6 Singleton 单实例：

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

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    protected static T instance;
    public static T Instance
    {
        get
        {
            if (instance == null) 
            {
                instance = (T)FindObjectOfType(typeof(T));
                if (instance == null)
                {
                    Debug.LogError("An instance of " + typeof(T)
                        + " is needed in the scene, but there is none.");
                }
            }
            return instance;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3.7 Interface接口：

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

public interface ISceneController{
    void LoadResources();
}

//箭的飞行和颤抖动作的回调接口
public interface ISSActionCallback
{
    void SSActionEvent(SSAction source,int param = 0, GameObject arrow = null);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.8 玩家交互界面：

显示相应的信息，以及响应玩家的动作，如点击开始游戏的按钮，和通过方向键控制弓的移动，点击空格箭发射。

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

public class UserGUI : MonoBehaviour
{
    //private IUserAction action;
    private FirstSceneController action;
    GUIStyle tip_style = new GUIStyle();
    GUIStyle wind_style = new GUIStyle();
    GUIStyle button_style = new GUIStyle();
    GUIStyle state_style = new GUIStyle();
    private int game_state = 0; //1-》游戏结束   0->游戏正在进行
    // Start is called before the first frame update
    void Start()
    {
       
       action = this.transform.gameObject.GetComponent<FirstSceneController>();
        tip_style.fontSize = 16;
        tip_style.normal.textColor = new Color(1,1,1,1);

        wind_style.normal.textColor = new Color(1,0.8f,0.8f,1);
        wind_style.fontSize = 16;

        button_style.normal.textColor = new Color(1,0.5f,0.7f,1);
        button_style.fontSize = 20;

        state_style.normal.textColor = new Color(0.9f,0.7f,0.5f,1);
        state_style.fontSize = 30;

        game_state = 0;//游戏状态 0->未开始  1-》开始
    }

    // Update is called once per frame
    //获取方向键的偏移量并移动弓
    void Update()
    {
        if(game_state == 1)
        {   
            //点击空格键射击
            if(Input.GetKeyDown(KeyCode.Space))
            {
                action.ShootArrow();
            }
            //获取方向键的位移
            float transY = Input.GetAxis("Vertical");
            float transX = Input.GetAxis("Horizontal");
             //移动弓相应的位移
            action.MoveBow(transX,transY); //
        }
    }
    //
    private void OnGUI()
    {//游戏已经开始
            if(game_state == 1)
            {   //游戏正在进行
                if(action.GetGameState() == 1) //
                {
                    //显示各种信息
                    GUI.Label(new Rect(20,10,150,50),"Score: ",button_style);
                    GUI.Label(new Rect(100,10,100,50),action.GetScore().ToString(),state_style);

                    GUI.Label(new Rect(200,10,100,50),"wind: ",wind_style);
                    Vector3 wind = action.GetWind();
                    string wind_data = "(" + wind.x +"," + wind.y + ",0)";
                    GUI.Label(new Rect(250,10,100,50),wind_data,wind_style);

                    
                    GUI.Label(new Rect(20,50,150,50),"ArrowNum: ",button_style);
                    GUI.Label(new Rect(120,50,100,50),action.GetArrowNum().ToString(),button_style);
                    //重新开始的按钮
                    if (GUI.Button(new Rect(80,100, 100, 50), "重新开始"))
                        {
                            action.Restart();
                        }
                }

                else{
                    GUI.Label(new Rect(Screen.width / 2 - 50, Screen.width / 2 - 250, 100, 100), "游戏结束", button_style);
                }
        }
        //游戏未开始，检测开始按键
        else{
                GUI.Label(new Rect(Screen.width / 2 - 150, Screen.width / 2 - 370, 100, 100), "Bowman", wind_style);
                //开始按键如果按下，游戏开始
                if (GUI.Button(new Rect(Screen.width / 2 - 50, Screen.width / 2 - 150, 100, 50), "游戏开始"))
                {
                    game_state = 1;
                    action.BeginGame();
                }
                GUI.Label(new Rect(Screen.width / 2 - 100, Screen.width / 2 - 320, 400, 100), "使用方向键控制弓箭移动，点击空格键射箭", wind_style);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

3.9 FirstSceneController 界面管理：

获取所需要的资源，响应玩家交互类传过来的动作，更新风向，分数等信息，调用箭的动作等等。

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

public class FirstSceneController : MonoBehaviour,ISceneController
{
    //箭的动作管理者
    public ArrowShootActionManager arrow_manager;
    //箭的工厂
    public ArrowFactory factory;
    //副相机
    public Camera second_camera;
    //主相机
    public Camera main_camera;
    //记录分数
    public ScoreRecorder recorder;
    //弓
    public GameObject bow;
    //靶
    public GameObject target;
    //风
    public Vector3 wind;
    //箭
    public GameObject arrow;

    private  int arrow_num = 0;    //射出的箭数
    //箭的队列
    private List<GameObject> arrows = new List<GameObject>();
 
    private int gameState = 0; //0-游戏未开始，1-》游戏进行
    //加载箭和靶子
    public void LoadResources()
    {
        bow = Instantiate(Resources.Load("Prefabs/bow",typeof(GameObject))) as GameObject;
        target = Instantiate(Resources.Load("Prefabs/target",typeof(GameObject))) as GameObject;
    }
    //进行资源加载
    // Start is called before the first frame update
    void Start()
    {
        SSDirector director = SSDirector.GetInstance();
        factory = Singleton<ArrowFactory>.Instance;
        recorder = Singleton<ScoreRecorder>.Instance;
        director.CurrentScenceController = (ISceneController)this;
        arrow_manager = this.gameObject.AddComponent<ArrowShootActionManager>() as ArrowShootActionManager;
        LoadResources();
        main_camera.GetComponent<CameraFlow>().bow = bow;
        float windx = Random.Range(-2,2);
        float windy = Random.Range(-2,2);
        wind = new Vector3(windx,windy,0);
    }

    // Update is called once per frame
    void Update()
    {
        if(gameState == 1)
        {
            for(int i = 0; i < arrows.Count; ++i)
            {   //当前界面如果箭飞出靶外或者数量大于3则回收
                GameObject t_arrow = arrows[i];
                if(t_arrow.transform.position.z > 35 || arrows.Count > 3)
                {
                    factory.RecycleArrow(t_arrow);
                    arrows.RemoveAt(i);
                }
            }
        }
    }

    //通过方向键移动弓
    public void MoveBow(float transX, float transY)
    {   //限制弓的位置在一定范围内，x,y的绝对值小于5，z为-5；
        if(gameState == 1)
        {
              bow.transform.position = new Vector3(bow.transform.position.x,bow.transform.position.y,-5);
            if(bow.transform.position.x > 5)
            {
                bow.transform.position = new Vector3(5,bow.transform.position.y,bow.transform.position.z);
                return;
            }
            if(bow.transform.position.x < -5)
            {
                bow.transform.position = new Vector3(-5,bow.transform.position.y,bow.transform.position.z);
                return;
            }
            if(bow.transform.position.y > 5)
            {
                bow.transform.position = new Vector3(bow.transform.position.x,5,bow.transform.position.z);
                return;
            }
            if(bow.transform.position.y < -5)
            {
                bow.transform.position = new Vector3(bow.transform.position.x,-5,bow.transform.position.z);
                return;
            }
            //移动特定的距离
            bow.transform.Translate(new Vector3(0,transY,-transX)*Time.deltaTime);
        }
    }
    //射箭
    public void ShootArrow()
    {
        if(gameState == 1)
        {   //从工厂得到箭
            arrow = factory.GetArrow();
            arrows.Add(arrow);
            //通过管理类发射动作
            arrow_manager.ArrowShoot(arrow,wind);
            //开启副相机
            second_camera.GetComponent<SecondCamera>().ShowCamera();

        arrow_num += 1;
            //每次射击后风向改变；
        float windx = Random.Range(-2,2);
        float windy = Random.Range(-2,2);
        wind = new Vector3(windx,windy,0);
        }
    }
    //返回当前分数
    public int GetScore()
    {
        return recorder.score;
    }
    //得到风向
    public Vector3 GetWind()
    {
        return wind;
    }
    //得到射出的箭的数量
    public int GetArrowNum()
    {
        return arrow_num;
    }
    //重新开始游戏
    public void Restart()
    {
        arrow_num = 0;
        recorder.score = 0;
        for(int i = 0; i < arrows.Count; ++i){
            factory.RecycleArrow(arrows[i]);
        }
        arrows.Clear();
    }
    //开始游戏
    public void BeginGame()
    {
        gameState = 1;
    }
    //得到游戏的状态
    public int GetGameState()
    {
        return gameState;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

4：运行游戏：

4.1： 相机

需要添加一个新的相机作为副相机，需要设置副相机Viewport Rect属性，设置为小窗口显示：并添加脚本SecondCamera,同时主相机也需要添加脚本CameraFlow：

4.2 GameObject

创建一个空对象，并添加和设置相应脚本：

4.3： Target：

每个环都要添加RingController，并设置RingScore；

5： 游戏展示：

• 一共有五环，分数分别为1，2，3，4，5；
• 方向键移动弓的位置；
• 空格箭发射

6：项目地址：

项目gitee地址

点击Scenes/BowAndArrow可运行项目；