经典小游戏开发思路和算法之打砖块(3)

怼烎@ 2022-03-10 08:00 211阅读 0赞

很长时间没有更新了，今天终于抽出点时间写一下之前看过的一个小游戏案例，相关素材和工程我会放到我的资源下载里面。(共同学习进步，一直在路上从未停下脚步)

## 打砖块游戏规则： ##

玩家操作在屏幕底端的横板，通过反弹小球的方式，使小球击打并消除砖块，只需要打掉所有的砖块即可获的胜利。  
小球掉落横板下方即失败。

## 先来简单介绍一下打砖块的历史： ##

《Breakout》世界上第一款打砖块游戏，1976年由英宝格公司发行。游戏设计者是后来创立苹果电脑公司的史蒂夫·乔布斯与斯蒂夫·沃兹尼亚克两人，程序设计者Bread Stewart。  
《Gee Bee》日本Namco公司在1978年推出的该公司第一款街机游戏，合并了打砖块与弹珠台游戏的特色。  
快打砖块《Arkanoid》,日本泰托(Taito)公司在1986年推出的街机游戏，引入了电脑控制的敌机，还有后来打砖块游戏中常见的加强道具(Power up Item)等元素。

## 程序思路： ##

### 1.地图生成 ###

使用动态生成的方式，利用循环，通过循环遍历的方式生成新的砖块。  
如下：

for(x轴)
    {
        for(y轴)
       {
           生成砖块;
       }
    }

游戏需要设置砖块随机颜色以及砖块的排布(砖块随机组成各种设定好的图形)。外置一个储存地图的文件夹，内含地图的txt文档，将地图中方块排布转换为txt储存，由程序读取后循环遍历生成。  
外置几个编译好的txt文档，里面保存了地图数据，其中X表示空，R表示红色，B表示蓝色，G表示绿色，Y表示黄色。如下图：  
![在这里插入图片描述][20190310103209945.png]

### 2.砖块控制 ###

设置一个砖块类，定义Color(用于显示)和hits(作为可被撞击次数，即生命值)。

### 3.小球控制 ###

给小球一个力，使其获得一个初速度。小球接触横板后，将获得一个向上的力(ySpeed)，小球接触砖块时也将获得一个力使其反弹，但目前大多数平台都有物理引擎，所以我们可以使用其中的物理材质来实现反弹。  
(1).小球反弹方向的思路：  
小球与横板碰撞时的反弹方向，由于横板的x坐标为横板中心，所以我们只需要用球的x坐标减去横板的x坐标，即可判断小球是在横板的左边或右边与横板接触的，所以公式为：(ballPos.x-racketPos.x)/recketWidth。  
小球碰触横板不同位置将获取不同方向的反弹力(xSpeed).

float HitFacter
    {
      return(ballPos.x-racketPos.x)/racketWidth;
    }
    
    if(碰撞板)
    {
      小球的xSpeed=HitFacter；
    }

### 4.游戏流程图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODU1Mjkz_size_16_color_FFFFFF_t_70]

### 5.程序实现 ###

（素材包在我的资源里面名字为： Break Out 里面有完整的游戏案例和游戏所需要的一切素材）  
先看一下游戏实现之后的游戏截图 不同的颜色可撞击的次数也不同，颜色和次数可以自己设置

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODU1Mjkz_size_16_color_FFFFFF_t_70 1]  
下面直接来上代码，以及相关的讲解(关于素材的导入和场景的搭建(基础知识不做详解))  
(1).横板的控制、道具生效、挡板与道具的触发器(横板的控制只是左右移动并不超出左右边界即可)

public class RacketMove : MonoBehaviour {
    
        /// <summary>
        /// 挡板移动速度
        /// </summary>
        public float Racketmovespeed = 10f;
    
    	// Update is called once per frame
    	void Update () {
            //挡板左移
            if (Input.GetKey(KeyCode.LeftArrow))
            {
                //挡板左移不能超过屏幕左侧的边界
                if (transform.position.x>-5.2)
                {
                    transform.Translate(Vector3.left * Time.deltaTime * Racketmovespeed);
    
                }
                else
                {
                    return;
                }
            }//挡板右移
            else if (Input.GetKey(KeyCode.RightArrow))
            {
                //右边也不能超过边界
                if (transform.position.x<5.2)
                {
                    transform.Translate(Vector3.right*Time.deltaTime*Racketmovespeed);
                }
                else
                {
                    return;
                }
            }
    	}
    
