devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity开发笔记（五）—— 制作第四个小游戏《坦克大战》_unity开发弹幕互动游戏

作者：盐析白兔 | 2024-02-19 19:51:49

赞

踩

unity开发弹幕互动游戏

目录

使用VS传统方法制作

使用Unity制作

使用VS传统方法制作

写在前面的话

C#可以干什么？

  • 桌面应用开发（用的少，现在市面上的桌面应用大部分是C++开发的）
  • Unity游戏开发
  • Web开发（用的少，现在市面上的网站是Java/PHP开发的）

开发工具：Unity、VS

注意：杀毒软件可能会把开发完成阶段生成的exe文件误当成病毒删除，所以使用时注意关闭

一、准备

 进入项目后可以看到Form1.cs的设计模型框 

鼠标右键选择查看代码，可查看Form1.cs的具体代码 

选择视图->工具箱，在工具箱中有一些系统自带组件鼠标拖动到Form1.cs进行UI布局的设计

控制窗体显示的位置 

居中显示

自定义位置显示 

 查看窗体事件有哪些

我们找到Paint（这个事件是用于更新画布的），然后在其后面的空格处双击，然后我们就会得到一个Form1_Paint方法

 

下面我们在此方法中编写代码去画一条线段

注意这里的坐标原点是表头以下部分的左上角 

 查看本机有哪些字体？新建一个txt文件打开，然后找到字体即可查看

 

绘制文字 

绘制图片，双击打开Resources文件，选择图像，选择添加现有文件，选择导入即可

 

我们可以在Resources类下发现有自动生成的代码

同理，添加音频

 

编写代码 

 绘制图片成功

 

控制代码收缩，使用region和endregion 

也可用Bitmap来获取图片对象且使用它可以对颜色进行透明处理

二、正式开始

1.创建画布窗口

创建窗体应用项目，设置窗口居中显示，设置标题（长宽均为15*30像素，为了对此取奇数）和游戏标题

新建一个线程 

新建一个类（项目右键添加->类）

创建Start和Update方法，Start方法用于游戏启动时的初始化，Update用于游戏每帧画面的更新逻辑操作 

为了优化性能，限制1s执行60次update方法

我们在调试时可以发现，当关闭窗口后主线程没有关闭，这是因为子线程没有关闭的情况下子线程是不会关闭的，我们添加一个FormClosed事件（方法见一）

修改Thread作用域，然后在FormClosed方法中调用中断线程的方法

创建画布并赋值 

将画布置为黑色 (为什么要把置为黑色代码放到每一帧里面重复执行？我直接执行一次不就好了吗？答案是：因为我们在游戏中还有动态的坦克，如果只执行一次则在创建坦克时会有重复)

 

2.绘制地图

创建GameObject类

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace TankWar
  8. {
  9.     class GameObject
  10.     {
  11.         public int X { get; set; }
  12.         public int Y { get; set; }
  13.  
  14.         //上述等价于
  15.         //public int y;
  16.         //public int Y {
  17.         //    get {
  18.         //        return y;
  19.         //    }
  20.         //    set {
  21.         //        value = y;
  22.         //    }
  23.         //}
  24.     }
  25. }

 创建NotMovingThing类，继承GameObject，新建Image对象

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace TankWar
  9. {
  10.     class NotMoveThing:GameObject
  11.     {
  12.         public Image img { get; set; }
  13.     }
  14. }

 创建MoveThing类

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace TankWar
  9. {
  10.     enum Direction{ 
  11.         UP,
  12.         DOWN,
  13.         LEFT,
  14.         RIGHT
  15.     }
  16.     class MoveThing:GameObject
  17.     {
  18.         public Bitmap BitmapUp { get; set; }
  19.         public Bitmap BitmapDown { get; set; }
  20.         public Bitmap BitmapLeft { get; set; }
  21.         public Bitmap BitmapRight { get; set; }
  22.         public int Speed { get; set; }
  23.         public Direction direction { get; set; }
  24.     }
  25. }

创建MyTank、EnemyTank、Bullet，分别继承MoveThing

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace TankWar
  8. {
  9.     class MyTank:MoveThing
  10.     {
  11.     }
  12. }
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace TankWar
  8. {
  9.     class EnemyTank:MoveThing
  10.     {
  11.     }
  12. }
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace TankWar
  8. {
  9.     class Bullet:MoveThing
  10.     {
  11.     }
  12. }

为GameObject添加抽象方法以获取图片对象和在画布上画图片的公共方法 

子类实现抽象方法，红线部分按下alt+enter选择实现抽象类，就会自动补充好实现方法，然后根据自己的逻辑需要修改即可 

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace TankWar
  9. {
  10.     class NotMoveThing:GameObject
  11.     {
  12.         public Image img { get; set; }
  13.  
  14.         protected override Image GetImage()
  15.         {
  16.             return img;
  17.         }
  18.     }
  19. }
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace TankWar
  9. {
  10.     enum Direction{ 
  11.         UP,
  12.         DOWN,
  13.         LEFT,
  14.         RIGHT
  15.     }
  16.     class MoveThing:GameObject
  17.     {
  18.         public Bitmap BitmapUp { get; set; }
  19.         public Bitmap BitmapDown { get; set; }
  20.         public Bitmap BitmapLeft { get; set; }
  21.         public Bitmap BitmapRight { get; set; }
  22.         public int Speed { get; set; }
  23.         public Direction direction { get; set; }
  24.  
  25.         protected override Image GetImage()
  26.         {
  27.             switch (direction) {
  28.                 case Direction.UP:
  29.                     return BitmapUp;
  30.                 case Direction.DOWN:
  31.                     return BitmapDown;
  32.                 case Direction.LEFT:
  33.                     return BitmapLeft;
  34.                 case Direction.RIGHT:
  35.                     return BitmapRight;
  36.                 default:
  37.                     return BitmapUp;
  38.             }
  39.         }
  40.     }
  41. }

将黑底图片设为透明

绘制墙，导入图片和音频资源（同上），创建GameObjectManager

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using TankWar.Properties;
  7.  
  8. namespace TankWar
  9. {
  10.     class GamebjectManager
  11.     {
  12.         private static List<NotMoveThing> wallList = new List<NotMoveThing>();//保存所有墙对象
  13.  
  14.         public static void DrawMap() {
  15.             foreach (NotMoveThing  wall in wallList) {
  16.                 wall.DrawSelf();//绘制墙
  17.             }
  18.         }
  19.         public static void CreateMap() {
  20.             CreateWall(1, 1, 5,wallList);//创建墙对象
  21.         }
  22.  
  23.         /**
  24.          * x,y代表一个30*30的方格的位置，如第一格是0，0，我们在绘画时从1，1位置开始画
  25.          * count代表要创建的强对象个数
  26.          */
  27.         private static void CreateWall(int x,int y,int count,List<NotMoveThing> wallList) {
  28.             int xPosition = x * 30;
  29.             int yPosition = y * 30;
  30.             for (int i=yPosition;i<yPosition+count*30; i+=15) {
  31.                 NotMoveThing wall1 = new NotMoveThing(xPosition,i,Resources.wall);
  32.                 NotMoveThing wall2 = new NotMoveThing(xPosition+15, i, Resources.wall);
  33.                 wallList.Add(wall1);
  34.                 wallList.Add(wall2);
  35.             }
  36.         }
  37.     }
  38. }

新增NotMoveThing构造f方法

  1. ​
  2. 新增NotMoveThing构造方法
  3.  
  4. using System;
  5. using System.Collections.Generic;
  6. using System.Drawing;
  7. using System.Linq;
  8. using System.Text;
  9. using System.Threading.Tasks;
  10.  
  11. namespace TankWar
  12. {
  13.     class NotMoveThing:GameObject
  14.     {
  15.         public Image img { get; set; }
  16.  
  17.         protected override Image GetImage()
  18.         {
  19.             return img;
  20.         }
  21.  
  22.         public NotMoveThing(int x,int y,Image img) {
  23.             this.X = x;
  24.             this.Y = y;
  25.             this.img = img;
  26.         }
  27.     }
  28. }

