devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C语言课设】经典植物大战僵尸丨完整开发教程+笔记+源码_植物大战僵尸c语言源代码

作者：笔触狂放9 | 2024-05-15 08:13:02

赞

踩

植物大战僵尸c语言源代码

前言

植物对抗僵尸是一款经典小游戏，初学者可以从零开始开发自己的版本，这将是一次令人期待的经历！它可以作为课程设计的一部分，也可以用来快速提升项目开发技能。

视频教程+素材资源

点击进入B站：（视频教程+素材资源）
说明：项目演示视频，在上面链接里的第一个视频，下面只展示项目截图..

项目准备

  • 安装Visual Studio的任意版本（推荐VS2019社区版、VS2022社区版）

  • 领取项目素材（回复“植物大战僵尸”，即可领取）

创建项目

使用VS创建项目，使用空项目模板：

导入素材 ：

在项目目录下，创建res文件夹，把解压后的素材拷贝到res目录下。

实现游戏初始场景

代码如下（需要逐行代码视频讲解，可回复“代码讲解“）。

  1. #include <stdio.h>
  2. #include <graphics.h>
  3. #include "tools.h"
  4. #include <mmsystem.h>
  5. #pragma comment(lib, "winmm.lib")
  6.  
  7. #define WIN_WIDTH    900
  8. #define WIN_HEIGHT    600
  9.  
  10. enum { WAN_DOU, XIANG_RI_KUI, ZHI_WU_COUT };
  11. IMAGE imgBg;
  12. IMAGE imgBar;
  13. IMAGE imgCards[ZHI_WU_COUT];
  14. IMAGE* imgZhiWu[ZHI_WU_COUT][20];
  15. int curZhiWu;
  16. int curX, curY; //当前选中植物在移动过程中的坐标
  17.  
  18. struct zhiWu {
  19.     int type;   // >=1  0:没有植物
  20.     int frameIndex;
  21. };
  22. struct zhiWu  map[3][9];
  23. int sunshine;
  24. int sunshineTable[ZHI_WU_COUT] = { 100, 50 };
  25.  
  26. void gameInit() {
  27.     loadimage(&imgBg, "res/bg.jpg");
  28.     loadimage(&imgBar, "res/bar.png");
  29.     sunshine = 150;
  30.     curZhiWu = 0;
  31.     memset(imgZhiWu, 0, sizeof(imgZhiWu));
  32.     memset(map, 0, sizeof(map));
  33.  
  34.     char name[64];
  35.     for (int i = 0; i < ZHI_WU_COUT; i++) {
  36.         sprintf_s(name, sizeof(name), "res/Cards/card_%d.png", i + 1);
  37.         loadimage(&imgCards[i], name);
  38.  
  39.         for (int j = 0; j < 20; j++) {
  40.             sprintf_s(name, sizeof(name), "res/zhiwu/%d/%d.png", i, j + 1);
  41.             imgZhiWu[i][j] = new IMAGE;
  42.             loadimage(imgZhiWu[i][j], name);
  43.             if (imgZhiWu[i][j]->getwidth() == 0) {
  44.                 delete imgZhiWu[i][j];
  45.                 imgZhiWu[i][j] = NULL;
  46.             }
  47.         }
  48.     }
  49.  
  50.     initgraph(WIN_WIDTH, WIN_HEIGHT, 1);
  51.     // 设置字体：
  52.     LOGFONT f;
  53.     gettextstyle(&f);                     // 获取当前字体设置
  54.     f.lfHeight = 30;                      // 设置字体高度为 48
  55.     f.lfWidth = 15;
  56.     strcpy(f.lfFaceName, "Segoe UI Black");
  57.     f.lfQuality = ANTIALIASED_QUALITY;    // 设置输出效果为抗锯齿  
  58.     settextstyle(&f);                     // 设置字体样式
  59.     setbkmode(TRANSPARENT);
  60.     setcolor(BLACK);
  61.  
  62.     mciSendString("play res/bg.mp3 repeat", 0, 0, 0);
  63. }
  64.  
  65. void updateWindow() {
  66.     BeginBatchDraw();
  67.  
  68.     putimage(0, 0, &imgBg);
  69.     putimagePNG(250, 0, &imgBar);
  70.  
  71.     for (int i = 0; i < ZHI_WU_COUT; i++) {
  72.         int x = 338 + i * 64;
  73.         int y = 6;
  74.         putimage(x, y, &imgCards[i]);
  75.     }
  76.  
  77.     if (curZhiWu > 0) {  // 绘制正在移动的植物
  78.         IMAGE* img = imgZhiWu[curZhiWu - 1][0];
  79.         putimagePNG(curX - img->getwidth() * 0.5, curY - img->getheight() * 0.5, img);
  80.     }
  81.  
  82.     for (int i = 0; i < 3; i++) {
  83.         for (int j = 0; j < 9; j++) {
  84.             if (map[i][j].type > 0) {
  85.                 int x = 260 + j * 81.6;    // (msg.x - 260) / 81.6;
  86.                 int y = 180 + i * 103.6 + 14; // (msg.y - 210) / 103.6;
  87.                 int zhiWuIndex = map[i][j].type;
  88.                 int frameIndex = map[i][j].frameIndex;
  89.                 putimagePNG(x, y, imgZhiWu[zhiWuIndex - 1][frameIndex]);
  90.             }
  91.         }
  92.     }
  93.  
  94.     char scoreText[8];
  95.     sprintf_s(scoreText, sizeof(scoreText), "%d", sunshine);
  96.     outtextxy(282 - 10 + 4, 50 + 15 + 2, scoreText);
  97.     EndBatchDraw();
  98. }
  99.  
  100. void userClick() {
  101.     ExMessage msg;
  102.     static int status = 0;
  103.     if (peekmessage(&msg)) {
  104.         if (msg.message == WM_LBUTTONDOWN) {
  105.             if (msg.x > 338 && msg.x < 338 + 64 * ZHI_WU_COUT && msg.y>6 && msg.y < 96) {
  106.                 int index = (msg.x - 338) / 64;
  107.                 printf("%d\n", index);
  108.                 status = 1;
  109.                 curZhiWu = index + 1; // 1， 2 
  110.                 curX = msg.x;
  111.                 curY = msg.y;
  112.             }
  113.         }
  114.         else if (msg.message == WM_MOUSEMOVE && status == 1) {
  115.             curX = msg.x;
  116.             curY = msg.y;
  117.         }
  118.         else if (msg.message == WM_LBUTTONUP && status == 1) {
  119.             printf("up\n");
  120.             if (msg.x > 260 && msg.y < 995 && msg.y > 180 && msg.y < 491) {
  121.                 if (sunshine >= sunshineTable[curZhiWu - 1]) {
  122.                     sunshine -= sunshineTable[curZhiWu - 1];
  123.                     int col = (msg.x - 260) / 81.6;
  124.                     int row = (msg.y - 210) / 103.6;
  125.                     printf("[%d,%d]\n", row, col);
  126.                     if (map[row][col].type == 0) {
  127.                         map[row][col].type = curZhiWu;
  128.                         map[row][col].frameIndex = 0;
  129.                     }
  130.                 }
  131.             }
  132.             status = 0;
  133.             curZhiWu = 0;
  134.         }
  135.     }
  136. }
  137.  
  138. void updateGame() {
  139.     for (int i = 0; i < 3; i++) {
  140.         for (int j = 0; j < 9; j++) {
  141.             if (map[i][j].type > 0) {
  142.                 map[i][j].frameIndex++;
  143.                 if (imgZhiWu[map[i][j].type - 1][map[i][j].frameIndex] == NULL) {
  144.                     map[i][j].frameIndex = 0;
  145.                 }
  146.             }
  147.         }
  148.     }
  149. }
  150.  
  151. int main(void) {
  152.     gameInit();
  153.  
  154.     int timer = 0;
  155.     bool flag = true;
  156.     while (1) {
  157.         userClick();
  158.         timer += getDelay();
  159.         if (timer > 20) {
  160.             timer = 0;
  161.             flag = true;
  162.         }
  163.         if (flag) {
  164.             flag = false;
  165.             updateWindow();
  166.             updateGame();
  167.         }
  168.     }
  169.  
  170.     return 0;
  171. }