        /// <summary>
        /// 道具生效
        /// </summary>
        /// <param name="name"></param>
        void performUpgrade(string name)
        {
            name = name.Remove(name.Length-21);
            float x;
            Ball ballController = GameObject.Find("ball").GetComponent<Ball>();
            switch (name)
            {
                case "ball_speed_up":
                    if (ballController.speed<27)
                    {
                       //当小球速度小于27，并且道具为ball_speed_up时，小球速度+3，以下类似
                        ballController.speed += 3;
                    }
                    break;
                case "ball_speed_down":
                    if (ballController.speed > 18)
                    {
                    //当小球速度小于27，并且道具为ball_speed_up时，小球速度+3，以下类似
                        ballController.speed -= 3;
                    }
                    break;
                 case "paddle_size_up":
                    x = this.gameObject.transform.localScale.x;
                    if (x < 8.0f)
                    {
                        this.gameObject.transform.localScale = new Vector3(x+=0.25f,this.gameObject.transform.localScale.y,1.0f);
                    }
                    break;
                case "paddle_size_down":
                    x = this.gameObject.transform.localScale.x;
                    if (x > 4.0f)
                    {
                        this.gameObject.transform.localScale = new Vector3(x -= 0.25f,this.gameObject.transform.localScale.y,1.0f);
                    }
                    break;
                case "paddle_speed_up":
                    Racketmovespeed += 3;
                    break;
                case "paddle_speed_down":
                    if (Racketmovespeed > 7)
                    {
                        Racketmovespeed-= 3;
                    }
                    break;
                default:
                    break;
            }
        }
    
        /// <summary>
        /// 挡板与道具的触发器
        /// </summary>
        /// <param name="collision"></param>
        private void OnTriggerEnter2D(Collider2D collision)
        {
            if (collision.gameObject.tag=="upgrade")
            {
                string name = collision.gameObject.GetComponent<Upgrad>().upgradeName;
                performUpgrade(name);
                Destroy(collision.gameObject);
            }
        }
    }

(2).小球控制  
小球运动控制的分析：

*  小球需要一个弹性且无能量损失的材质
 *  小球第一次发出需要一个向上且能使小球运动到画面最上方的初始作用力  
    （小球的材质的话我们直接用物理材质，然后调整一下拖入小球的物理材质框即可如下图：）  
    ![在这里插入图片描述][20190310120857765.png]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODU1Mjkz_size_16_color_FFFFFF_t_70 2]  
    小球的控制代码：(球与横板接触位置与反弹方向的公式、发球的碰撞触发器)

public class Ball : MonoBehaviour {
    
        public float speed = 20f;//小球的速度
        bool num = false;
    	
    	// Update is called once per frame
    	void Update () {
            //num控制小球是不是第一次离开横板   按任何键小球获得初始速度
            if (Input.anyKey&&!num)
            {
                GetComponent<Rigidbody2D>().velocity = Vector2.up * speed;//给小球初始速度
                num=true;
            }
    
            //小球掉落后重新加载场景
            if (transform.position.y<-8)
            {
                SceneManager.LoadScene("Break_Out");
            }
    	}
    
        /// <summary>
        /// 球与横板接触位置与反弹方向的公式
        /// </summary>
        /// <param name="ballPos">球的位置</param>
        /// <param name="racketPos">横板的位置</param>
        /// <param name="racketWidth">横板的宽度</param>
        /// <returns></returns>
        public float HitFactor(Vector2 ballPos,Vector2 racketPos,float racketWidth)
        {
            return (ballPos.x - racketPos.x) / racketWidth;
        }
    
        /// <summary>
        /// 发球的碰撞触发器
        /// </summary>
        /// <param name="collision"></param>
        private void OnCollisionEnter2D(Collision2D collision)
        {
            if (collision.gameObject.name=="racket"&&num)
            {
                float x = HitFactor(transform.position,collision.transform.position,collision.collider.bounds.size.x);//collider.bounds.size.x碰撞体横板的宽度
                Vector2 dir = new Vector2(x, 1).normalized;//向量归一化
                GetComponent<Rigidbody2D>().velocity = dir * speed;//改变力的方向
            }
        }

(3).砖块的生成及控制(直接上代码)

/// <summary>
    /// 保存砖块的颜色及生命值
    /// </summary>
    public class Block : MonoBehaviour {
    
        public string color;
        public int hits_required;
    }

生成地图

public class LeveLoader : MonoBehaviour {
    
        /// <summary>
        /// 砖块类
        /// </summary>
        public Block block;
    
        //public GameObject blocks;
    
        public int block_count = 0;
    
    	// Use this for initialization
    	void Start () {
            string level = GetRandomMapName();
            Debug.Log(level);
            LoadLevel(level);
    	}
    
        /// <summary>
        /// 随机获取地图名称
        /// </summary>
        public string GetRandomMapName()
        {
            int level = Random.Range(1,5);
            //通过地图名称读取文件夹里面的txt
            return "Assets/MyClassicGame/Break_Out/LevelsMap/level_" + level+".txt";
        }
    