在GameFrameWork中调用

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace TankWar
  9. {
  10.     class GameFramework
  11.     {
  12.         public static Graphics g;
  13.         public static void Start() {
  14.             GamebjectManager.CreateMap();
  15.         }
  16.  
  17.         public static void Update() {
  18.             GamebjectManager.DrawMap();
  19.         }
  20.     }
  21. }

效果如下，但是会出现闪烁问题（这是因为每一帧都需要重新绘制） 

 为了解决闪烁问题，我们可以采用把所有的图像绘制在一张图片上，然后再把图片绘制到画布上

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading;
  9. using System.Threading.Tasks;
  10. using System.Windows.Forms;
  11.  
  12. namespace TankWar
  13. {
  14.     public partial class Form1 : Form
  15.     {
  16.         private Thread thread;
  17.         private static Graphics windowG;//窗口画布对象
  18.         private static Bitmap tempBmp;//临时图片对象
  19.  
  20.         public Form1()
  21.         {
  22.             InitializeComponent();
  23.             this.StartPosition = FormStartPosition.CenterScreen;//使窗口在屏幕居中显示
  24.  
  25.             windowG = this.CreateGraphics();//创建窗体画布
  26.  
  27.             tempBmp = new Bitmap(450,450);//创建临时图片
  28.             Graphics bmpG = Graphics.FromImage(tempBmp);//根据图片对象创建临时画布对象
  29.             GameFramework.g = bmpG;//赋值，以便在GameFramework中拿到此对象
  30.  
  31.  
  32.             thread = new Thread(new ThreadStart(GameMainThread));
  33.             thread.Start();
  34.         }
  35.  
  36.         private static void GameMainThread() {
  37.             GameFramework.Start();
  38.             int sleepTime = 1000 / 60; //值为：1/60s
  39.             while (true)
  40.             {
  41.                 GameFramework.g.Clear(Color.Black);//将画布内容清空，并置为黑色
  42.                 GameFramework.Update();//画画
  43.                 windowG.DrawImage(tempBmp, 0, 0);
  44.                 Thread.Sleep(sleepTime);//每执行一次休息一段时间，保证1s执行60次
  45.             }
  46.         }
  47.  
  48.         private void Form1_FormClosed(object sender, FormClosedEventArgs e)
  49.         {
  50.             thread.Abort();
  51.         }
  52.     }
  53. }

这样图像就不再闪动了 

继续创建其他墙，并添加图片参数

继续添加墙和boss，最终代码和最终效果

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using TankWar.Properties;
  8.  
  9. namespace TankWar
  10. {
  11.     class GamebjectManager
  12.     {
  13.         private static List<NotMoveThing> wallList = new List<NotMoveThing>();//保存所有普通墙对象
  14.         private static List<NotMoveThing> steelList = new List<NotMoveThing>();//保存所有钢铁墙对象
  15.         private static NotMoveThing boss;//保存boss对象
  16.         public static void DrawMap() {
  17.             foreach (NotMoveThing  wall in wallList) {
  18.                 wall.DrawSelf();//绘制墙
  19.             }
  20.             foreach (NotMoveThing wall in steelList) {
  21.                 wall.DrawSelf();//绘制墙
  22.             }
  23.             boss.DrawSelf();
  24.         }
  25.         public static void CreateMap() {
  26.             CreateWall(1, 1, 5,Resources.wall,wallList);//创建墙对象
  27.             CreateWall(3, 1, 5, Resources.wall, wallList);//创建墙对象
  28.             CreateWall(5, 1, 4, Resources.wall, wallList);//创建墙对象
  29.             CreateWall(7, 1, 3, Resources.wall, wallList);//创建墙对象
  30.             CreateWall(9, 1, 4, Resources.wall, wallList);//创建墙对象
  31.             CreateWall(11, 1, 5, Resources.wall, wallList);//创建墙对象
  32.             CreateWall(13, 1, 5, Resources.wall, wallList);//创建墙对象
  33.  
  34.             CreateWall(7, 5, 1, Resources.steel, steelList);//创建钢铁墙对象
  35.             CreateWall(0, 7, 1, Resources.steel, steelList);//创建钢铁墙对象
  36.             CreateWall(14, 7, 1, Resources.steel, steelList);//创建钢铁墙对象
  37.  
  38.             CreateWall(2, 7, 1, Resources.wall, wallList);
  39.             CreateWall(3, 7, 1, Resources.wall, wallList);
  40.             CreateWall(4, 7, 1, Resources.wall, wallList);
  41.             CreateWall(6, 7, 1, Resources.wall, wallList);
  42.             CreateWall(7, 6, 2, Resources.wall, wallList);
  43.             CreateWall(8, 7, 1, Resources.wall, wallList);
  44.             CreateWall(10, 7, 1, Resources.wall, wallList);
  45.             CreateWall(11, 7, 1, Resources.wall, wallList);
  46.             CreateWall(12, 7, 1, Resources.wall, wallList);
  47.  
  48.             CreateWall(1, 9, 5, Resources.wall, wallList);//创建墙对象
  49.             CreateWall(3, 9, 5, Resources.wall, wallList);//创建墙对象
  50.             CreateWall(5, 9, 3, Resources.wall, wallList);//创建墙对象
  51.             CreateWall(6, 10, 1, Resources.wall, wallList);//创建墙对象
  52.             CreateWall(7, 10, 1, Resources.wall, wallList);//创建墙对象
  53.             CreateWall(8, 10, 1, Resources.wall, wallList);//创建墙对象
  54.             CreateWall(9, 9, 3, Resources.wall, wallList);//创建墙对象
  55.  
  56.             CreateWall(11, 9, 5, Resources.wall, wallList);//创建墙对象
  57.             CreateWall(13, 9, 5, Resources.wall, wallList);//创建墙对象
  58.  
  59.             CreateWall(6, 13, 2, Resources.wall, wallList);//创建墙对象
  60.             CreateWall(7, 13, 1, Resources.wall, wallList);//创建墙对象
  61.             CreateWall(8, 13, 2, Resources.wall, wallList);//创建墙对象
  62.  
  63.             CreateBoss(7, 14,Resources.Boss);
  64.         }
  65.  
  66.         /**
  67.          * x,y代表一个30*30的方格的位置，如第一格是0，0，我们在绘画时从1，1位置开始画
  68.          * count代表要创建的强对象个数
  69.          */
  70.         private static void CreateWall(int x,int y,int count,Image img,List<NotMoveThing> wallList) {
  71.             int xPosition = x * 30;
  72.             int yPosition = y * 30;
  73.             for (int i=yPosition;i<yPosition+count*30; i+=15) {//例如从30到180(150+30),需执行10次
  74.                 NotMoveThing wall1 = new NotMoveThing(xPosition,i,img);
  75.                 NotMoveThing wall2 = new NotMoveThing(xPosition+15, i, img);
  76.                 wallList.Add(wall1);
  77.                 wallList.Add(wall2);
  78.             }
  79.         }
  80.  
  81.         private static void CreateBoss(int x,int y,Image img) {
  82.             int xPosition = x * 30;
  83.             int yPosition = y * 30;
  84.             boss = new NotMoveThing(xPosition, yPosition,img);
  85.         }
  86.     }
  87. }

修改窗体属性，使其不能用鼠标拖动改变窗体大小，但可以最大化和最小化

3.绘制主角（即自己的坦克）

GameObjectManager类新增如下两个方法，并在GameFramework中添加调用

 添加对应的构造方法

最终效果图：

4.控制坦克的移动

添加键盘监听事件函数(同上，再Form的属性->事件下找到KeyDown和KeyUp)

调用鼠标按下和起来的方法

这样控制坦克移动随可以，但会有一个一开始的卡顿（按下后移动一下然后停顿一s再往前走）