添加启动菜单

创建菜单界面，代码如下：

  1. void startUI() {
  2.     IMAGE imgBg, imgMenu1, imgMenu2;
  3.     loadimage(&imgBg, "res/menu.png");
  4.     loadimage(&imgMenu1, "res/menu1.png");
  5.     loadimage(&imgMenu2, "res/menu2.png");
  6.     int flag = 0;
  7.     while (1) {
  8.         BeginBatchDraw();
  9.         putimage(0, 0, &imgBg);
  10.         putimagePNG(474, 75, flag ? &imgMenu2 : &imgMenu1);
  11.  
  12.         ExMessage msg;
  13.         if (peekmessage(&msg)) {
  14.             if (msg.message == WM_LBUTTONDOWN &&
  15.                 msg.x > 474 && msg.x < 474 + 300 && msg.y > 75 && msg.y < 75 + 140) {
  16.                 flag = 1;
  17.                 EndBatchDraw();
  18.             }
  19.             else if (msg.message == WM_LBUTTONUP && flag) {
  20.                 return;
  21.             }
  22.         }
  23.         EndBatchDraw();
  24.     }
  25. }

在main函数中调用菜单，代码如下：

  1. int main(void) {
  2.     gameInit();
  3.     startUI();
  4.     int timer = 0;
  5.     bool flag = true;
  6.     while (1) {
  7.         userClick();
  8.         timer += getDelay();
  9.         if (timer > 20) {
  10.             timer = 0;
  11.             flag = true;
  12.         }
  13.         if (flag) {
  14.             flag = false;
  15.             updateWindow();
  16.             updateGame();
  17.         }
  18.     }
  19.  
  20.     return 0;
  21. }