        /// <summary>
        /// 载入地图
        /// </summary>
        public void LoadLevel(string levelName)
        {
            try
            {
                string line;
                StreamReader reader = new StreamReader(levelName,Encoding.Default);
                using (reader)
                {
                    float pos_x = -5f;//初始克隆方块位置
                    float pos_y = 5.8f;
                    line = reader.ReadLine();
                    while (line!=null)
                    {
                        char[] characters = line.ToCharArray();
                        for (int i = 0; i < characters.Length; i++)
                        {
                            if (characters[i]=='X')
                            {
                                pos_x += 0.87f;
                                continue;
                            }
                            Vector2 b_pos = new Vector2(pos_x, pos_y);
                            Block b = Instantiate(block, b_pos,Quaternion.identity);//实例化砖块
                            b.GetComponent<BoxCollider2D>().size = new Vector2(0.8f,0.4f);//方块大小
                            //给砖块上色
                            switch (characters[i])
                            {
                                case 'B':
                                    b.GetComponent<Block>().color = "blue";
                                    b.GetComponent<Block>().hits_required = 3;
                                    block_count++;
                                    break;
                                case 'G':
                                    b.GetComponent<Block>().color = "green";
                                    b.GetComponent<Block>().hits_required = 2;
                                    block_count++;
                                    break;
                                case 'P':
                                    b.GetComponent<Block>().color = "pink";
                                    b.GetComponent<Block>().hits_required = 1;
                                    block_count++;
                                    break;
                                case 'R':
                                    b.GetComponent<Block>().color = "red";
                                    b.GetComponent<Block>().hits_required = 5;
                                    block_count++;
                                    break;
                                case 'Y':
                                    b.GetComponent<Block>().color = "yellow";
                                    b.GetComponent<Block>().hits_required = 4;
                                    block_count++;
                                    break;
                                default:
                                    Destroy(b);
                                    break;
                            }
                            pos_x += 0.87f;//每块克隆方块之间的间隔
                        }
                        pos_x = -5.5f;
                        pos_y -= 0.45f;
                        line = reader.ReadLine();
                    }
                    reader.Close();
                }
            }
            catch (System.Exception e)
            {
    
                Debug.Log(e.Message);
            }
         }
        }

//控制砖块的贴图以及销毁
    public class BlockController : MonoBehaviour {
    
        public GameObject upgradePrefabs;
    
    	// Use this for initialization
    	void Start () {
            //获取颜色名字
            string spriteFileName = "sprites/block_"+GetComponent<Block>().color;
            //贴图
            this.GetComponent<SpriteRenderer>().sprite = Resources.Load<UnityEngine.Sprite>(spriteFileName);
    	}
    
        /// <summary>
        /// 球与砖块的碰撞检测
        /// </summary>
        /// <param name="collision"></param>
        private void OnCollisionEnter2D(Collision2D collision)
        {
            GameObject go = GameObject.Find("Main Camera");
            LeveLoader levelLoader = go.GetComponent<LeveLoader>();
            gameObject.GetComponent<Block>().hits_required -= 1;
    
            switch (gameObject.GetComponent<Block>().hits_required)
            {
                case 1:
                    this.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>("sprites/block_pink");
                    break;
                case 2:
                    this.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>("sprites/block_green");
                    break;
                case 3:
                    this.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>("sprites/block_blue");
                    break;
                case 4:
                    this.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>("sprites/block_yellow");
                    break;
                case 5:
                    this.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>("sprites/block_red");
                    break;
            }
    
            if (gameObject.GetComponent<Block>().hits_required==0)
            {
                Destroy(gameObject);
                levelLoader.block_count--; //总长度减一
    
                if (Random.value<0.10)//道具生成概率
                {
                    Instantiate(upgradePrefabs, new Vector3(collision.gameObject.transform.position.x,collision.gameObject.transform.position.y,0),Quaternion.identity);
                }
            }
        }
    }

(4).道具的控制(创建一个精灵数组来储存道具的贴图)

public class Upgrad : MonoBehaviour {
    
        public Sprite[] upgradeSprite;
        public string upgradeName = "";
    
        private void Start()
        {
            //随机选择图片
            Sprite icon = upgradeSprite[Random.Range(0,upgradeSprite.Length)];
            //与图片对应的道具名字
            upgradeName = icon.ToString();
            Debug.Log("道具名称："+upgradeName);
            //贴图
            this.gameObject.GetComponent<SpriteRenderer>().sprite = icon;
        }
    
        private void Update()
        {
            //道具位置刷新
            this.gameObject.transform.position = new Vector3(this.gameObject.transform.position.x,this.gameObject.transform.position.y-0.05f,0);
    
            //如果道具低于横板，则销毁
            if (gameObject.transform.position.y<=-8.0f)
            {
                Destroy(this.gameObject);
            }
        }
    }

好了这个就是这个游戏的全部代码以及相关思路了。  
一起加油！！！（思想的学习与交流才可以使一个人快速成长）

[20190310103209945.png]: /images/20220310/5922028a62224ebe9c40744c076850bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODU1Mjkz_size_16_color_FFFFFF_t_70]: /images/20220310/aad8fc2d9f264934a6f3af8f1bd89557.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODU1Mjkz_size_16_color_FFFFFF_t_70 1]: /images/20220310/93aa6d9834184226a939b0fa98fc9472.png
[20190310120857765.png]: /images/20220310/af7e996635254e3594716401b3d0a173.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODU1Mjkz_size_16_color_FFFFFF_t_70 2]: /images/20220310/b6ff652864684563bc4fc07785f60023.png