因此我们这样做，定义一个isMoving变量，当键盘按下后设置为true，当键盘起来时设置为false。然后根据isMoving来控制移动

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Windows.Forms;
  7. using TankWar.Properties;
  8.  
  9. namespace TankWar
  10. {
  11.     class MyTank:MoveThing
  12.     {
  13.         public bool IsMoving { get; set; }
  14.         public MyTank(int x,int y,int speed) {
  15.             this.IsMoving = false;
  16.             this.X = x;
  17.             this.Y = y;
  18.             this.Speed = speed;
  19.             this.direction = Direction.UP;
  20.             BitmapDown = Resources.MyTankDown;
  21.             BitmapUp = Resources.MyTankUp;
  22.             BitmapRight = Resources.MyTankRight;
  23.             BitmapLeft = Resources.MyTankLeft;
  24.         }
  25.  
  26.         public void KeyDown(KeyEventArgs args) {
  27.             switch (args.KeyCode) {
  28.                 case Keys.W:
  29.                     direction = Direction.UP;
  30.                     IsMoving = true;
  31.                     break;
  32.                 case Keys.S:
  33.                     direction = Direction.DOWN;
  34.                     IsMoving = true;
  35.                     break;
  36.                 case Keys.A:
  37.                     direction = Direction.LEFT;
  38.                     IsMoving = true;
  39.                     break;
  40.                 case Keys.D:
  41.                     direction = Direction.RIGHT;
  42.                     IsMoving = true;
  43.                     break;
  44.             }
  45.         }
  46.  
  47.         public void KeyUp(KeyEventArgs args) {
  48.             switch (args.KeyCode)
  49.             {
  50.                 case Keys.W:
  51.                     IsMoving = false;
  52.                     break;
  53.                 case Keys.S:
  54.                     IsMoving = false;
  55.                     break;
  56.                 case Keys.A:
  57.                     IsMoving = false;
  58.                     break;
  59.                 case Keys.D:
  60.                     IsMoving = false;
  61.                     break;
  62.             }
  63.         }
  64.  
  65.         private void Move() {
  66.             if (IsMoving==false) {
  67.                 return;
  68.             }
  69.             switch (direction) {
  70.                 case Direction.UP:
  71.                     Y -= Speed;
  72.                     break;
  73.                 case Direction.DOWN:
  74.                     Y += Speed;
  75.                     break;
  76.                 case Direction.LEFT:
  77.                     X -= Speed;
  78.                     break;
  79.                 case Direction.RIGHT:
  80.                     X += Speed;
  81.                     break;
  82.             }
  83.         } 
  84.  
  85.         public override void Update()
  86.         {
  87.             Move();
  88.             base.Update();
  89.         }
  90.     }
  91. }

现在我们的坦克可以移动了，但是会穿过墙体和外边界 

添加墙体检测，在MoveCheck方法添加墙体检测

 处理资源冲突异常：

在MoveThing中重写此方法 

5.添加敌人坦克

添加EnemyTank生成方法

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using System.Windows.Forms;
  8. using TankWar.Properties;
  9.  
  10. namespace TankWar
  11. {
  12.     class GamebjectManager
  13.     {
  14.         ...
  15.         private static List<EnemyTank> tankList = new List<EnemyTank>();//保存敌人坦克对象
  16.         private static int enemyBornSpeed = 60;//敌人坦克的生成速度
  17.         private static int enemyBornCount = 60;//敌人坦克的生成数量
  18.         private static Point[] points=new Point[3];
  19.  
  20.         public static void Start() {
  21.             points[0].X = 0;
  22.             points[0].Y = 0;
  23.             points[1].X = 7*30;
  24.             points[1].Y = 0;
  25.             points[2].X = 14*30;
  26.             points[2].Y = 0;
  27.         }
  28.  
  29.         public static void Update() {
  30.             ...
  31.             foreach (EnemyTank tank in tankList) {
  32.                 tank.Update();
  33.             }
  34.             ...
  35.             EnemyBorn();
  36.         }
  37.  
  38.         public static void EnemyBorn() {
  39.             enemyBornCount++;
  40.             if (enemyBornCount<enemyBornSpeed) {
  41.                 return;
  42.             }
  43.             Random rd = new Random();
  44.             int index=rd.Next(0, 3);//生成0-3之间的随机整数，不包含3
  45.             Point positon = points[index];
  46.             int enemyType = rd.Next(1, 5);
  47.             switch (enemyType) {
  48.                 case 1:
  49.                     CreateEnemyTank1(positon.X,positon.Y);
  50.                     break;
  51.                 case 2:
  52.                     CreateEnemyTank2(positon.X, positon.Y);
  53.                     break;
  54.                 case 3:
  55.                     CreateEnemyTank3(positon.X, positon.Y);
  56.                     break;
  57.                 case 4:
  58.                     CreateEnemyTank4(positon.X, positon.Y);
  59.                     break;
  60.             }
  61.             enemyBornCount = 0;
  62.         }
  63.  
  64.         private static void CreateEnemyTank1(int x,int y) {
  65.             EnemyTank tank = new EnemyTank(x, y, 2, Resources.GrayDown, Resources.GrayUp, Resources.GrayLeft, Resources.GrayRight);
  66.             tankList.Add(tank);
  67.         }
  68.         private static void CreateEnemyTank2(int x, int y)
  69.         {
  70.             EnemyTank tank = new EnemyTank(x, y, 2, Resources.GreenDown, Resources.GreenUp, Resources.GreenLeft, Resources.GreenRight);
  71.             tankList.Add(tank);
  72.         }
  73.         private static void CreateEnemyTank3(int x, int y)
  74.         {
  75.             EnemyTank tank = new EnemyTank(x, y, 4, Resources.QuickDown, Resources.QuickUp, Resources.QuickLeft, Resources.QuickRight);
  76.             tankList.Add(tank);
  77.         }
  78.         private static void CreateEnemyTank4(int x, int y)
  79.         {
  80.             EnemyTank tank = new EnemyTank(x, y, 1, Resources.SlowDown, Resources.SlowUp, Resources.SlowLeft, Resources.SlowRight);
  81.             tankList.Add(tank);
  82.         }
  83.     }
  84. }

创建EnemyTank构造函数及移动

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace TankWar
  9. {
  10.     class EnemyTank:MoveThing
  11.     {
  12.         private Random r = new Random();
  13.         public EnemyTank(int x, int y, int speed,Bitmap bmpDown,Bitmap bmpUp,Bitmap bmpLeft,Bitmap bmpRight)
  14.         {
  15.             //this.IsMoving = true;
  16.             this.X = x;
  17.             this.Y = y;
  18.             this.Speed = speed;
  19.             BitmapDown = bmpDown;
  20.             BitmapUp = bmpUp;
  21.             BitmapRight = bmpRight;
  22.             BitmapLeft = bmpLeft;
  23.             this.Direction = Direction.DOWN;
  24.         }
  25.  
  26.         public override void Update()
  27.         {
  28.             MoveCheck();//移动前检查
  29.             Move();
  30.             base.Update();
  31.         }
  32.  
  33.         private void ChangeDirection() {
  34.             while (true) {
  35.                 Direction dir = (Direction)r.Next(0, 4);
  36.                 if (Direction == dir)
  37.                 {
  38.                     continue;
  39.                 } else {
  40.                     Direction = dir;
  41.                     break;
  42.                 }
  43.             }
  44.             MoveCheck();
  45.         }
  46.  
  47.         private void Move()
  48.         {
  49.             switch (Direction)
  50.             {
  51.                 case Direction.UP:
  52.                     Y -= Speed;
  53.                     break;
  54.                 case Direction.DOWN:
  55.                     Y += Speed;
  56.                     break;
  57.                 case Direction.LEFT:
  58.                     X -= Speed;
  59.                     break;
  60.                 case Direction.RIGHT:
  61.                     X += Speed;
  62.                     break;
  63.             }
  64.         }
  65.  
  66.         private void MoveCheck()
  67.         {
  68.             #region 检查是否超过窗体边界
  69.             if (Direction == Direction.UP)
  70.             {
  71.                 if (Y - Speed < 0)
  72.                 {
  73.                     ChangeDirection();
  74.                     return;
  75.                 }
  76.             }
  77.             else if (Direction == Direction.DOWN)
  78.             {
  79.                 if (Y + Speed + Height > 450)
  80.                 {
  81.                     ChangeDirection();
  82.                     return;
  83.                 }
  84.             }
  85.             else if (Direction == Direction.LEFT)
  86.             {
  87.                 if (X - Speed < 0)
  88.                 {
  89.                     ChangeDirection();
  90.                     return;
  91.                 }
  92.             }
  93.             else if (Direction == Direction.RIGHT)
  94.             {
  95.                 if (X + Speed + Width > 450)
  96.                 {
  97.                     ChangeDirection();
  98.                     return;
  99.                 }
  100.             }
  101.             #endregion
  102.  
  103.             Rectangle rect = GetRectangle();
  104.             switch (Direction)
  105.             {
  106.                 case Direction.UP:
  107.                     rect.Y -= Speed;
  108.                     break;
  109.                 case Direction.DOWN:
  110.                     rect.Y += Speed;
  111.                     break;
  112.                 case Direction.LEFT:
  113.                     rect.X -= Speed;
  114.                     break;
  115.                 case Direction.RIGHT:
  116.                     rect.X += Speed;
  117.                     break;
  118.             }
  119.             if (GamebjectManager.isCollidedWall(rect) != null)
  120.             {
  121.                 ChangeDirection();
  122.                 return;
  123.             }
  124.             if (GamebjectManager.isCollidedSteel(rect) != null)
  125.             {
  126.                 ChangeDirection();
  127.                 return;
  128.             }
  129.             if (GamebjectManager.isCollidedBoss(rect))
  130.             {
  131.                 ChangeDirection();
  132.                 return;
  133.             }
  134.         }
  135.     }
  136. }