生产阳光


熟悉植物大战僵尸的同学都知道，种植植物才能消灭僵尸，但是种植植物，需要先具备一定数量的阳光值。初始的阳光值很小。

有两种方式生成阳光：

第一种，随机降落少量的阳光；

第二种，通过种植向日葵，让向日葵自动生产阳光。我们先实现第一种方式。

定义一个结构体，来表示阳光球。因为阳光是以旋转的方式运动的，所以定义一个图片帧数组，通过循环播放图片帧来实现旋转效果。

  1. IMAGE imgSunshineBall[29]; 
  2. struct sunshineBall { 
  3.     int x, y;
  4.     int frameIndex;
  5.     bool used;
  6.     int destY;
  7.     int timer = 0;
  8. };
  9. struct sunshineBall balls[10];

在gameInit函数中，初始化阳光帧数组。

  1.     memset(balls, 0, sizeof(balls));
  2.     for (int i = 0; i < 29; i++) {
  3.         sprintf_s(name, sizeof(name), "res/sunshine/%d.png", i + 1);
  4.         loadimage(&imgSunshineBall[i], name);
  5.     }

创建阳光，代码如下。

  1. void createSunshine() {
  2.     int ballMax = sizeof(balls) / sizeof(balls[0]);
  3.  
  4.     static int frameCount = 0;
  5.     static int fre = 400;
  6.     frameCount++;
  7.     if (frameCount >= fre) {
  8.         fre = 200 + rand() % 200;  
  9.         frameCount = 0;
  10.         int i;
  11.         for (i = 0; i < ballMax && balls[i].used; i++);
  12.         if (i >= ballMax) return;
  13.  
  14.         balls[i].used = true;
  15.         balls[i].frameIndex = 0;
  16.         balls[i].x = 260 + rand() % (905 - 260);
  17.         balls[i].y = 60;
  18.         balls[i].destY = 180 + (rand() % 4) * 90 + 20;
  19.         balls[i].timer = 0;
  20.     }
  21. }

修改阳光的位置和帧序号，代码如下。

  1. void updateSunshine() {
  2.     int ballMax = sizeof(balls) / sizeof(balls[0]);
  3.  
  4.     for (int i = 0; i < ballMax; i++) {
  5.         if (balls[i].used) {
  6.             balls[i].frameIndex = (balls[i].frameIndex + 1) % 29;
  7.             if(balls[i].timer == 0) balls[i].y += 2;
  8.             if (balls[i].y >= balls[i].destY) {
  9.                 balls[i].timer++;
  10.                 if (balls[i].timer > 100) balls[i].used = false;
  11.             }
  12.         }
  13.     }
  14. }

在updateGame函数中调用以上两个函数 ，以创建阳光并更新阳光的状态。

  1. createSunshine();
  2. updateSunshine();

在updateWindow函数中，渲染阳光。

  1. for (int i = 0; i < 10; i++) {
  2.     if (balls[i].used) {
  3.         putimagePNG(balls[i].x, balls[i].y, &imgSunshineBall[balls[i].frameIndex]);
  4.     }
  5. }

收集阳光

当“阳光球”出现的时候，用户点击阳光球，就可以“收集”这个阳光，当前总的阳光值就会增加25点。在原版的植物大战僵尸游戏中，阳光球被收集后，会慢慢移动到顶部的“工具栏”的左侧。这个阳光球的“移动过程”，我们后续再实现。

定义一个全局变量，表示当前总的阳光值。

int sunshine;

在初始化gameInit中，设置一个初始值。

sunshine = 150;

创建收集阳光的函数，如下：

  1. void collectSunshine(ExMessage* msg) {
  2.     int count = sizeof(balls) / sizeof(balls[0]);
  3.     int w = imgSunshineBall[0].getwidth();
  4.     int h = imgSunshineBall[0].getheight();
  5.     for (int i = 0; i < count; i++) {
  6.         if (balls[i].used) {
  7.             int x = balls[i].x;
  8.             int y = balls[i].y;
  9.             if (msg->x > x && msg->x < x + w && msg->y > y && msg->y < y + h) {
  10.                 balls[i].used = false;
  11.                 sunshine += 25;
  12.                 mciSendString("play res/sunshine.mp3", 0, 0, 0);
  13.             }
  14.         }
  15.     }
  16. }

在用户点击处理中，调用收集阳光的函数。

  1. #include <mmsystem.h>
  2. #pragma comment(lib, "winmm.lib")
  3.  
  4. void userClick() {
  5.     ExMessage msg;
  6.     static int status = 0;
  7.     if (peekmessage(&msg)) {
  8.         if (msg.message == WM_LBUTTONDOWN) {
  9.             if (msg.x > 338 && msg.x < 338 + 65 * ZHI_WU_COUNT && msg.y < 96) {
  10.                 int index = (msg.x - 338) / 65;
  11.                 status = 1;
  12.                 curZhiWu = index + 1;
  13.             } else {
  14.                 collectSunshine(&msg);
  15.             }
  16.         }
  17.         // ...... 
  18.     }
  19. }

显示当前总的阳光值

在gameInit初始化中，设置字体。

  1. LOGFONT f;
  2. gettextstyle(&f);                     // 获取当前字体设置
  3. f.lfHeight = 30;                      // 设置字体高度为 48
  4. f.lfWidth = 15;
  5. strcpy(f.lfFaceName, "Segoe UI Black");
  6. f.lfQuality = ANTIALIASED_QUALITY;    // 设置输出效果为抗锯齿  
  7. settextstyle(&f);                     // 设置字体样式
  8. setbkmode(TRANSPARENT);
  9. setcolor(BLACK);

在updateWindow中绘制阳光值。

  1. char scoreText[8];
  2. sprintf_s(scoreText, sizeof(scoreText), "%d", sunshine);
  3. outtextxy(276, 67, scoreText);

创建僵尸

创建僵尸的数据模型。这里一共创建了10个僵尸，这10个僵尸全部被消灭后，这个关卡就胜利了。

  1.  
  2. struct zm {
  3.     int x, y; 
  4.     int frameIndex;
  5.     bool used;
  6.     int speed;
  7. };
  8. struct zm zms[10];
  9. IMAGE imgZM[22];

僵尸数组，以及僵尸序列帧图片数组，在gameInit函数中进行初始化，如下。（注意：把僵尸的素材图片保存到src/zm目录下。）

  1. memset(zms, 0, sizeof(zms));
  2. srand(time(NULL));
  3.  
  4. for (int i = 0; i < 22; i++) {
  5.     sprintf_s(name, sizeof(name), "res/zm/%d.png", i + 1);
  6.     loadimage(&imgZM[i], name);
  7. }

创建僵尸，代码如下：

  1. void createZM() {
  2.     static int zmFre = 500;
  3.     static int count = 0;
  4.     count++;
  5.     if (count > zmFre) {
  6.         zmFre = rand() % 200 + 300;
  7.         count = 0;
  8.  
  9.         int i;
  10.         int zmMax = sizeof(zms) / sizeof(zms[0]);
  11.         for (i = 0; i < zmMax && zms[i].used; i++);
  12.         if (i < zmMax) {
  13.             zms[i].used = true;
  14.             zms[i].x = WIN_WIDTH;
  15.             zms[i].y = 180 + (1 + rand() % 3) * 100 - 8;
  16.             zms[i].speed = 1;
  17.         }
  18.     }
  19. }