6.发射子弹

在MyTank中添加空格监听，当按下空格后发射子弹

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using TankWar.Properties;
  8.  
  9. namespace TankWar
  10. {
  11.     enum Tag { 
  12.         MyTank,
  13.         EnemyTank
  14.     }
  15.     class Bullet:MoveThing
  16.     {
  17.         public Tag Tag { get; set; } //用于判断是自己的坦克发射的子弹还是敌人的坦克发射的子弹
  18.         public bool isDestroy { get; set; }
  19.         public Bullet(int x, int y, int speed,Direction dir,Tag tag)
  20.         {
  21.             isDestroy = false;
  22.             this.X = x;
  23.             this.Y = y;
  24.             this.Speed = speed;
  25.             BitmapDown = Resources.BulletDown;
  26.             BitmapUp = Resources.BulletUp;
  27.             BitmapRight = Resources.BulletRight;
  28.             BitmapLeft = Resources.BulletLeft;
  29.             this.Direction = dir;
  30.             this.Tag = tag;
  31.             this.X -= Width / 2;
  32.             this.Y -= Height / 2;
  33.         }
  34.  
  35.         public override void DrawSelf()
  36.         {
  37.             base.DrawSelf();
  38.         }
  39.  
  40.         public override void Update()
  41.         {
  42.             MoveCheck();//移动前检查
  43.             Move();
  44.             base.Update();
  45.         }
  46.  
  47.         private void Move()
  48.         {
  49.             switch (Direction)
  50.             {
  51.                 case Direction.UP:
  52.                     Y -= Speed;
  53.                     break;
  54.                 case Direction.DOWN:
  55.                     Y += Speed;
  56.                     break;
  57.                 case Direction.LEFT:
  58.                     X -= Speed;
  59.                     break;
  60.                 case Direction.RIGHT:
  61.                     X += Speed;
  62.                     break;
  63.             }
  64.         }
  65.  
  66.         private void MoveCheck()
  67.         {
  68.             #region 检查是否超过窗体边界
  69.             if (Direction == Direction.UP)
  70.             {
  71.                 if (Y +Height/2+3< 0)//子弹图片自身的高度/2和子弹本身的高度的一半(大约为3)
  72.                 {
  73.                     isDestroy=true;
  74.                     return;
  75.                 }
  76.             }
  77.             else if (Direction == Direction.DOWN)
  78.             {
  79.                 if (Y + Height/2 -3 > 450)
  80.                 {
  81.                     isDestroy = true;
  82.                     return;
  83.                 }
  84.             }
  85.             else if (Direction == Direction.LEFT)
  86.             {
  87.                 if (X+Width/2-3 < 0)
  88.                 {
  89.                     isDestroy = true;
  90.                     return;
  91.                 }
  92.             }
  93.             else if (Direction == Direction.RIGHT)
  94.             {
  95.                 if (X+Width/2+3 > 450)
  96.                 {
  97.                     isDestroy = true;
  98.                     return;
  99.                 }
  100.             }
  101.             #endregion
  102.  
  103.             ...
  104.         }
  105.     }
  106. }

当子弹超出边界时，判断isDestroy并销毁

当子弹遇到墙或者敌人后销毁它们

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using TankWar.Properties;
  8.  
  9. namespace TankWar
  10. {
  11.     enum Tag { 
  12.         MyTank,
  13.         EnemyTank
  14.     }
  15.     class Bullet:MoveThing
  16.     {
  17.         ...
  18.  
  19.         private void MoveCheck()
  20.         {
  21.             ...
  22.             
  23.             Rectangle rect = GetRectangle();
  24.             rect.X = X + Width / 2 - 3;//取到子弹实际位置的左上角横坐标
  25.             rect.Y = Y + Height / 2 - 3;
  26.             rect.Height = 3;
  27.             rect.Width = 3;
  28.             NotMoveThing wall = null;
  29.             if ((wall=GamebjectManager.isCollidedWall(rect)) != null)
  30.             {
  31.                 isDestroy = true;
  32.                 GamebjectManager.DestoryWall(wall);
  33.                 return;
  34.             }
  35.             if (GamebjectManager.isCollidedSteel(rect) != null)
  36.             {
  37.                 isDestroy = true;
  38.                 return;
  39.             }
  40.             if (GamebjectManager.isCollidedBoss(rect))
  41.             {
  42.                 //ChangeDirection();
  43.                 return;
  44.             }
  45.             if (Tag==Tag.MyTank) {
  46.                 EnemyTank tank = null;
  47.                 if ((tank = GamebjectManager.isCollidedEnemyTank(rect))!=null)
  48.                 {
  49.                     isDestroy = true;
  50.                     GamebjectManager.DestoryTank(tank);
  51.                     return;
  52.                 }
  53.             }
  54.             
  55.         }
  56.     }
  57. }

效果 

7.添加爆炸效果

创建爆炸效果类

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using TankWar.Properties;
  8.  
  9. namespace TankWar
  10. {
  11.     class Explosion : GameObject
  12.     {
  13.         public bool IsNeedDestory { get; set;}
  14.         private int playSpeed = 1;
  15.         private int playCount = 0;//0/2=0 1/2=0 2/2=1 3/2=1..每张图片停留2帧 
  16.         private int index = 0;
  17.         private Bitmap[] bmpArray = new Bitmap[] {
  18.             Resources.EXP1,
  19.             Resources.EXP2,
  20.             Resources.EXP3,
  21.             Resources.EXP4,
  22.             Resources.EXP5
  23.         };
  24.         public Explosion(int x,int y) {
  25.             foreach (Bitmap bmp in bmpArray) {
  26.                 bmp.MakeTransparent(Color.Black);
  27.             }
  28.             this.X = x - bmpArray[0].Width / 2;//得到左上角坐标
  29.             this.Y = y - bmpArray[0].Height / 2;
  30.             IsNeedDestory = false;
  31.         }
  32.  
  33.         protected override Image GetImage()
  34.         {
  35.             if (index>4) {
  36.                 return bmpArray[4];
  37.             }
  38.             return bmpArray[index];
  39.         }
  40.  
  41.         public override void Update()
  42.         {
  43.             playCount++;
  44.             index = (playCount - 1) / playSpeed;//获取播放图片的索引
  45.             if (index>4) {
  46.                 IsNeedDestory = true;
  47.             }
  48.             base.Update();
  49.         }
  50.     }
  51. }

添加生成爆炸效果的代码 

8.优化敌人坦克