更新僵尸的数据（僵尸的图片帧序号、僵尸的位置），代码如下：

  1. void updateZM() {
  2.     int zmMax = sizeof(zms) / sizeof(zms[0]);
  3.  
  4.     static int count1 = 0;
  5.     count1++;
  6.     if (count1 > 2) {
  7.         count1 = 0;
  8.         for (int i = 0; i < zmMax; i++) {
  9.             if (zms[i].used) {
  10.                 zms[i].x -= zms[i].speed;
  11.                 if (zms->x < 236 - 66) {
  12.                     printf("GAME OVER!\n");
  13.                     MessageBox(NULL, "over", "over", 0); //TO DO
  14.                     break;
  15.                 }
  16.             }
  17.         }
  18.     }
  19.     
  20.     static int count2 = 0;
  21.     count2++;
  22.     if (count2 > 4) {
  23.         count2 = 0;
  24.         for (int i = 0; i < zmMax; i++) {
  25.             if (zms[i].used) {
  26.                 zms[i].frameIndex = (zms[i].frameIndex + 1) % 22;
  27.             }
  28.         }
  29.     }
  30. }

在updateGame函数中，创建僵尸并更新僵尸数据，如下：

  1. createZM();
  2. updateZM();

创建绘制僵尸的接口, 如下：

  1. void drawZM() {
  2.     int zmCount = sizeof(zms) / sizeof(zms[0]);
  3.     for (int i = 0; i < zmCount; i++) {
  4.         if (zms[i].used) {
  5.             IMAGE* img = &imgZM[zms[i].frameIndex];
  6.             int x = zms[i].x;
  7.             int y = zms[i].y - img->getheight();
  8.             putimagePNG(x, y, img);
  9.         }
  10.     }
  11. }

在updateWindow函数中，绘制僵尸，如下：

drawZM();

实现阳光球的飞跃
现在的实现效果是，阳光被点击后，阳光球直接消失了！而原版的植物大战僵尸中，阳光被点击后，阳光会自动飞向左上角的位置，飞到终点后，阳光值才增加25点。我们的实现方式是，阳光球每次飞跃4个点，直到飞到终点，如下图：


给阳光的结构体添加两个成员，表示飞跃过程中的偏移量：

  1. struct sunshineBall { 
  2.     int x, y;
  3.     int frameIndex;
  4.     bool used;
  5.     int destY;
  6.     int timer;
  7.  
  8.     //添加以下两个成员
  9.     float xOff;
  10.     float yOff;
  11. };

在阳光被创建时，把变异量设置为0， 如下：

  1. void createSunshine() {
  2.     int ballMax = sizeof(balls) / sizeof(balls[0]);
  3.     static int frameCount = 0;
  4.     static int fre = 200;
  5.     frameCount++;
  6.     if (frameCount >= fre) {
  7.         //...略
  8.         balls[i].xOff = 0;
  9.         balls[i].yOff = 0;
  10.     }
  11.  
  12. }

阳光被点击后，马上修改阳光球的xoff和yoff:

  1. #include <math.h>
  2.  
  3. void collectSunshine(ExMessage* msg) {
  4.     int count = sizeof(balls) / sizeof(balls[0]);
  5.     int w = imgSunshineBall[0].getwidth();
  6.     int h = imgSunshineBall[0].getheight();
  7.     for (int i = 0; i < count; i++) {
  8.         if (balls[i].used) {
  9.             int x = balls[i].x;
  10.             int y = balls[i].y;
  11.             if (msg->x > x && msg->x < x + w &&
  12.                 msg->y >y && msg->y < y + h) {
  13.                 balls[i].used = false;
  14.                 sunshine += 25;
  15.                 mciSendString("play res/sunshine.mp3", 0, 0, 0);
  16.                 
  17.                 // 设置初始偏移量
  18.                 float destX = 262;
  19.                 float destY = 0;
  20.                 float angle = atan((y - destY) / (x - destX));
  21.                 balls[i].xOff = 4 * cos(angle);
  22.                 balls[i].yOff = 4 * sin(angle);
  23.             }
  24.         }
  25.     }
  26. }

在阳光飞跃过程中更新阳光的位置，如下：（注意是在飞跃过程中，不断计算偏移量，效果更好。）

  1. void updateSunshine() {
  2.     int ballMax = sizeof(balls) / sizeof(balls[0]);
  3.     for (int i = 0; i < ballMax; i++) {
  4.         if (balls[i].used) {
  5.            //略...
  6.         }
  7.         else if (balls[i].xOff) {
  8.             float destX = 263;
  9.             float destY = 0;
  10.             float angle = atan((balls[i].y - destY) / (balls[i].x - destX));
  11.             balls[i].xOff = 4 * cos(angle);
  12.             balls[i].yOff = 4 * sin(angle);
  13.  
  14.             balls[i].x -= balls[i].xOff;
  15.             balls[i].y -= balls[i].yOff;
  16.             if (balls[i].y < 0 || balls[i].x < 262) {
  17.                 balls[i].xOff = 0;
  18.                 balls[i].yOff = 0;
  19.                 sunshine += 25; 
  20.             }
  21.         }
  22.     }
  23. }

删除原来被点击后，立即更新阳光值的代码。

//sunshine += 25;

修改渲染阳光的判断条件，如下：

  1. for (int i = 0; i < ballMax; i++) {
  2.     if (balls[i].used 
  3.             || balls[i].xOff) { //添加这个条件
  4.         IMAGE* img = &imgSunshineBall[balls[i].frameIndex];
  5.         putimagePNG(balls[i].x, balls[i].y, img);
  6.     }
  7. }

此时已经能够实现阳光的飞跃了，但是飞跃动作太慢了，后期我们再优化。

发射豌豆

僵尸靠近时，已经种植的植物豌豆就会自动发射“子弹”，我们先为子弹定义数据类型，如下：

  1. struct bullet {
  2.     int x, y;
  3.     int row;
  4.     bool used;
  5.     int speed;
  6. };
  7. struct bullet bullets[30];
  8. IMAGE imgBulletNormal;

在gameInit函数中，初始化“豌豆子弹池”和子弹的图片，如下：

  1. loadimage(&imgBulletNormal, "res/bullets/bullet_normal.png");
  2. memset(bullets, 0, sizeof(bullets));

在僵尸结构体中，添加成员row, 表示该僵尸所在的“行”，方便后续的判断。也可以不加，直接根据僵尸的y坐标来计算。

  1. struct zm {
  2.     int x, y; 
  3.     int frameIndex;
  4.     bool used;
  5.     int speed;
  6.  
  7.     int row; //0..2
  8. };

在createZM函数中，创建僵尸的时候，设置row成员的值，如下：

  1. ......
  2. if (i < zmMax) {
  3.     zms[i].used = true;
  4.     zms[i].x = WIN_WIDTH;
  5.  
  6.     zms[i].row = rand() % 3; // 0..2;
  7.     zms[i].y = 172 + (1 + zms[i].row) * 100;
  8.  
  9.     zms[i].speed = 1;
  10. }
  11. ......

创建shoot函数，实现豌豆发射子弹，如下：

  1. void shoot() {
  2.     int zmCount = sizeof(zms) / sizeof(zms[0]);
  3.     int directions[3] = { 0 }; 
  4.     int dangerX = WIN_WIDTH - imgZM[0].getwidth();
  5.     for (int i = 0; i < zmCount; i++) {
  6.         if (zms[i].used && zms[i].x < dangerX) {
  7.             directions[zms[i].row] = 1;
  8.         }
  9.     }
  10.  
  11.     for (int i = 0; i < 3; i++) {
  12.         for (int j = 0; j < 9; j++) {
  13.             if (map[i][j].type == WAN_DOU+1 && directions[i]) {
  14.                 static int count = 0;
  15.                 count++;
  16.                 if (count > 20) {
  17.                     count = 0;
  18.                     int k;
  19.                     int maxCount = sizeof(bullets) / sizeof(bullets[0]);
  20.                     for (k = 0; k < maxCount && bullets[k].used; k++);
  21.                     if (k < maxCount) {
  22.                         bullets[k].row = i;
  23.                         bullets[k].speed = 4;
  24.                         bullets[k].used = true;
  25.  
  26.                         int zwX = 260 + j * 81.6;    // (msg.x - 260) / 81.6;
  27.                         int zwY = 180 + i * 103.6 + 14; // (msg.y - 210) / 103.6;
  28.  
  29.                         bullets[k].x = zwX + imgZhiWu[map[i][j].type - 1][0]->getwidth()-10;
  30.                         bullets[k].y = zwY + 5;
  31.                     }
  32.                 }
  33.             }
  34.         }
  35.     }
  36. }