敌人坦克可发射子弹 

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace TankWar
  9. {
  10.     class EnemyTank:MoveThing
  11.     {
  12.         public int AttackSpeed { get; set; }
  13.         private int attackCount = 0;
  14.         ...
  15.         public EnemyTank(int x, int y, int speed,Bitmap bmpDown,Bitmap bmpUp,Bitmap bmpLeft,Bitmap bmpRight)
  16.         {
  17.             ...
  18.             AttackSpeed = 60;
  19.         }
  20.  
  21.         public override void Update()
  22.         {
  23.             ...
  24.             AttackCheck();//是否需要攻击
  25.             ...
  26.         }
  27.  
  28.         ...
  29.         private void AttackCheck() {
  30.             attackCount++;
  31.             if (attackCount < AttackSpeed) return;
  32.             Attack();
  33.             attackCount = 0;
  34.         }
  35.         private void Attack()
  36.         {
  37.             int x = this.X;
  38.             int y = this.Y;
  39.             switch (Direction)
  40.             {
  41.                 case Direction.UP:
  42.                     x = x + Width / 2;
  43.                     break;
  44.                 case Direction.DOWN:
  45.                     x = x + Width / 2;
  46.                     y += Height;
  47.                     break;
  48.                 case Direction.LEFT:
  49.                     y = y + Height / 2;
  50.                     break;
  51.                 case Direction.RIGHT:
  52.                     x += Width;
  53.                     y = y + Height / 2;
  54.                     break;
  55.             }
  56.             GamebjectManager.CreateBullet(x, y, Tag.EnemyTank, Direction);
  57.         }
  58.     }
  59. }

 敌人可随机转向，而不是遇到障碍我才转向

 

 

 子弹可以攻击主角坦克，主角坦克可以被攻击4次，第4次主角坦克消失并回归起点

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using System.Windows.Forms;
  8. using TankWar.Properties;
  9.  
  10. namespace TankWar
  11. {
  12.     class MyTank:MoveThing
  13.     {
  14.         public int HP { get; set; }//血量
  15.         ...
  16.         private int originalX, originalY;
  17.         public MyTank(int x,int y,int speed) {
  18.             ...
  19.             originalX = x;
  20.             originalY = y;
  21.             ...
  22.             HP = 4;
  23.         }
  24.  
  25.         ...
  26.  
  27.         public void TakeDamage() {
  28.             HP--;
  29.             if (HP<=0) {
  30.                 X = originalX;
  31.                 Y = originalY;
  32.                 HP = 4;
  33.             }
  34.         }
  35.     }
  36. }

 子弹攻击boss时游戏结束

9.添加音效

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Media;
  5. using System.Text;
  6. using System.Threading;
  7. using System.Threading.Tasks;
  8. using TankWar.Properties;
  9.  
  10. namespace TankWar
  11. {
  12.     class SoundManager
  13.     {
  14.  
  15.         private static SoundPlayer startPlayer = new SoundPlayer();
  16.         private static SoundPlayer addPlayer = new SoundPlayer();
  17.         private static SoundPlayer blastPlayer = new SoundPlayer();
  18.         private static SoundPlayer firePlayer = new SoundPlayer();
  19.         private static SoundPlayer hitPlayer = new SoundPlayer();
  20.  
  21.         public static void InitSound() {
  22.             startPlayer.Stream = Resources.start;
  23.             addPlayer.Stream = Resources.add;
  24.             blastPlayer.Stream = Resources.blast;
  25.             firePlayer.Stream = Resources.fire;
  26.             hitPlayer.Stream = Resources.hit;
  27.         }
  28.         public static void PlayStart() {
  29.             startPlayer.Play();
  30.         }
  31.         public static void PlayAdd()
  32.         {
  33.             addPlayer.Play();
  34.         }
  35.         public static void PlayBlast() {
  36.             blastPlayer.Play();
  37.         }
  38.         public static void PlayFire()
  39.         {
  40.             firePlayer.Play();
  41.         }
  42.         public static void PlayHit()
  43.         {
  44.             hitPlayer.Play();
  45.         }
  46.  
  47.     }
  48. }

使用Unity制作

1.创建工程

修改布局模式为2 by 3

Project面板切换单行模式 

导入资源（将unitypackage文件拖到Project面板，在弹出的弹窗点击Import即可）

确保单张图片的SpriteMode选择为Single，多张小图片组成的图片选择为Multiple，TextureType选择为Sprite2D 

切割图片（点击Sprite Editor->Slice->Gride By Cell Size，输入最小图片大小点击Slice即可，之后就可以展开看到切割后图片）

创建Player（将Player1拖到Hierarchy面板即可），创建其对应预制体，同理可创建Wall、Barrier、Grass、Heart

创建动画效果（出生动画、爆炸动画、护盾动画、河流动画），选择动画然后拖到Hierarchy面板，然后命名即可，然后创建其对于预制体，然后会自动产生俩个文件，将其放到新建文件夹Animator和AnimatorController中（适当改名以清晰结构）

2.控制Player移动

新建脚本Player放在新建文件夹Scripts下，与Player对象关联，然后编辑内容

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     public float moveSpeed=3;
  8.     // Start is called before the first frame update
  9.     void Start()
  10.     {
  11.         
  12.     }
  13.  
  14.     // Update is called once per frame
  15.     void Update()
  16.     {
  17.         float h = Input.GetAxisRaw("Horizontal");
  18.         transform.Translate(Vector3.right * h * moveSpeed * Time.deltaTime,Space.World);//乘以delTatime表示按每一秒移动,以世界坐标轴移动
  19.         float v = Input.GetAxisRaw("Vertical");
  20.         transform.Translate(Vector3.up * v * moveSpeed * Time.deltaTime, Space.World);
  21.     }
  22. }

新建一个数组，用以存放4个方向的图片

获取SpriteRender对象控制图片的显示

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     public float moveSpeed=3;
  8.     private SpriteRenderer sr;
  9.     public Sprite[] tankSprite;
  10.     private void Awake()
  11.     {
  12.         sr = GetComponent<SpriteRenderer>();//得到图片渲染组件
  13.     }
  14.     // Start is called before the first frame update
  15.     void Start()
  16.     {
  17.         
  18.     }
  19.  
  20.     // Update is called once per frame
  21.     void Update()
  22.     {
  23.         float h = Input.GetAxisRaw("Horizontal");
  24.         transform.Translate(Vector3.right * h * moveSpeed * Time.deltaTime,Space.World);//乘以delTatime表示按每一秒移动,以世界坐标轴移动
  25.         if (h < 0) {
  26.             sr.sprite = tankSprite[3];//左
  27.         } else if (h>0) {
  28.             sr.sprite = tankSprite[1];//右
  29.         }
  30.         float v = Input.GetAxisRaw("Vertical");
  31.         transform.Translate(Vector3.up * v * moveSpeed * Time.deltaTime, Space.World);
  32.         if (v < 0)
  33.         {
  34.             sr.sprite = tankSprite[2];
  35.         }
  36.         else if (v > 0)
  37.         {
  38.             sr.sprite = tankSprite[0];
  39.         }
  40.     }
  41. }

3.为Player添加碰撞效果

添加碰撞器（点击Add Component后如图）

添加刚体组件

然后将Player的所有新加属性应用到其预制体上 

然后为剩余的Map预制体添加碰撞器（这里把River换到了Map文件中，Player放在了新文件夹下）

然后在运行后发现坦克下落了（这是因为重力的原因，我们将其重力设为0即可） 

去掉Grass的碰撞器，因为逻辑上不需要碰撞

当我们在运行时会发现坦克会在碰撞体边角处发生z轴的旋转，所以我们在这里勾选如图选项即可

处理坦克遇到墙面时抖动滚动的情形（将所有代码放大FixedUpdate方法中并改Time.DeltaTime为Time.fixedDeltaTime，即固定每一帧执行的时间从而保证物理碰撞时相同的）

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     public float moveSpeed=3;
  8.     private SpriteRenderer sr;
  9.     public Sprite[] tankSprite;
  10.     private void Awake()
  11.     {
  12.         sr = GetComponent<SpriteRenderer>();//得到图片渲染组件
  13.     }
  14.     // Start is called before the first frame update
  15.     void Start()
  16.     {
  17.         
  18.     }
  19.  
  20.     // Update is called once per frame
  21.     void Update()
  22.     {
  23.         
  24.     }
  25.  
  26.     private void FixedUpdate()
  27.     {
  28.         float h = Input.GetAxisRaw("Horizontal");
  29.         transform.Translate(Vector3.right * h * moveSpeed * Time.deltaTime, Space.World);//乘以delTatime表示按每一秒移动,以世界坐标轴移动
  30.         if (h < 0)
  31.         {
  32.             sr.sprite = tankSprite[3];//左
  33.         }
  34.         else if (h > 0)
  35.         {
  36.             sr.sprite = tankSprite[1];//右
  37.         }
  38.         float v = Input.GetAxisRaw("Vertical");
  39.         transform.Translate(Vector3.up * v * moveSpeed * Time.deltaTime, Space.World);
  40.         if (v < 0)
  41.         {
  42.             sr.sprite = tankSprite[2];
  43.         }
  44.         else if (v > 0)
  45.         {
  46.             sr.sprite = tankSprite[0];
  47.         }
  48.     }
  49. }