更新子弹的位置，如下：

  1. void updateBullets() {
  2.     int countMax = sizeof(bullets) / sizeof(bullets[0]);
  3.     for (int i = 0; i < countMax; i++) {
  4.         if (bullets[i].used) {
  5.             bullets[i].x += bullets[i].speed;
  6.             if (bullets[i].x > WIN_WIDTH) {
  7.                 bullets[i].used = false;
  8.             }
  9.         }
  10.     }
  11. }

在updateGame函数中，发射子弹并更新子弹的位置，如下：

  1. shoot();
  2. updateBullets();

在updateWindow中绘制子弹，如下：

  1. int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  2. for (int i = 0; i < bulletMax; i++) {
  3.     if (bullets[i].used) {
  4.         putimagePNG(bullets[i].x, bullets[i].y, &imgBulletNormal);
  5.     }
  6. }

子弹和僵尸的碰撞

子弹碰到僵尸之后，子弹会“爆炸”，同时僵尸会“掉血”。我们先给僵尸添加血量成员。

  1. struct zm {
  2.      //略...
  3.     int blood;
  4. };

并在创建僵尸的时候，把血量初始化为100，如下：

  1. //...
  2. zms[i].speed = 1;
  3. zms[i].blood = 100;

子弹在碰到僵尸之后才会爆炸，并显示爆炸图片：

所以，我们在子弹的结构体中添加两个成员，分别表示当前是否已经爆炸，以及爆炸的帧图片序号，如下：

  1. struct bullet {
  2.     //...
  3.     bool blast;
  4.     int frameIndex; 
  5. };
  6. IMAGE imgBulletBlast[4];

在gameInit函数中对子弹帧图片数组，进行初始化，如下：

  1. loadimage(&imgBulletBlast[3], "res/bullets/bullet_blast.png");
  2. for (int i = 0; i < 3; i++) {
  3.     float k = (i + 1) * 0.2;
  4.     loadimage(&imgBulletBlast[i], "res/bullets/bullet_blast.png", 
  5.         imgBulletBlast[3].getwidth()*k,
  6.         imgBulletBlast[3].getheight()*k, true);
  7. }

在发射子弹shoot函数中，对子弹的blast和帧序号frameIndex进行初始化，如下：

  1. bullets[k].row = i;
  2. bullets[k].speed = 4;
  3. bullets[k].used = true;
  4.  
  5. bullets[k].blast = false;
  6. bullets[k].blastTime = 0;

在更新子弹的updateBullets函数中，更新子弹爆炸的帧序号，如下：

  1. bullets[i].x += bullets[i].speed;
  2. if (bullets[i].x > WIN_WIDTH) {
  3.     bullets[i].used = false;
  4. }
  5.  
  6. if (bullets[i].blast) {
  7.     bullets[i].blastTime++;
  8.     if (bullets[i].blastTime >= 4) {
  9.         bullets[i].used = false;
  10.     }
  11. }

进行碰撞检测，检查子弹和僵尸是否发生碰撞，如下：

  1. void collisionCheck() {
  2.     int bCount = sizeof(bullets) / sizeof(bullets[0]);
  3.     int zCount = sizeof(zms) / sizeof(zms[0]);
  4.     for (int i = 0; i < bCount; i++) {
  5.         if (bullets[i].used == false || bullets[i].blast)continue;
  6.         for (int k = 0; k < zCount; k++) {
  7.             int x1 = zms[k].x + 80;
  8.             int x2 = zms[k].x + 110;
  9.             if (bullets[i].row == zms[k].row && bullets[i].x > x1 && bullets[i].x < x2) {
  10.                 zms[i].blood -= 20;
  11.                 bullets[i].blast = true;
  12.                 bullets[i].speed = 0;
  13.             }
  14.         }
  15.         
  16.     }
  17. }