在测试过程种，我们发现同时按下两个键（如左上、左下等）坦克会歇着走，这样是不好的用户体验，所以我们添加如下内容，同时为了代码简洁我们把它放到一个Move方法中调用

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     ...
  8.     private void FixedUpdate()
  9.     {
  10.         Move();   
  11.     }
  12.  
  13.     private void Move()
  14.     {
  15.         float h = Input.GetAxisRaw("Horizontal");
  16.         transform.Translate(Vector3.right * h * moveSpeed * Time.fixedDeltaTime, Space.World);//乘以delTatime表示按每一秒移动,以世界坐标轴移动
  17.         if (h < 0)
  18.         {
  19.             sr.sprite = tankSprite[3];//左
  20.         }
  21.         else if (h > 0)
  22.         {
  23.             sr.sprite = tankSprite[1];//右
  24.         }
  25.  
  26.         if (h != 0)
  27.         {
  28.             return;//处理两键同时按下导致坦克斜着走问题
  29.         }
  30.  
  31.  
  32.         float v = Input.GetAxisRaw("Vertical");
  33.         transform.Translate(Vector3.up * v * moveSpeed * Time.fixedDeltaTime, Space.World);
  34.         if (v < 0)
  35.         {
  36.             sr.sprite = tankSprite[2];
  37.         }
  38.         else if (v > 0)
  39.         {
  40.             sr.sprite = tankSprite[0];
  41.         }
  42.     }
  43. }

设置层级显示（即多张图片叠在一起后优先显示那张图片），下图将出生动画层级设为1（默认为0）则坦克图片经过时就会被遮盖了，同理可设置Grass、Explosion等

然后我们添加Bullet（子弹），将图片拖入左侧面板即可，然后再创建其预制体（放在Tank下）

 添加发射子弹的函数Attack，并绑定预制体

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     ...
  8.     public GameObject bulletPrefab;//子弹预制体
  9.     private void Awake()
  10.     {
  11.         sr = GetComponent<SpriteRenderer>();//得到图片渲染组件
  12.     }
  13.     // Start is called before the first frame update
  14.     void Start()
  15.     {
  16.         
  17.     }
  18.  
  19.     // Update is called once per frame
  20.     void Update()
  21.     {
  22.         Attack(); //发射子弹,一定要放在Update中，如果放在FixedUpdate会偶尔发出不出子弹
  23.     }
  24.  
  25.     private void FixedUpdate()
  26.     {
  27.         Move(); //坦克移动  
  28.         
  29.     }
  30.  
  31.     private void Attack() {
  32.         if (Input.GetKeyDown(KeyCode.Space)) {
  33.             Instantiate(bulletPrefab, transform.position, transform.rotation);
  34.         }
  35.     }
  36.     ...
  37. }

控制子弹的角度（这里需要把欧拉角转换为四元数表示传入），然后再每次坦克变向时设置bulletAngle

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     ...
  8.     private Vector3 bulletAngle;//子弹的发射角度
  9.     ...
  10.  
  11.     // Update is called once per frame
  12.     void Update()
  13.     {
  14.         Attack(); //发射子弹
  15.     }
  16.  
  17.     private void FixedUpdate()
  18.     {
  19.         Move(); //坦克移动  
  20.         
  21.     }
  22.  
  23.     private void Attack() {
  24.         if (Input.GetKeyDown(KeyCode.Space)) {
  25.             Instantiate(bulletPrefab, transform.position, Quaternion.Euler(transform.eulerAngles+bulletAngle));
  26.         }
  27.     }
  28.  
  29.     private void Move()
  30.     {
  31.         float v = Input.GetAxisRaw("Vertical");
  32.         transform.Translate(Vector3.up * v * moveSpeed * Time.fixedDeltaTime, Space.World);
  33.         if (v < 0)
  34.         {
  35.             sr.sprite = tankSprite[2];
  36.             bulletAngle = new Vector3(0, 0, -180);
  37.         }
  38.         else if (v > 0)
  39.         {
  40.             sr.sprite = tankSprite[0];
  41.             bulletAngle = new Vector3(0, 0, 0);
  42.         }
  43.  
  44.         if (v != 0)
  45.         {
  46.             return;//处理两键同时按下导致坦克斜着走问题
  47.         }
  48.  
  49.         float h = Input.GetAxisRaw("Horizontal");
  50.         transform.Translate(Vector3.right * h * moveSpeed * Time.fixedDeltaTime, Space.World);//乘以delTatime表示按每一秒移动,以世界坐标轴移动
  51.         if (h < 0)
  52.         {
  53.             sr.sprite = tankSprite[3];//左
  54.             bulletAngle = new Vector3(0, 0, 90);//这里记住坐标是反着的，
  55.         }
  56.         else if (h > 0)
  57.         {
  58.             sr.sprite = tankSprite[1];//右
  59.             bulletAngle = new Vector3(0, 0, -90);
  60.         }
  61.     }
  62. }

欧拉角：欧拉角包括3个旋转，根据这3个旋转来指定一个刚体的朝向。这3个旋转分别绕x轴，y轴和z轴，分别称为Pitch，Yaw和Roll

绕X轴（红线旋转）

绕Y轴（绿线）旋转 

绕Z轴（蓝线）旋转 

与我们在Unity的坐标一一对应 

四元数

这个四元数真的很难理解，我们先来看一个我们好理解的二元数（也即我们学过的复数），如图我们画一条线段AB（用3+4i表示从A点到B点的路程变化，而B的坐标为(3，4)），当我们想把这条线段旋转90度时，我们得到-6+4i，从而达到旋转后B点的坐标为(-6，4)，这并非巧合，而是可通过计算得到：(4+6i)*i=4i-6，即乘以i代表旋转90度。如果想旋转45度呢？乘以 1/\sqrt{2}+1/\sqrt{2}i 就可以得到（即旋转度数为\theta，乘以cos\theta+sin\thetai）  

然后我们推广到三维空间，同样的几何意义，一个空间线段旋转指定度数得到新的坐标，虚四元数表示为：q=q0+q1i+q2j+q3k，其中i^{2}+j^{2}+k^{2}=ijk=-1，则旋转后的四元数记为p=(q0+q1i+q2j+q3k)*(cos \theta+sin \thetai+sin \thetaj+sin \thetak)即可得到了

控制子弹的移动，创建Bullet脚本，并放在Scripts下，并于Bullet预制体绑定

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Bullet : MonoBehaviour
  6. {
  7.     public float moveSpeed = 10;
  8.     // Start is called before the first frame update
  9.     void Start()
  10.     {
  11.         
  12.     }
  13.  
  14.     // Update is called once per frame
  15.     void Update()
  16.     {
  17.         transform.Translate(transform.up * moveSpeed * Time.deltaTime, Space.World);//世界坐标轴
  18.     }
  19. }

为子弹添加CD（不添加会随这快速按键发射太快）

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     ...
  8.     private float timeVal;//发射子弹CD
  9.  
  10.  
  11.    
  12.     // Update is called once per frame
  13.     void Update()
  14.     {
  15.         Attack();
  16.         if (timeVal >= 0.4){
  17.             Attack(); //发射子弹
  18.         }else {
  19.             timeVal += Time.deltaTime;
  20.         }
  21.     }
  22.  
  23.     private void FixedUpdate()
  24.     {
  25.         Move(); //坦克移动  
  26.         
  27.     }
  28.  
  29.     private void Attack() {
  30.         if (Input.GetKeyDown(KeyCode.Space)) {
  31.             Instantiate(bulletPrefab, transform.position, Quaternion.Euler(transform.eulerAngles+bulletAngle));
  32.             timeVal = 0;
  33.         }
  34.     }
  35.     ...
  36. }

为子弹添加触发器（记得勾选Is Trigger）和钢体组件（重力设为0）

 