在updateGame函数中，调用碰撞检测函数，如下：

collisionCheck();

渲染子弹的爆炸效果，如下：

  1. int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  2. for (int i = 0; i < bulletMax; i++) {
  3.     if (bullets[i].used) {
  4.         if (bullets[i].blast) {
  5.             IMAGE* img = &imgBulletBlast[bullets[i].blastTime];
  6.             int x = bullets[i].x + 12 - img->getwidth() / 2;
  7.             int y = bullets[i].y + 12 - img->getheight() / 2;
  8.             putimagePNG(x, y, img);
  9.  
  10.             /*bullets[i].used = false;*/
  11.         }
  12.         else {
  13.             putimagePNG(bullets[i].x, bullets[i].y, &imgBulletNormal);
  14.         }
  15.         
  16.     }
  17. }

僵尸死亡

僵尸被豌豆子弹击中后，会“掉血”，血量掉光了，就直接KO了，同时变成一堆“黑沙”。

给僵尸结构体添加dead成员，表示是否已经死亡，另外添加一个图片帧数组，用来表示变成成黑沙的过程。

  1. struct zm {
  2.     ......
  3.     bool dead;
  4. };
  5. IMAGE imgZmDead[20];

在gameInit中对这个图片帧数组进行初始化。

  1. for (int i = 0; i < 20; i++) {
  2.     sprintf_s(name, sizeof(name), "res/zm_dead/%d.png", i + 1);
  3.     loadimage(&imgZmDead[i], name);
  4. }

在碰撞检测中对僵尸的血量做检测，如果血量降到0，就设置为死亡状态。如下：

  1. void collisionCheck() {
  2.     int bCount = sizeof(bullets) / sizeof(bullets[0]);
  3.     int zCount = sizeof(zms) / sizeof(zms[0]);
  4.     for (int i = 0; i < bCount; i++) {
  5.         if (bullets[i].used == false || bullets[i].blast)continue;
  6.         for (int k = 0; k < zCount; k++) {
  7.             int x1 = zms[k].x + 80;
  8.             int x2 = zms[k].x + 110;
  9.             if (zms[k].dead==false &&  //添加这个条件
  10.                     bullets[i].row == zms[k].row && bullets[i].x > x1 && bullets[i].x < x2) {
  11.                 zms[k].blood -= 20;
  12.                 bullets[i].blast = true;
  13.                 bullets[i].speed = 0;
  14.                 
  15.                 //对血量进行检测
  16.                 if (zms[k].blood <= 0) {
  17.                     zms[k].dead = true;
  18.                     zms[k].speed = 0;
  19.                     zms[k].frameIndex = 0;
  20.                 }
  21.                 break;
  22.             }
  23.         }
  24.     }
  25. }

僵尸死亡后，在updateZM中，更新僵尸的状态（变成黑沙发）。如下：

  1. static int count2 = 0;
  2. count2++;
  3. if (count2 > 4) {
  4.     count2 = 0;
  5.     for (int i = 0; i < zmMax; i++) {
  6.         if (zms[i].used) {
  7.             //判断是否已经死亡
  8.             if (zms[i].dead) {
  9.                 zms[i].frameIndex++;
  10.                 if (zms[i].frameIndex >= 20) {
  11.                     zms[i].used = false;
  12.                 }
  13.             }
  14.             else {
  15.                 zms[i].frameIndex = (zms[i].frameIndex + 1) % 22;
  16.             }
  17.         }
  18.     }
  19. }

绘制僵尸的黑沙状态，如下：

  1. void drawZM() {
  2.     int zmCount = sizeof(zms) / sizeof(zms[0]);
  3.     for (int i = 0; i < zmCount; i++) {
  4.         if (zms[i].used) {
  5.             //选择对应的渲染图片
  6.             IMAGE* img = (zms[i].dead) ? imgZmDead : imgZM;
  7.             img += zms[i].frameIndex;
  8.  
  9.             int x = zms[i].x;
  10.             int y = zms[i].y - img->getheight();
  11.             putimagePNG(x, y, img);
  12.         }
  13.     }
  14. }

后续的内容，点击这里看完整的实现

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

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

  

闽ICP备14008679号