为预制体添加Tag，并修改对应Player、Barrier、Wall的Tag

创建空气墙（为了给四周做一个边界，从而判断子弹何时被销毁）复制一个Barrier取名为AirBarrier，删除其SpriteRenderer组件（这样它就变透明不会渲染样式了，即看不见的墙）然后创建其对应预制体 

 添加坦克开始时的护盾效果，将护盾效果放在Player下面（这样就会随着坦克移动了），然后在Player脚本添加护盾效果预制体（记得绑定）、护盾效果时间和是否保护标志等逻辑代码（当护盾时间不大于0时隐藏护盾效果）最后将Player的属性Apply到预制体上

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     ...
  8.     private float defendTimeVal=3;//保护时间
  9.     private bool isDefended=true;//是否保护
  10.     ...
  11.     public GameObject defendEffectPrefab;//护盾特效预制体
  12.     ...
  13.  
  14.     // Update is called once per frame
  15.     void Update()
  16.     {
  17.         //是否处于无敌状态
  18.         if (isDefended) {
  19.             defendEffectPrefab.SetActive(true);
  20.             defendTimeVal -= Time.deltaTime;
  21.             if (defendTimeVal<=0) {
  22.                 isDefended = false;
  23.                 defendEffectPrefab.SetActive(false);
  24.             }
  25.         }
  26.         if (timeVal >= 0.4)
  27.         {
  28.             Attack(); //发射子弹
  29.         }
  30.         else
  31.         {
  32.             timeVal += Time.deltaTime;
  33.         }
  34.  
  35.     }
  36. }

添加Boos的破坏效果，新建Heart脚本，并于Heart预制体绑定，编码，然后绑定图片

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Heart : MonoBehaviour
  6. {
  7.     private SpriteRenderer sr;
  8.     public Sprite BrokenSprite;
  9.     // Start is called before the first frame update
  10.     void Start()
  11.     {
  12.         sr= GetComponent<SpriteRenderer>();
  13.     }
  14.  
  15.     // Update is called once per frame
  16.     void Update()
  17.     {
  18.         
  19.     }
  20.  
  21.     public void Die() {
  22.         sr.sprite = BrokenSprite;
  23.     }
  24. }

为子弹创建触发方法（针对Wall、Heart、Barrier）（Barrier的IsPlayerBullet要勾选）

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Bullet : MonoBehaviour
  6. {
  7.     public float moveSpeed = 10;
  8.     public bool isPlayerBullet;//是否为玩家子弹
  9.     // Start is called before the first frame update
  10.     void Start()
  11.     {
  12.         
  13.     }
  14.  
  15.     // Update is called once per frame
  16.     void Update()
  17.     {
  18.         transform.Translate(transform.up * moveSpeed * Time.deltaTime, Space.World);//世界坐标轴
  19.     }
  20.  
  21.     private void OnTriggerEnter2D(Collider2D collision)
  22.     {
  23.         switch (collision.tag) {
  24.             case "Tank":
  25.                 if (!isPlayerBullet) {
  26.                     collision.SendMessage("Die");//执行碰撞到的物体的Die方法
  27.                 }
  28.                 break;
  29.             case "Heart":
  30.                 collision.SendMessage("Die");//执行碰撞到的物体的Die方法
  31.                 Destroy(gameObject);//销毁子弹自身
  32.                 break;
  33.             case "Enemy":
  34.                 break;
  35.             case "Wall":
  36.                 Destroy(collision.gameObject);//销毁碰撞到的物体
  37.                 Destroy(gameObject);//销毁子弹自身
  38.                 break;
  39.             case "Barrier":
  40.                 Destroy(gameObject);//销毁子弹自身
  41.                 break;
  42.             default:
  43.                 break;
  44.         }
  45.     }
  46. }

重命名子弹名称，并新建一个EnemyBullet，然后其IsPlayerBullet取消勾选，PlayerBullet则勾选 

创建爆炸特效脚本并与预制体绑定

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Explosion : MonoBehaviour
  6. {
  7.     // Start is called before the first frame update
  8.     void Start()
  9.     {
  10.         Destroy(gameObject, 0.2f);
  11.     }
  12.  
  13.     // Update is called once per frame
  14.     void Update()
  15.     {
  16.         
  17.     }
  18. }

创建出生效果，创建Born脚本(与Born预制体绑定)，然后将Player预制体与脚本绑定

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Born : MonoBehaviour
  6. {
  7.     public GameObject playerPrefab;
  8.     // Start is called before the first frame update
  9.     void Start()
  10.     {
  11.         Invoke("BornTank", 1f);//延时调用
  12.         Destroy(gameObject, 1f);//延时销毁
  13.     }
  14.  
  15.     // Update is called once per frame
  16.     void Update()
  17.     {
  18.         
  19.     }
  20.  
  21.     private void BornTank() {
  22.         Instantiate(playerPrefab, transform.position, Quaternion.identity);
  23.     }
  24. }

创建敌人（设置钢体、碰撞器、重力为0，Z轴定向，设置4各方向图片、创建对应预制体，绑定爆炸效果预制体和子弹预制体）添加移动AI（每3秒进行一次攻击，每4秒进行一次转向），并添加敌人子弹的判定效果

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Enemy : MonoBehaviour
  6. {
  7.     public float moveSpeed = 3;
  8.     private Vector3 bulletAngle;//子弹的发射角度
  9.     private float v, h;
  10.     private float timeVal;//发射子弹CD
  11.     private float timeValChangeDirection=4;//改变方向的时间
  12.  
  13.  
  14.     private SpriteRenderer sr;
  15.     public Sprite[] tankSprite;
  16.     public GameObject bulletPrefab;//子弹预制体
  17.     public GameObject explosionPrefab;//爆炸效果预制体
  18.     private void Awake()
  19.     {
  20.         sr = GetComponent<SpriteRenderer>();//得到图片渲染组件
  21.     }
  22.     // Start is called before the first frame update
  23.     void Start()
  24.     {
  25.  
  26.     }
  27.  
  28.     // Update is called once per frame
  29.     void Update()
  30.     {
  31.         if (timeVal >= 3)
  32.         {
  33.             Attack(); //发射子弹
  34.         }
  35.         else
  36.         {
  37.             timeVal += Time.deltaTime;
  38.         }
  39.  
  40.     }
  41.  
  42.     private void FixedUpdate()
  43.     {
  44.         Move(); //坦克移动  
  45.  
  46.     }
  47.  
  48.     private void Attack()
  49.     {
  50.             Instantiate(bulletPrefab, transform.position, Quaternion.Euler(transform.eulerAngles + bulletAngle));
  51.             timeVal = 0;
  52.     }
  53.  
  54.     private void Move()
  55.     {
  56.         if (timeValChangeDirection >= 4)
  57.         {
  58.             int num = Random.Range(0, 8);
  59.             if (num > 5)
  60.             {
  61.                 v = -1;//向下走
  62.                 h = 0;
  63.             }
  64.             else if (num == 0)
  65.             {
  66.                 v = 1;//向后走
  67.                 h = 0;
  68.             }
  69.             else if (num > 0 && num <= 2)
  70.             {
  71.                 h = -1;//向左走
  72.                 v = 0;
  73.             }
  74.             else if (num > 2 && num <= 4)
  75.             {
  76.                 h = 1;//向右走
  77.                 v = 0;
  78.             }
  79.             timeValChangeDirection = 0;
  80.         } else {
  81.             timeValChangeDirection += Time.fixedDeltaTime;
  82.         }
  83.         transform.Translate(Vector3.right * h * moveSpeed * Time.fixedDeltaTime, Space.World);//乘以delTatime表示按每一秒移动,以世界坐标轴移动
  84.         if (h < 0)
  85.         {
  86.             sr.sprite = tankSprite[3];//左
  87.             bulletAngle = new Vector3(0, 0, 90);//这里记住坐标是反着的，
  88.         }
  89.         else if (h > 0)
  90.         {
  91.             sr.sprite = tankSprite[1];//右
  92.             bulletAngle = new Vector3(0, 0, -90);
  93.         }
  94.  
  95.         if (h != 0)
  96.         {
  97.             return;//处理两键同时按下导致坦克斜着走问题
  98.         }
  99.  
  100.         transform.Translate(Vector3.up * v * moveSpeed * Time.fixedDeltaTime, Space.World);
  101.         if (v < 0)
  102.         {
  103.             sr.sprite = tankSprite[2];
  104.             bulletAngle = new Vector3(0, 0, -180);
  105.         }
  106.         else if (v > 0)
  107.         {
  108.             sr.sprite = tankSprite[0];
  109.             bulletAngle = new Vector3(0, 0, 0);
  110.         }
  111.     }
  112.  
  113.     private void Die()
  114.     {
  115.         Instantiate(explosionPrefab, transform.position, transform.rotation);//产生爆炸效果
  116.         Destroy(gameObject);
  117.     }
  118. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Bullet : MonoBehaviour
  6. {
  7.     public float moveSpeed = 10;
  8.     public bool isPlayerBullet;//是否为玩家子弹
  9.     // Start is called before the first frame update
  10.     void Start()
  11.     {
  12.         
  13.     }
  14.  
  15.     // Update is called once per frame
  16.     void Update()
  17.     {
  18.         transform.Translate(transform.up * moveSpeed * Time.deltaTime, Space.World);//世界坐标轴
  19.     }
  20.  
  21.     private void OnTriggerEnter2D(Collider2D collision)
  22.     {
  23.         switch (collision.tag) {
  24.             case "Tank":
  25.                 if (!isPlayerBullet) {
  26.                     collision.SendMessage("Die");//执行碰撞到的物体的Die方法
  27.                     Destroy(gameObject);//销毁子弹自身                
  28.                 }
  29.                 break;
  30.             case "Heart":
  31.                 collision.SendMessage("Die");//执行碰撞到的物体的Die方法
  32.                 Destroy(gameObject);//销毁子弹自身
  33.                 break;
  34.             case "Enemy":
  35.                 if (isPlayerBullet) {
  36.                     collision.SendMessage("Die");
  37.                     Destroy(gameObject);//销毁子弹自身
  38.                 }
  39.                 break;
  40.             case "Wall":
  41.                 Destroy(collision.gameObject);//销毁碰撞到的物体
  42.                 Destroy(gameObject);//销毁子弹自身
  43.                 break;
  44.             case "Barrier":
  45.                 Destroy(gameObject);//销毁子弹自身
  46.                 break;
  47.             default:
  48.                 break;
  49.         }
  50.     }
  51. }

创建多个Born（绑定敌人坦克预制体，多个Born中有一个是用来生成Player的，所以需要勾选CreatePlayer）编写代码控制显示和销毁以及产生的坦克类型

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Born : MonoBehaviour
  6. {
  7.     public GameObject playerPrefab;
  8.     public GameObject[] enemyPrefabList;
  9.     public bool createPlayer;
  10.     // Start is called before the first frame update
  11.     void Start()
  12.     {
  13.         Invoke("BornTank", 1f);//延时调用
  14.         Destroy(gameObject, 1f);//延时销毁
  15.     }
  16.  
  17.     // Update is called once per frame
  18.     void Update()
  19.     {
  20.         
  21.     }
  22.  
  23.     private void BornTank() {
  24.         if (createPlayer) {
  25.             Instantiate(playerPrefab, transform.position, Quaternion.identity);
  26.         }else {
  27.             int num = Random.Range(0, 2);
  28.             Instantiate(enemyPrefabList[num], transform.position, Quaternion.identity);
  29.         }
  30.     }
  31. }

创建空对象命名为MapCreation，创建MapCreation脚本，声明一个GameObject数组，将下图种相关预制体拖入（右上角的锁可以锁定该页面方便拖放预制体） 

 创建BOSS和BOSS周围的墙

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class MapCreation : MonoBehaviour
  6. {
  7.     public GameObject[] item;//保存Boss、墙、障碍、出生效果、河流、草、空气墙
  8.     private void Awake()
  9.     {
  10.         //在界面下边界中间位置，创建Boss
  11.         CreateItem(item[0], new Vector3(0, -8, 0), Quaternion.identity);
  12.         //Boss周围的墙
  13.         CreateItem(item[1], new Vector3(-1,-8,0), Quaternion.identity);
  14.         CreateItem(item[1], new Vector3(1, -8, 0), Quaternion.identity);
  15.         for (int i=-1;i<2;i++) {
  16.             CreateItem(item[1], new Vector3(i, -7, 0), Quaternion.identity);
  17.         }
  18.     }
  19.  
  20.     private void CreateItem(GameObject createObject,Vector3 position,Quaternion rotation) {
  21.         GameObject item = Instantiate(createObject, position, rotation);
  22.         item.transform.SetParent(gameObject.transform);//将新建的对象放在MapCreation下使目录简洁
  23.     }
  24. }

创建外围空气墙，随机位置创建其他对象（墙、障碍、海、草等），拖入一个主角坦克生成点Born

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class MapCreation : MonoBehaviour
  6. {
  7.     public GameObject[] item;//保存Boss、墙、障碍、出生效果、河流、草、空气墙
  8.     private List<Vector3> itemPostionList=new List<Vector3>();//保存每个对象的位置，用于判断随机生成的位置是否已有对象
  9.     private void Awake()
  10.     {
  11.         //在界面下边界中间位置，创建Boss
  12.         CreateItem(item[0], new Vector3(0, -8, 0), Quaternion.identity);
  13.         //Boss周围的墙
  14.         CreateItem(item[1], new Vector3(-1,-8,0), Quaternion.identity);
  15.         CreateItem(item[1], new Vector3(1, -8, 0), Quaternion.identity);
  16.         for (int i=-1;i<2;i++) {
  17.             CreateItem(item[1], new Vector3(i, -7, 0), Quaternion.identity);
  18.         }
  19.         //创建外围空气墙
  20.         for (int i=-11;i<12;i++) {//上边界
  21.             CreateItem(item[6], new Vector3(i, 9, 0), Quaternion.identity);
  22.         }
  23.         for (int i = -11; i < 12; i++)//下边界
  24.         {
  25.             CreateItem(item[6], new Vector3(i, -9, 0), Quaternion.identity);
  26.         }
  27.         for (int i = -8; i < 9; i++)//左边界
  28.         {
  29.             CreateItem(item[6], new Vector3(-11, i, 0), Quaternion.identity);
  30.         }
  31.         for (int i = -8; i < 9; i++)//右边界
  32.         {
  33.             CreateItem(item[6], new Vector3(11, i, 0), Quaternion.identity);
  34.         }
  35.  
  36.         //创建其他对象（墙、障碍、河流、草）
  37.         for (int i=0;i<20;i++) {
  38.             CreateItem(item[1], createRandomPosition(), Quaternion.identity);
  39.         }
  40.         for (int i = 0; i < 20; i++)
  41.         {
  42.             CreateItem(item[2], createRandomPosition(), Quaternion.identity);
  43.         }
  44.         for (int i = 0; i < 20; i++)
  45.         {
  46.             CreateItem(item[4], createRandomPosition(), Quaternion.identity);
  47.         }
  48.         for (int i = 0; i < 20; i++)
  49.         {
  50.             CreateItem(item[5], createRandomPosition(), Quaternion.identity);
  51.         }
  52.  
  53.  
  54.     }
  55.  
  56.     private void CreateItem(GameObject createObject,Vector3 position,Quaternion rotation) {
  57.         GameObject item = Instantiate(createObject, position, rotation);
  58.         item.transform.SetParent(gameObject.transform);//将新建的对象放在MapCreation、下
  59.         itemPostionList.Add(position);//将新建的对象位置放入列表
  60.     }
  61.  
  62.     private Vector3 createRandomPosition() {
  63.         while (true) {
  64.             Vector3 position = new Vector3(Random.Range(-9, 10), Random.Range(-7, 8), 0);//不在四个边界产生游戏物体
  65.             if (!IsUsedPosition(position)) {
  66.                 return position;
  67.             }
  68.         }
  69.     }
  70.  
  71.     private bool IsUsedPosition(Vector3 position) {
  72.         for (int i=0;i<itemPostionList.Count;i++) {
  73.             if (position==itemPostionList[i]) {
  74.                 return true;
  75.             }
  76.         }
  77.         return false;
  78.     }
  79. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/116549
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号