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

C语言课设：植物大战僵尸_easyx做植物大战僵尸

作者：你好赵伟 | 2024-05-15 08:15:02

赞

踩

easyx做植物大战僵尸

文章是作者C语言项目的开发日志，主要介绍与该项目有关的函数，代码实现以及在开发过程中遇到的问题。IDE:VS2022。

 资源包以及工具文件已上传，需要的朋友可自取。

C语言:植物大战僵尸库函数解析-CSDN博客

目录

 资源包以及工具文件已上传，需要的朋友可自取。

1.EasyX图形库下载（确保在开始之前已经安装）

1.2进入官网:EasyX Graphics Library for C++

1.3安装后打开文件，点下一步

1.4将EasyX安装到正在使用的编译器中，带点击安装即可

1.5为了确保安装成功，需要打开编译器创建新项目输入以下代码

2.源文件main.cpp

2.1判断文件能否打开：fileExist()

2.2游戏初始化：gameinit()

2.3渲染僵尸:drawzm()

2.4渲染阳光:drawsunshine()

2.5渲染卡牌：drawCard()

2.6渲染种植后的植物:drawPlantMap()

2.7渲染鼠标拖动的植物:drawPlantMove()

2.8渲染豌豆子弹:drawPea()

2.9显示左上角阳光数:outsunshine()

2.10渲染：updatewindow()

2.11收集阳光：collectsunshine()

2.12鼠标操作：userclick()

2.13创建阳光：creatsunshine()

2.14更新阳光参数：updatesunshine()

2.15创建僵尸：creatzomb()

2.16更新僵尸参数:updatezomb()

2.17发射豌豆：shoot()

2.18更新子弹参数：updatebullets()

2.19豌豆->僵尸：checkbullet()

2.20僵尸->植物：checkeat()

2.21碰撞检测：collisioncheck()

2.22更新植物参数：updatePlant()

2.23更改参数：updategame()

2.24起始菜单：startUI()

2.25画面巡视：viewScene()

2.26工具栏下降:barsDown()

2.27判定游戏结束：checkOver()

2.28主函数

3.头文件tools.h(工具文件)

4.源文件tools.cpp(工具文件)

5.源文件vector2.cpp(工具文件:实现贝塞尔曲线)

6.头文件vector2.h(工具文件:实现贝塞尔曲线)

1.EasyX图形库下载（确保在开始之前已经安装）

1.2进入官网:EasyX Graphics Library for C++

1.3安装后打开文件，点下一步

1.4将EasyX安装到正在使用的编译器中，带点击安装即可

注意：easyx只支持C++，所以有些编译器无法下载

1.5为了确保安装成功，需要打开编译器创建新项目输入以下代码

  1. #include <graphics.h>		// 引用 EasyX 绘图库头文件
  2. #include <conio.h>
  3. int main(){
  4. 	initgraph(640, 480);	
  5. 	circle(320, 240, 100);	
  6. 	_getch();				
  7. 	closegraph();			
  8. 	return 0;
  9. }

运行结果证明安装成功

2.源文件main.cpp

  1. #include <stdio.h>
  2. #include <graphics.h>//easyx图形库头文件
  3. #include <math.h>
  4. #include "tools.h"//图片透明函数接口
  5. #include <time.h>
  6. #include <mmsystem.h>//播放音乐头文件
  7. #include "vector2.h"//实现产阳光抛物线
  8.  
  9. #define WIN_WIDTH 900
  10. #define	WIN_HIGHT 600
  11. #define ZM_MAX 10
  12. #define _CRT_SECURE_NO_WARNINGS
  13.  
  14. #pragma warning(disable:4996)//忽略不安全函数
  15. #pragma comment(lib,"winmm.lib")//播放音乐并加载库
  16.  
  17. //植物类型
  18. enum { PEA, SUN_FLOWER, PLANT_COUNTS };//方便添加植物卡牌
  19.  
  20. //阳光的状态
  21. enum { SUNSHINE_DOWN, SUNSHINE_GROUND, SUNSHINE_COLLECT, SUNSHINE_PRODUCT };//下降，落地，收集，生产
  22.  
  23. //游戏状态
  24. enum{GOING,WIN,FAIL};//进行，胜利，失败
  25.  
  26. IMAGE imgBg;//背景图片
  27. IMAGE imgBar;//工具栏
  28. IMAGE imgCard[PLANT_COUNTS];//植物卡牌
  29. IMAGE* imgPLANT[PLANT_COUNTS][20];//实现植物晃动的二维指针数组,20是晃动牌组
  30. IMAGE imgsunshine[29];//存放阳光球图片帧
  31. IMAGE imgzombie[22];//僵尸行走的图片帧
  32. IMAGE imgBulletNormal;//子弹正常形态
  33. IMAGE imgballblast[4];//爆炸图片帧
  34. IMAGE imgzmDead[20];//僵尸死亡帧
  35. IMAGE imgzmEat[21];//僵尸吃植物帧
  36. IMAGE imgzmStand[11];//僵尸站立帧
  37.  
  38. int curX, curY;//表示选中植物卡牌的位置
  39. int curPLANT;//表示选中植物的类型，0:没有选中，1:选中第一种植物
  40. int sunshine = 50;//初始阳光值
  41. int killcount;//已经杀掉的僵尸个数
  42. int zmCount1;//已经出现的僵尸个数
  43. int gameStatus;//游戏状态
  44.  
  45. struct PLANT//植物相关的结构体
  46. {
  47. 	int type;//一块草坪种植的植物类型，0:没有种植，1:种植第一种植物
  48. 	int frameindex;//表示植物晃动时图片的序号
  49. 	int shootTimer;//发射计数器
  50. 	bool catched;//是否被僵尸捕获
  51. 	int deadtime;//死亡计数器
  52. 	int timer;//生产阳光的计时器
  53. 	int x, y;//植物的位置
  54. };
  55. struct PLANT map[3][9];//草坪有3行9列
  56.  
  57. struct sunshineBALL //阳光球结构体
  58. {
  59. 	int x, y;//阳光掉落时的坐标
  60. 	int frameINDEX;//阳光旋转的图片帧
  61. 	int destY;//阳光下落的最终坐标
  62. 	bool used;//判断阳光是否在使用
  63. 	int timer;//阳光在场上停留的时间
  64. 	float xoff;//阳光飞跃时x轴偏移量
  65. 	float yoff;//阳光飞跃时y轴偏移量
  66. 	float t;//贝塞尔曲线的时间点
  67. 	vector2 p1, p2, p3, p4;//贝塞尔曲线的起始点(p1,p4)和控制点(p2,p3)
  68. 	vector2 pCur;//当前时刻阳光球的位置
  69. 	float speed;
  70. 	int status;//当前状态
  71. };
  72. struct sunshineBALL balls[10];//10个阳光球
  73. int ballMax = sizeof(balls) / sizeof(balls[0]);//阳光数量
  74.  
  75. struct zomb//僵尸结构体
  76. {
  77. 	int x, y;//僵尸的坐标
  78. 	int frameIndex;//图片帧
  79. 	bool used;//使用情况
  80. 	int speed;//行走速度
  81. 	int zmrow;//僵尸在第(zmrow+1)行
  82. 	int blood;//僵尸的血量
  83. 	bool dead;//死亡
  84. 	bool eating;//正在吃植物的状态
  85. };
  86. struct zomb zms[10];//10个僵尸
  87.  
  88. struct bullet//豌豆射手的子弹
  89. {
  90. 	int x, y;
  91. 	int pearow;//子弹所处的行
  92. 	int speed;//速度
  93. 	bool used;//使用情况
  94. 	bool blast;//子弹爆炸情况
  95. 	int frameindex;//爆炸帧
  96. };
  97. struct bullet bullets[30];//30个子弹
  98.  
  99. bool fileExist(char* name)//判断文件能否打开
  100. {
  101. 	FILE* fp = fopen(name, "r");//以“读”的形式打开文件
  102. 	//fopen函数能打开文件返回文件路径,打不开文件返回NULL,所以需要定义指针变量
  103. 	if (fp == NULL)
  104. 		return false;//表示文件打不开
  105. 	else
  106. 		fclose(fp);//关闭文件
  107. 		return true;//表示文件能打开
  108. }
  109.  
  110. void gameInit()//初始化函数
  111. {
  112. 	//加载背景图片
  113. 	loadimage(&imgBg, "res/bg.jpg");
  114. 	loadimage(&imgBar, "res/bar5.png");
  115.  
  116. 	killcount = 0;
  117. 	zmCount1 = 0;
  118. 	gameStatus = GOING;
  119.  
  120. 	//对数组整体初始化
  121. 	memset(imgPLANT, 0, sizeof(imgPLANT));
  122. 	memset(map, 0, sizeof(map));
  123. 	memset(balls, 0, sizeof(balls));
  124. 	memset(zms, 0, sizeof(zms));
  125. 	memset(bullets, 0, sizeof(bullets));
  126.  
  127. 	char plant_name[64];
  128. 	for (int i = 0; i < PLANT_COUNTS; i++)//初始化植物卡牌
  129. 	{
  130. 		sprintf_s(plant_name, sizeof(plant_name), "res/Cards/card_%d.png", i + 1);
  131. 		loadimage(&imgCard[i], plant_name);
  132.  
  133. 		for (int j = 0; j < 20; j++)
  134. 		{
  135. 			//将植物晃动的图片格式化到数组plant_name中
  136. 			sprintf_s(plant_name, sizeof(plant_name), "res/zhiwu/%d/%d.png", i, j + 1);
  137. 			if (fileExist(plant_name))//判断文件是否存在
  138. 			{
  139. 				imgPLANT[i][j] = new IMAGE;//分配新的内存
  140. 				loadimage(imgPLANT[i][j], plant_name);//将图片加载到实现晃动的数组里
  141. 			}
  142. 			else//打不开跳出循环
  143. 				break;
  144. 		}
  145. 	}
  146.  
  147. 	curPLANT = 0;//初始化
  148.  
  149. 	for (int i = 0; i < 29; i++)//初始化阳光球
  150. 	{
  151. 		sprintf_s(plant_name, sizeof(plant_name), "res/sunshine/%d.png", i + 1);
  152. 		loadimage(&imgsunshine[i], plant_name);
  153. 	}
  154.  
  155. 	srand(time(NULL));//配置随机种子
  156.  
  157. 	initgraph(WIN_WIDTH, WIN_HIGHT, 1);//创建游戏窗口，显示图片
  158.  
  159. 	LOGFONT f;//设置显示阳光的字体
  160. 	gettextstyle(&f);//获取字体的文本格式
  161. 	f.lfHeight = 30;//字体高度30
  162. 	f.lfWeight = 15;//设置字体的粗细
  163. 	strcpy(f.lfFaceName, "Segoe UI Black");//设置字体格式
  164. 	f.lfQuality = ANTIALIASED_QUALITY;//抗锯齿
  165. 	settextstyle(&f);
  166. 	setbkmode(TRANSPARENT);//设置字体背景透明
  167. 	setcolor(BLACK);//设置字体颜色
  168.  
  169. 	for (int i = 0; i < 22; i++)//初始化僵尸
  170. 	{
  171. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm/%d.png", i + 1);
  172. 		loadimage(&imgzombie[i], plant_name);
  173. 	}
  174.  
  175. 	//初始化豌豆normal
  176. 	loadimage(&imgBulletNormal, "res/bullets/bullet_normal.png");
  177.  
  178. 	//初始化豌豆blast
  179. 	//爆炸的实质是一张爆炸帧图片放大四次
  180. 	loadimage(&imgballblast[3], "res/bullets/bullet_blast.png");
  181. 	for (int i = 0; i < 3; i++)//放大次数(可修改)
  182. 	{
  183. 		float k = (i + 1) * 0.2;//0.2是放大倍数(可修改)
  184. 		loadimage(&imgballblast[i], "res/bullets/bullet_blast.png",
  185. 			imgballblast[3].getwidth() * k, imgballblast[3].getheight() * k, true);
  186. 			//true表示按照如上的大小放大该图片,false相反
  187. 	}
  188.  
  189. 	//初始化僵尸dead
  190. 	for (int i = 0; i < 20; i++)
  191. 	{
  192. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm_dead/%d.png", i + 1);
  193. 		loadimage(&imgzmDead[i], plant_name);
  194. 	}
  195.  
  196. 	//初始化僵尸eat
  197. 	for (int i = 0; i < 21; i++)
  198. 	{
  199. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm_eat/%d.png", i + 1);
  200. 		loadimage(&imgzmEat[i], plant_name);
  201. 	}
  202.  
  203. 	//初始化僵尸stand
  204. 	for (int i = 0; i < 11; i++)
  205. 	{
  206. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm_stand/%d.png", i + 1);
  207. 		loadimage(&imgzmStand[i], plant_name);
  208. 	}
  209. }
  210.  
  211. void drawzm()//渲染僵尸
  212. {
  213. 	int zmMax = sizeof(zms) / sizeof(zms[0]);
  214. 	for (int i = 0; i < zmMax; i++)
  215. 	{
  216. 		if (zms[i].used)
  217. 		{
  218. 			//根据僵尸的情况而调用不同的数组
  219. 			IMAGE* img3 = NULL;
  220. 			if (zms[i].dead)
  221. 				img3 = imgzmDead;
  222. 			else if (zms[i].eating)
  223. 				img3 = imgzmEat;
  224. 			else
  225. 				img3 = imgzombie;
  226. 			img3 += zms[i].frameIndex;
  227. 			putimagePNG(zms[i].x, zms[i].y - img3->getheight(), img3);
  228. 		}
  229. 	}
  230. }
  231.  
  232. void drawsunshine()//渲染阳光
  233. {
  234. 	for (int i = 0; i < ballMax; i++)
  235. 	{
  236. 		//if (balls[i].used || balls[i].xoff)
  237. 		if(balls[i].used)
  238. 		{
  239. 			IMAGE* img2 = &imgsunshine[balls[i].frameINDEX];
  240. 			//putimagePNG(balls[i].x, balls[i].y, img2);
  241. 			putimagePNG(balls[i].pCur.x, balls[i].pCur.y, img2);
  242. 		}
  243. 	}
  244. }
  245.  
  246. void drawCard()//渲染卡牌
  247. {
  248. 	for (int i = 0; i < PLANT_COUNTS; i++)//加载植物卡牌
  249. 	{
  250. 		int x = 338 + i * 65;//将植物加载到卡槽里
  251. 		int y = 6;
  252. 		putimage(x, y, &imgCard[i]);
  253. 	}
  254. }
  255.  
  256. void drawPlantMap()//渲染种植后的植物
  257. {
  258. 	for (int i = 0; i < 3; i++)//控制行,渲染种植后的植物
  259. 	{
  260. 		for (int j = 0; j < 9; j++)//控制列
  261. 		{
  262. 			if (map[i][j].type > 0)
  263. 			{
  264. 				//int x = 256 + j * 81;//植物种植的横坐标
  265. 				//int y = 179 + i * 102 + 14;//植物种植的纵坐标,位置可自行调整
  266. 				putimagePNG(map[i][j].x, map[i][j].y, imgPLANT[map[i][j].type - 1][map[i][j].frameindex]);
  267. 			}
  268. 		}
  269. 	}
  270. }
  271.  
  272. void drawPlantMove()//渲染鼠标拖动的植物
  273. {
  274. 	if (curPLANT)//渲染拖动时的植物模型
  275. 	{
  276. 		IMAGE* img1 = imgPLANT[curPLANT - 1][0];
  277. 		//实现无背景贴图,让鼠标位于植物的正中间
  278. 		putimagePNG(curX - img1->getwidth() / 2, curY - img1->getheight() / 2, img1);//取植物晃动的第一张图片
  279. 	}
  280. }
  281.  
  282. void drawPea()渲染豌豆
  283. {
  284. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  285. 	for (int i = 0; i < bulletMax; i++)
  286. 	{
  287. 		if (bullets[i].used)
  288. 		{
  289. 			if (bullets[i].blast)//爆炸
  290. 			{
  291. 				IMAGE* img5 = &imgballblast[bullets[i].frameindex];
  292. 				putimagePNG(bullets[i].x, bullets[i].y, img5);
  293. 			}
  294. 			else//正常
  295. 			{
  296. 				putimagePNG(bullets[i].x, bullets[i].y, &imgBulletNormal);
  297. 			}
  298. 		}
  299. 	}
  300. }
  301.  
  302. void outsunshine()//显示左上角阳光数
  303. {
  304. 	char scoreText[8];
  305. 	sprintf_s(scoreText, sizeof(scoreText), "%d", sunshine);//将阳光格式化为字符串并加载进数组
  306. 	outtextxy(279, 67, scoreText);//在指定位置输出字符串
  307. }
  308.  
  309. void updateWindow()//渲染显示图片
  310. {
  311. 	BeginBatchDraw();//开始缓冲
  312. 	putimage(-112, 0, &imgBg);//从最左上角显示草坪
  313. 	putimagePNG(250, 0, &imgBar);//植物栏
  314.  
  315. 	drawCard();//渲染卡牌
  316. 	
  317. 	drawPlantMap();//渲染种植后的植物
  318.  
  319. 	drawPlantMove();//渲染拖动时的植物
  320.  
  321. 	drawsunshine();//渲染阳光
  322.  
  323. 	drawzm();//渲染僵尸
  324.  
  325. 	drawPea();//渲染豌豆
  326.  
  327. 	outsunshine();//显示左上角阳光数
  328.  
  329. 	EndBatchDraw();//结束双缓冲
  330. }
  331.  
  332. void collectsunshine(ExMessage* msg)//实现收集阳光
  333. {
  334. 	int width = imgsunshine[0].getwidth();//获取阳光球的宽
  335. 	int hight = imgsunshine[0].getheight();//获取阳光球的高
  336. 	for (int i = 0; i < ballMax; i++)
  337. 	{
  338. 		if (balls[i].used)//遍历每一个用过的阳光
  339. 		{
  340. 			//int x = balls[i].x;//此阳光球左上角的x坐标
  341. 			//int y = balls[i].y;//此阳光球左上角的y坐标
  342. 			int x = balls[i].pCur.x;
  343. 			int y = balls[i].pCur.y;
  344. 			if (msg->x > x && msg->x<x + width && msg->y>y && msg->y < y + hight)//判断鼠标位置与阳光球的位置
  345. 			{
  346. 				//选中范围近似为矩形
  347. 				//balls[i].used = false;//选中后消失
  348. 				balls[i].status = SUNSHINE_COLLECT;//收集状态
  349. 				PlaySound("res/sunshine.wav", NULL, SND_FILENAME | SND_ASYNC);
  350. 				//mciSendString("play res/sunshine.mp3", 0, 0, NULL);//音乐播放(有延迟)
  351.  
  352. 				//贝塞尔曲线法渲染阳光球飞跃路线
  353. 				balls[i].p1 = balls[i].pCur;//起点:被收集时的位置
  354. 				balls[i].p4 = vector2( 262,0 );//终点
  355. 				balls[i].t = 0;
  356. 				float distance = dis(balls[i].p1 - balls[i].p2);//两点之间的距离
  357. 				float off = 8;//每次移动的像素(可修改)
  358. 				balls[i].speed = 1.0 / (distance / off);//一次移动完成
  359. 				break;
  360.  
  361. 				//获取阳光球与目的地中心连线与水平方向的夹角
  362. 				//float destY = 0;
  363. 				//float destX = 262;//植物栏阳光收集位置的坐标
  364. 				//float angle = atan((y - destY) / (x - destX));//通过反正切函数获取夹角
  365. 				//balls[i].xoff = 40 * cos(angle);
  366. 				//balls[i].yoff = 40 * sin(angle);//4是指定的飞跃速度
  367. 			}
  368. 		}
  369. 	}
  370. }
  371.  
  372. void userclick()//实现鼠标相关操作
  373. {
  374. 	ExMessage msg;//结构体变量
  375. 	static int status = 0;//判断状态
  376. 	if (peekmessage(&msg))//判断msg的范围内是否有信息
  377. 	{
  378. 		if (msg.message == WM_LBUTTONDOWN)//鼠标左键按下
  379. 		{
  380. 			if (msg.x > 338 && msg.x < 338 + 65 * PLANT_COUNTS && msg.y < 96)//选择植物
  381. 			{
  382. 				int index = (msg.x - 338) / 65;//判断植物卡牌，这是下标
  383. 				status = 1;//表示鼠标左键已经按下
  384. 				//printf("%d\n", index);//测试
  385. 				curPLANT = index + 1;//选择植物
  386. 			}
  387. 			else //收集阳光
  388. 			{
  389. 				collectsunshine(&msg);
  390. 			}
  391. 		}
  392. 		else if (msg.message == WM_MOUSEMOVE && status == 1)//鼠标移动
  393. 		{
  394. 			curX = msg.x;//鼠标移动时图片的x轴位置
  395. 			curY = msg.y;//鼠标移动时图片的y轴位置
  396. 		}
  397. 		else if (msg.message == WM_LBUTTONUP)//鼠标左键抬起
  398. 		{
  399. 			if (msg.x > 144 && msg.y > 179 && msg.y < 489)//草坪的范围
  400. 			{
  401. 				int row = (msg.y - 179) / 102;//植物种植的行，102是行宽
  402. 				int col = (msg.x - 144) / 81;//植物种植的列,81是列宽
  403. 				//printf("%d,%d\n", row, col);//测试
  404. 				if (map[row][col].type == 0)//草坪只有空状态才能种植
  405. 				{
  406. 					map[row][col].type = curPLANT;//表示row行col列的植物类型为curPLANT
  407. 					map[row][col].frameindex = 0;
  408. 					map[row][col].shootTimer = 0;
  409. 					map[row][col].x = 144 + col * 81;
  410. 					map[row][col].y = 179 + row * 102 + 14;
  411. 				}
  412. 			}
  413. 			status = 0;
  414. 			curPLANT = 0;//鼠标左键抬起植物种下
  415. 		}
  416. 	}
  417. }
  418.  
  419. void creatsunshine()//选取阳光,阳光结构体成员的初始化
  420. {
  421. 	static int count = 0;
  422. 	static int fre = 200;
  423. 	count++;
  424. 	if (count >= fre)
  425. 	{
  426. 		fre = 100 + rand() % 200;//每200到399毫秒创建一个阳光
  427. 		count = 0;
  428. 		int i = 0;
  429. 		for (i = 0; i < 29 && balls[i].used; i++);//空循环查询可使用的阳光
  430. 		//used初始为0表示该阳光可以被使用，循环停止
  431. 		if (i >= 29)
  432. 			return;
  433. 		balls[i].used = true;//第i个阳光被使用
  434. 		balls[i].frameINDEX = 0;//动画帧
  435. 		balls[i].timer = 0;
  436. 		//balls[i].x = 260 + rand() % (900 - 260);//阳光球随机在场上刷新
  437. 		//balls[i].y = 60;//初始下落坐标
  438. 		//balls[i].destY = 200 + (rand() % 4 * 90);
  439. 		//balls[i].xoff = 0;
  440. 		//balls[i].yoff = 0;
  441. 		balls[i].status = SUNSHINE_DOWN;//下落状态
  442. 		balls[i].t = 0;
  443. 		balls[i].p1 = vector2( 260 + rand() % (900 - 148) ,60 );//起点
  444. 		balls[i].p4 = vector2( balls[i].p1.x,200 + (rand() % 4 * 90) );//终点
  445. 		int off = 2;
  446. 		float distance = balls[i].p4.y - balls[i].p1.y;
  447. 		balls[i].speed = 1.0 / (distance / off);
  448. 	}
  449. 	//向日葵生产阳光
  450. 	static int sunshinecount = 0;
  451. 	if (++sunshinecount > 2)
  452. 	{
  453. 		sunshinecount = 0;
  454. 		for (int i = 0; i < 3; i++)//遍历3行9列
  455. 		{
  456. 			for (int j = 0; j < 9; j++)
  457. 			{
  458. 				if (map[i][j].type == SUN_FLOWER + 1)
  459. 				{
  460. 					map[i][j].timer++;
  461. 					if (map[i][j].timer > 100)//生产阳光的时间间隔
  462. 					{
  463. 						map[i][j].timer = 0;//归零
  464. 						int k;//找到第k个可用阳光
  465. 						for (k = 0; k < ballMax && balls[k].used; k++);
  466. 						if (k >= ballMax)
  467. 							return;
  468. 						balls[k].used = true;
  469. 						balls[k].p1 = vector2(map[i][j].x, map[i][j].y);//起点
  470. 						int w = (100 + rand() % 50) * (rand() % 2 ? 1 : -1);//阳光掉落位置与向日葵的距离(可在左也可在右)
  471. 						balls[k].p4 = vector2(map[i][j].x + w, map[i][j].y + imgPLANT[SUN_FLOWER][0]->getheight() - imgsunshine[0].getheight());
  472. 						balls[k].p2 = vector2(balls[k].p1.x + w * 0.3, balls[k].p1.y - 100);
  473. 						balls[k].p3 = vector2(balls[k].p1.x + w * 0.7, balls[k].p1.y - 100);
  474. 						balls[k].status = SUNSHINE_PRODUCT;
  475. 						balls[k].speed = 0.05;
  476. 						balls[k].t = 0;
  477. 					}
  478. 				}
  479. 			}
  480. 		}
  481. 	}
  482. }
  483.  
  484. void updatesunshine()//更新阳光状态:使用——>未使用，动画帧再初始化
  485. {
  486. 	for (int i = 0; i < ballMax; i++)
  487. 	{
  488. 		if (balls[i].used)//如果阳光球处于使用状态，则更新
  489. 		{
  490. 			balls[i].frameINDEX = (balls[i].frameINDEX + 1) % 29;//防止动画帧越界
  491. 			if (balls[i].status == SUNSHINE_DOWN)//下落
  492. 			{
  493. 				struct sunshineBALL* sun = &balls[i];
  494. 				sun->t += sun->speed;
  495. 				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);//直线运动
  496. 				if (sun->t >= 1)//到达终点
  497. 				{
  498. 					sun->status = SUNSHINE_GROUND;//更改状态
  499. 					sun->timer = 0;
  500. 				}
  501. 			}
  502. 			else if (balls[i].status == SUNSHINE_GROUND)//落地
  503. 			{
  504. 				balls[i].timer++;
  505. 				if (balls[i].timer > 100)
  506. 				{
  507. 					balls[i].used = false;
  508. 					balls[i].timer = 0;
  509. 				}
  510. 			}
  511. 			else if (balls[i].status == SUNSHINE_COLLECT)//收集
  512. 			{
  513. 				struct sunshineBALL* sun = &balls[i];
  514. 				sun->t += sun->speed;
  515. 				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);//直线运动
  516. 				if (sun->t > 1)
  517. 				{
  518. 					sun->used = false;
  519. 					sunshine += 25;
  520. 				}
  521. 			}
  522. 			else if (balls[i].status == SUNSHINE_PRODUCT)//生产
  523. 			{
  524. 				struct sunshineBALL* sun = &balls[i];
  525. 				sun->t += sun->speed;
  526. 				//调用贝塞尔曲线函数
  527. 				sun->pCur = calcBezierPoint(sun->t, sun->p1, sun->p2, sun->p3, sun->p4);//曲线运动
  528. 				if (sun->t > 1)
  529. 				{
  530. 					sun->status = SUNSHINE_GROUND;
  531. 					sun->timer = 0;
  532. 				}
  533. 			}
  534. 			//if (balls[i].timer == 0)//下落过程中停留时间不变为0
  535. 			//{
  536. 			//	balls[i].y += 3;//阳光下落
  537. 			//}
  538. 			//if (balls[i].y >= balls[i].destY)
  539. 			//{
  540. 			//	balls[i].timer++;
  541. 			//	if (balls[i].timer > 100)//停留100帧后消失
  542. 			//	{
  543. 			//		balls[i].used = false;//更新阳光的使用状态
  544. 			//	}
  545. 			//}
  546. 		}
  547. 		//else if (balls[i].xoff)
  548. 		//{
  549. 		//	float destY = 0;
  550. 		//	float destX = 262;//植物栏阳光收集位置的坐标
  551. 		//	float angle = atan((balls[i].y - destY) / (balls[i].x - destX));//通过反正切函数获取夹角
  552. 		//	balls[i].xoff = 40 * cos(angle);
  553. 		//	balls[i].yoff = 40 * sin(angle);//4是指定的飞跃速度
  554. 		//	//每次飞跃时消除误差
  555.  
  556. 		//	balls[i].x -= balls[i].xoff;
  557. 		//	balls[i].y -= balls[i].yoff;
  558. 		//	if (balls[i].x < 262 || balls[i].y < 0)
  559. 		//	{
  560. 		//		balls[i].xoff = 0;
  561. 		//		balls[i].yoff = 0;//偏移量归零
  562. 		//		sunshine += 25;
  563. 		//		balls[i].used = false;//到达目的地后模型消失
  564. 		//	}
  565. 		//}
  566. 	}
  567. }
  568.  
  569. void creatzomb()//创建僵尸
  570. {
  571. 	if (zmCount1 >= 10)
  572. 		return;
  573. 	int i;
  574. 	int zmMax = sizeof(zms) / sizeof(zms[0]);//僵尸的数量
  575. 	static int zmcount = 0;
  576. 	static int zmfre = 40;
  577. 	zmcount++;
  578. 	if (zmcount >= zmfre)
  579. 	{
  580. 		zmfre = 100 + rand() % 100;
  581. 		zmcount = 0;
  582. 		for (i = 0; i < zmMax && zms[i].used; i++);//查询可用的僵尸
  583. 		if (i < zmMax)
  584. 		{
  585. 			memset(&zms[i], 0, sizeof(zms[i]));
  586. 			zms[i].used = true;//表示该僵尸已经用过
  587. 			zms[i].x = WIN_WIDTH;//僵尸的横坐标
  588. 			zms[i].zmrow = rand() % 3;
  589. 			zms[i].y = 173 + (zms[i].zmrow + 1) * 100;//行高近似为100
  590. 			zms[i].speed = 1;//初始速度
  591. 			zms[i].blood = 150;//10个豌豆
  592. 			zms[i].dead = false;
  593. 			zmCount1++;
  594. 		}
  595. 		else
  596. 		{
  597. 			printf("创建僵尸失败\n");
  598. 		}
  599. 	}
  600. }
  601.  
  602. void updatezomb()//更新僵尸的数据
  603. {
  604. 	int zmMax = sizeof(zms) / sizeof(zms[0]);//僵尸的数量
  605. 	static int count = 0;
  606. 	count++;
  607. 	if (count > 2)
  608. 	{
  609. 		count = 0;
  610. 		for (int i = 0; i < zmMax; i++)
  611. 		{
  612. 			if (zms[i].used)//被使用则更新
  613. 			{
  614. 				zms[i].x -= zms[i].speed;
  615. 				if (zms[i].x <= 28)
  616. 				{
  617. 					//printf("GAME OVER\n");
  618. 					//MessageBox(NULL, "over", "over", 0);//显示对话框
  619. 					//exit(0);//退出程序(待优化)
  620. 					gameStatus = FAIL;//游戏失败
  621. 				}
  622. 			}
  623. 		}
  624. 	}
  625.  
  626. 	static int count2 = 0;
  627. 	count2++;
  628. 	if (count2 > 8)
  629. 	{
  630. 		count2 = 0;
  631. 		for (int i = 0; i < zmMax; i++)//更新僵尸的图片帧
  632. 		{
  633. 			if (zms[i].used)
  634. 			{
  635. 				if (zms[i].dead)//判断僵尸死亡
  636. 				{
  637. 					zms[i].frameIndex++;
  638. 					if (zms[i].frameIndex >= 20)
  639. 					{
  640. 						zms[i].used = false;
  641. 						killcount++;
  642. 						if (killcount == ZM_MAX)
  643. 							gameStatus = WIN;//游戏胜利
  644. 					}
  645. 				}
  646. 				else if (zms[i].eating)
  647. 				{
  648. 					zms[i].frameIndex = (zms[i].frameIndex + 1) % 21;
  649. 				}
  650. 				else
  651. 				{
  652. 					zms[i].frameIndex = (zms[i].frameIndex + 1) % 22;//防止越界
  653. 				}
  654. 			}
  655. 		}
  656. 	}
  657. }
  658.  
  659. void shoot()//发射豌豆
  660. {
  661. 	static int count6 = 0;
  662. 	if (++count6 < 5)
  663. 		return;
  664. 	count6 = 0;
  665. 	int lines[3] = { 0 };//表示3行草坪
  666. 	int zmMax = sizeof(zms) / sizeof(zms[0]);//僵尸数量
  667. 	int peaMax = sizeof(bullets) / sizeof(bullets[0]);
  668. 	int dangerX = WIN_WIDTH;//- imgzombie[0].getwidth();//发射豌豆的距离(可调节)
  669. 	for (int i = 0; i < zmMax; i++)
  670. 	{
  671. 		if (zms[i].used && zms[i].x < dangerX)//僵尸出现在草坪上
  672. 		{
  673. 			lines[zms[i].zmrow] = 1;//僵尸出现的行表示为1
  674. 		}
  675. 	}
  676.  
  677. 	for (int i = 0; i < 3; i++)//遍历草坪
  678. 	{
  679. 		for (int j = 0; j < 9; j++)
  680. 		{
  681. 			if (map[i][j].type == PEA + 1 && lines[i])//植物类型是1代表豌豆射手，可以发射子弹
  682. 			{
  683. 				map[i][j].shootTimer++;
  684. 				if (map[i][j].shootTimer > 15)//调节豌豆发射的频率(可调节)
  685. 				{
  686. 					map[i][j].shootTimer = 0;
  687. 					int k;
  688. 					for (k = 0; k < peaMax && bullets[k].used; k++);//查找可用子弹
  689. 					if (k < peaMax)
  690. 					{
  691. 						bullets[k].used = true;
  692. 						bullets[k].pearow = i;//第i+1行
  693. 						bullets[k].speed = 3;
  694. 						bullets[k].blast = false;//最开始没有发生爆炸
  695. 						bullets[k].frameindex = 0;
  696.  
  697. 						int peax = 144 + j * 81;//植物种植的横坐标
  698. 						int peay = 179 + i * 102 + 14;//植物种植的纵坐标,位置可自行调整
  699. 						//发射位置是豌豆左上角坐标加上一个身位的嘴部,-10可自行调整,只是为了更接近原版
  700. 						bullets[k].x = peax + imgPLANT[map[i][j].type - 1][0]->getwidth() - 10;
  701. 						bullets[k].y = peay + 5;
  702. 					}
  703. 				}
  704. 			}
  705. 		}
  706. 	}
  707. }
  708.  
  709. void updatebullets()//更新子弹的数据
  710. {
  711. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);//子弹数目
  712. 	for (int i = 0; i < bulletMax; i++)
  713. 	{
  714. 		if (bullets[i].used)
  715. 		{
  716. 			bullets[i].x += bullets[i].speed;//更新x坐标
  717. 			if (bullets[i].x > WIN_WIDTH)
  718. 			{
  719. 				bullets[i].used = false;//对超出边界的豌豆回收
  720. 			}
  721. 			if (bullets[i].blast)//子弹符合爆炸条件
  722. 			{
  723. 				bullets[i].frameindex++;
  724. 				if (bullets[i].frameindex >= 4)
  725. 				{
  726. 					bullets[i].used = false;//爆炸结束
  727. 				}
  728. 			}
  729. 		}
  730. 	}
  731. }
  732.  
  733. void checkbullet()//豌豆->僵尸
  734. {
  735. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  736. 	int zombMax = sizeof(zms) / sizeof(zms[0]);
  737. 	for (int i = 0; i < bulletMax; i++)//遍历子弹
  738. 	{
  739. 		if (bullets[i].used == false || bullets[i].blast)
  740. 			continue;//如果子弹还未出现或已经爆炸则无需做爆炸检测
  741. 		for (int j = 0; j < zombMax; j++)//遍历僵尸
  742. 		{
  743. 			if (zms[j].used == false)
  744. 				continue;//僵尸还未出现无需检测
  745. 			int x1 = zms[j].x + 80;
  746. 			int x2 = zms[j].x + 110;//僵尸模型的范围
  747. 			int x = bullets[i].x;//子弹的坐标
  748. 			if (zms[j].dead == false && bullets[i].pearow == zms[j].zmrow && x > x1 && x < x2)//保证僵尸和子弹在同一行
  749. 			{
  750. 				//僵尸死亡不用做碰撞检测
  751. 				zms[j].blood -= 20;//扣20滴血
  752. 				bullets[i].blast = true;//子弹爆炸
  753. 				bullets[i].speed = 0;
  754. 				if (zms[j].blood <= 0)
  755. 				{
  756. 					zms[j].dead = true;//僵尸死亡
  757. 					zms[j].speed = 0;
  758. 					zms[j].frameIndex = 0;
  759. 				}
  760. 				break;
  761. 			}
  762. 		}
  763. 	}
  764. }
  765.  
  766. void checkeat()//僵尸->植物
  767. {
  768. 	int zmcount = sizeof(zms) / sizeof(zms[0]);
  769. 	for (int i = 0; i < zmcount; i++)//遍历僵尸
  770. 	{
  771. 		if (zms[i].dead)
  772. 			continue;
  773. 		int samerow = zms[i].zmrow;
  774. 		for (int k = 0; k < 9; k++)//只遍历相同行的9个格子
  775. 		{
  776. 			if (map[samerow][k].type == 0)//该格子没有种植植物
  777. 				continue;
  778. 			int plantX = 144 + k * 81;//植物图片左上角的坐标
  779. 			int x1 = plantX + 10;//植物的左边界
  780. 			int x2 = plantX + 60;//植物的右边界
  781. 			int x3 = zms[i].x + 80;//僵尸的左边界
  782. 			if (x3 > x1 && x3 < x2)
  783. 			{
  784. 				if (map[samerow][k].catched)//植物被捕获
  785. 				{
  786. 					map[samerow][k].deadtime ++;
  787. 					if (map[samerow][k].deadtime > 100)
  788. 					{
  789. 						map[samerow][k].deadtime = 0;
  790. 						map[samerow][k].type = 0;
  791. 						zms[i].eating = false;
  792. 						zms[i].frameIndex = 0;
  793. 						zms[i].speed = 2;
  794. 						map[samerow][k].catched = false;
  795. 					}
  796. 				}
  797. 				else
  798. 				{
  799. 					map[samerow][k].catched = true;
  800. 					map[samerow][k].deadtime = 0;//死亡倒计时
  801. 					zms[i].eating = true;//僵尸开吃
  802. 					zms[i].speed = 0;
  803. 					zms[i].frameIndex = 0;
  804. 				}
  805. 			}
  806. 		}
  807. 	}
  808. }
  809.  
  810. void collisioncheck()//碰撞检测
  811. {
  812. 	checkbullet();//子弹碰撞
  813. 	checkeat();//僵尸捕获植物
  814. }
  815.  
  816. void updatePlant()//更新植物
  817. {
  818. 	static int count = 0;//频度控制
  819. 	if (++count > 2)
  820. 	{
  821. 		count = 0;
  822. 		for (int i = 0; i < 3; i++)
  823. 		{
  824. 			for (int j = 0; j < 9; j++)
  825. 			{
  826. 				if (map[i][j].type > 0)
  827. 				{
  828. 					map[i][j].frameindex++;//从第一张图片到最后一张图片
  829. 					//判断能否打开文件,打不开证明是最后一帧
  830. 					if (imgPLANT[map[i][j].type - 1][map[i][j].frameindex] == NULL)
  831. 					{
  832. 						map[i][j].frameindex = 0;//再初始化，从第一帧重新开始
  833. 					}
  834. 				}
  835. 			}
  836. 		}
  837. 	}
  838. }
  839.  
  840. void updateGame()//在每次循环后更改相应的参数
  841. {
  842. 	updatePlant();//更新植物
  843.  
  844. 	creatsunshine();//创建阳光
  845. 	updatesunshine();//更新阳光
  846.  
  847. 	creatzomb();//创建僵尸
  848. 	updatezomb();//更新僵尸
  849.  
  850. 	shoot();//发射豌豆
  851. 	updatebullets();//更新豌豆
  852.  
  853. 	collisioncheck();//碰撞检测
  854. }
  855.  
  856. void startUI()//起始菜单
  857. {
  858. 	mciSendString("play res/bg.mp3", 0, 0, NULL);
  859. 	IMAGE imgBG, imgMenu1, imgMenu2;
  860. 	loadimage(&imgBG, "res/menu.png");
  861. 	loadimage(&imgMenu1, "res/menu1.png");//选中选项卡
  862. 	loadimage(&imgMenu2, "res/menu2.png");//未选中选项卡
  863. 	int flag = 0;//表示是否选中，选中则为1
  864. 	
  865. 	while (1)
  866. 	{
  867. 		BeginBatchDraw();
  868. 		putimage(0, 0, &imgBG);
  869. 		putimagePNG(474, 75, flag ? &imgMenu2 : &imgMenu1);
  870.  
  871. 		ExMessage msg;
  872. 		if (peekmessage(&msg))
  873. 		{
  874. 			if (msg.message == WM_LBUTTONDOWN &&
  875. 				msg.x > 474 && msg.x < 474 + 300 && msg.y>75 &&
  876. 				msg.y < 75 + 140)
  877. 			{
  878. 				flag = 1;//表示选中
  879. 			}
  880. 			else if (msg.message == WM_LBUTTONUP && flag)
  881. 			{
  882. 				EndBatchDraw();
  883. 				break;
  884. 			}
  885. 		}
  886. 		EndBatchDraw();
  887. 	}
  888. 	mciSendString("close res/bg.mp3", 0, 0, 0);
  889. }
  890.  
  891. void viewScene()//视角移动
  892. {
  893. 	int xMax = WIN_WIDTH - imgBg.getwidth();//窗口宽-图片宽(坐标为负数)
  894. 	vector2 point[9] = { {550,80},{530,160},{630,170},{530,200},{515,270},
  895. 		{565,370},{605,340},{705,280},{690,340} };//阅览僵尸站位(可修改)
  896.  
  897. 	int index[9];
  898. 	for (int j = 0; j < 9; j++)
  899. 	{
  900. 		index[j] = rand() % 11;//僵尸起始帧序号
  901. 	}
  902. 	
  903. 	int scenecount = 0;
  904.  
  905. 	//画面巡视
  906. 	for (int i = 0; i >= xMax; i -= 2)
  907. 	{
  908. 		BeginBatchDraw();
  909.  
  910. 		putimage(i, 0, &imgBg);
  911. 		scenecount++;
  912. 		for (int k = 0; k < 9; k++)//绘制僵尸站位
  913. 		{
  914. 			putimagePNG(point[k].x - xMax + i, point[k].y, &imgzmStand[index[k]]);
  915. 			if (scenecount >= 10)
  916. 				index[k] = (index[k] + 1) % 11;
  917. 		}
  918. 		if (scenecount >= 10)
  919. 			scenecount = 0;
  920.  
  921. 		EndBatchDraw();
  922. 		Sleep(5);
  923. 	}
  924.  
  925. 	//画面停留时间(可修改)
  926. 	for (int i = 0; i < 50; i++)
  927. 	{
  928. 		BeginBatchDraw();
  929. 		
  930. 		putimage(xMax, 0, &imgBg);
  931. 		for (int k = 0; k < 9; k++)
  932. 		{
  933. 			putimagePNG(point[k].x, point[k].y, &imgzmStand[index[k]]);
  934. 			index[k] = (index[k] + 1) % 11;
  935. 		}
  936.  
  937. 		EndBatchDraw();
  938. 		Sleep(30);
  939. 	}
  940.  
  941. 	//画面返回
  942. 	for (int k = xMax; k <= -112; k += 2)
  943. 	{
  944. 		BeginBatchDraw();
  945.  
  946. 		putimage(k, 0, &imgBg);
  947. 		scenecount++;
  948. 		for (int i = 0; i < 9; i++)
  949. 		{
  950. 			putimagePNG(point[i].x - xMax + k, point[i].y, &imgzmStand[index[i]]);
  951. 			if (scenecount >= 10)
  952. 				index[i] = (index[i] + 1) % 11;
  953. 		}
  954. 		if (scenecount >= 10)
  955. 			scenecount = 0;
  956.  
  957. 		EndBatchDraw();
  958. 		Sleep(5);
  959. 	}
  960. }
  961.  
  962. void barsDown()//工具栏下降
  963. {
  964. 	int hight = imgBar.getheight();//获取工具栏的高
  965. 	for (int i = -hight; i <= 0; i++)
  966. 	{
  967. 		BeginBatchDraw();
  968.  
  969. 		putimage(-112, 0, &imgBg);
  970. 		putimagePNG(250, i, &imgBar);
  971.  
  972. 		for (int k = 0; k < PLANT_COUNTS; k++)
  973. 		{
  974. 			int x = 338 + k * 65;
  975. 			int y = 6 + i;
  976. 			putimage(x, y, &imgCard[k]);
  977. 		}
  978.  
  979. 		EndBatchDraw();
  980. 		Sleep(10);
  981. 	}
  982. }
  983.  
  984. bool checkOver()//游戏结束画面
  985. {
  986. 	bool ret = false;
  987. 	if (gameStatus == WIN)//游戏胜利
  988. 	{
  989. 		mciSendString("play res/win.mp3", 0, 0, NULL);
  990. 		Sleep(2000);
  991. 		mciSendString("close res/win.mp3", 0, 0, NULL);
  992. 		IMAGE* img7 = NULL;
  993. 		loadimage(img7, "res/gameWin.png");
  994. 		putimage(0, 0, img7);
  995. 		ret = true;
  996. 	}
  997. 	else if (gameStatus == FAIL)
  998. 	{
  999. 		mciSendString("play res/lose.mp3", 0, 0, NULL);
  1000. 		Sleep(2000);
  1001. 		mciSendString("close res/lose.mp3", 0, 0, NULL);
  1002. 		IMAGE* img9 = NULL;
  1003. 		loadimage(img9, "res/gameFail.png");
  1004. 		putimage(0, 0, img9);
  1005. 		ret = true;
  1006. 	}
  1007. 	return ret;
  1008. }
  1009.  
  1010. int main()
  1011. {
  1012. 	gameInit();
  1013. 	startUI();
  1014. 	viewScene();
  1015. 	barsDown();
  1016. 	
  1017. 	int timer = 0;//实现帧等待
  1018. 	bool flag = true;
  1019.  
  1020. 	while (1)//循环退出条件:用户单击
  1021. 	{
  1022. 		userclick();
  1023.  
  1024. 		timer += getDelay();//运行时间间隔
  1025. 		if (timer > 10)//运行时间间隔大于10毫秒
  1026. 		{
  1027. 			flag = true;
  1028. 			timer = 0;//再初始化
  1029. 		}
  1030. 		if (flag)
  1031. 		{
  1032. 			flag = false;
  1033. 			updateWindow();
  1034. 			updateGame();
  1035. 			if (checkOver())
  1036. 				break;
  1037. 		}
  1038. 	}
  1039. 	
  1040. 	system("pause");//暂停
  1041. 	return 0;
  1042. }

2.1判断文件能否打开：fileExist()

  1. bool fileExist(char* name)//判断文件能否打开
  2. {
  3. 	FILE* fp = fopen(name, "r");//以“读”的形式打开文件
  4. 	//fopen函数能打开文件返回文件路径,打不开文件返回NULL,所以需要定义指针变量
  5. 	if (fp == NULL)
  6. 		return false;//表示文件打不开
  7. 	else
  8. 		fclose(fp);//关闭文件
  9. 		return true;//表示文件能打开
  10. }

2.2游戏初始化：gameinit()

  1. void gameInit()//初始化函数
  2. {
  3. 	//加载背景图片
  4. 	loadimage(&imgBg, "res/bg.jpg");
  5. 	loadimage(&imgBar, "res/bar5.png");
  6.  
  7. 	killcount = 0;
  8. 	zmCount1 = 0;
  9. 	gameStatus = GOING;
  10.  
  11. 	//对数组整体初始化
  12. 	memset(imgPLANT, 0, sizeof(imgPLANT));
  13. 	memset(map, 0, sizeof(map));
  14. 	memset(balls, 0, sizeof(balls));
  15. 	memset(zms, 0, sizeof(zms));
  16. 	memset(bullets, 0, sizeof(bullets));
  17.  
  18. 	char plant_name[64];
  19. 	for (int i = 0; i < PLANT_COUNTS; i++)//初始化植物卡牌
  20. 	{
  21. 		sprintf_s(plant_name, sizeof(plant_name), "res/Cards/card_%d.png", i + 1);
  22. 		loadimage(&imgCard[i], plant_name);
  23.  
  24. 		for (int j = 0; j < 20; j++)
  25. 		{
  26. 			//将植物晃动的图片格式化到数组plant_name中
  27. 			sprintf_s(plant_name, sizeof(plant_name), "res/zhiwu/%d/%d.png", i, j + 1);
  28. 			if (fileExist(plant_name))//判断文件是否存在
  29. 			{
  30. 				imgPLANT[i][j] = new IMAGE;//分配新的内存
  31. 				loadimage(imgPLANT[i][j], plant_name);//将图片加载到实现晃动的数组里
  32. 			}
  33. 			else//打不开跳出循环
  34. 				break;
  35. 		}
  36. 	}
  37.  
  38. 	curPLANT = 0;//初始化
  39.  
  40. 	for (int i = 0; i < 29; i++)//初始化阳光球
  41. 	{
  42. 		sprintf_s(plant_name, sizeof(plant_name), "res/sunshine/%d.png", i + 1);
  43. 		loadimage(&imgsunshine[i], plant_name);
  44. 	}
  45.  
  46. 	srand(time(NULL));//配置随机种子
  47.  
  48. 	initgraph(WIN_WIDTH, WIN_HIGHT, 1);//创建游戏窗口，显示图片
  49.  
  50. 	LOGFONT f;//设置显示阳光的字体
  51. 	gettextstyle(&f);//获取字体的文本格式
  52. 	f.lfHeight = 30;//字体高度30
  53. 	f.lfWeight = 15;//设置字体的粗细
  54. 	strcpy(f.lfFaceName, "Segoe UI Black");//设置字体格式
  55. 	f.lfQuality = ANTIALIASED_QUALITY;//抗锯齿
  56. 	settextstyle(&f);
  57. 	setbkmode(TRANSPARENT);//设置字体背景透明
  58. 	setcolor(BLACK);//设置字体颜色
  59.  
  60. 	for (int i = 0; i < 22; i++)//初始化僵尸
  61. 	{
  62. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm/%d.png", i + 1);
  63. 		loadimage(&imgzombie[i], plant_name);
  64. 	}
  65.  
  66. 	//初始化豌豆normal
  67. 	loadimage(&imgBulletNormal, "res/bullets/bullet_normal.png");
  68.  
  69. 	//初始化豌豆blast
  70. 	//爆炸的实质是一张爆炸帧图片放大四次
  71. 	loadimage(&imgballblast[3], "res/bullets/bullet_blast.png");
  72. 	for (int i = 0; i < 3; i++)//放大次数(可修改)
  73. 	{
  74. 		float k = (i + 1) * 0.2;//0.2是放大倍数(可修改)
  75. 		loadimage(&imgballblast[i], "res/bullets/bullet_blast.png",
  76. 			imgballblast[3].getwidth() * k, imgballblast[3].getheight() * k, true);
  77. 			//true表示按照如上的大小放大该图片,false相反
  78. 	}
  79.  
  80. 	//初始化僵尸dead
  81. 	for (int i = 0; i < 20; i++)
  82. 	{
  83. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm_dead/%d.png", i + 1);
  84. 		loadimage(&imgzmDead[i], plant_name);
  85. 	}
  86.  
  87. 	//初始化僵尸eat
  88. 	for (int i = 0; i < 21; i++)
  89. 	{
  90. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm_eat/%d.png", i + 1);
  91. 		loadimage(&imgzmEat[i], plant_name);
  92. 	}
  93.  
  94. 	//初始化僵尸stand
  95. 	for (int i = 0; i < 11; i++)
  96. 	{
  97. 		sprintf_s(plant_name, sizeof(plant_name), "res/zm_stand/%d.png", i + 1);
  98. 		loadimage(&imgzmStand[i], plant_name);
  99. 	}
  100. }

2.3渲染僵尸:drawzm()

  1. void drawzm()//渲染僵尸
  2. {
  3. 	int zmMax = sizeof(zms) / sizeof(zms[0]);
  4. 	for (int i = 0; i < zmMax; i++)
  5. 	{
  6. 		if (zms[i].used)
  7. 		{
  8. 			//根据僵尸的情况而调用不同的数组
  9. 			IMAGE* img3 = NULL;
  10. 			if (zms[i].dead)
  11. 				img3 = imgzmDead;
  12. 			else if (zms[i].eating)
  13. 				img3 = imgzmEat;
  14. 			else
  15. 				img3 = imgzombie;
  16. 			img3 += zms[i].frameIndex;
  17. 			putimagePNG(zms[i].x, zms[i].y - img3->getheight(), img3);
  18. 		}
  19. 	}
  20. }

2.4渲染阳光:drawsunshine()

  1. void drawsunshine()//渲染阳光
  2. {
  3. 	for (int i = 0; i < ballMax; i++)
  4. 	{
  5. 		//if (balls[i].used || balls[i].xoff)
  6. 		if(balls[i].used)
  7. 		{
  8. 			IMAGE* img2 = &imgsunshine[balls[i].frameINDEX];
  9. 			//putimagePNG(balls[i].x, balls[i].y, img2);
  10. 			putimagePNG(balls[i].pCur.x, balls[i].pCur.y, img2);
  11. 		}
  12. 	}
  13. }

2.5渲染卡牌：drawCard()

  1. void drawCard()//渲染卡牌
  2. {
  3. 	for (int i = 0; i < PLANT_COUNTS; i++)//加载植物卡牌
  4. 	{
  5. 		int x = 338 + i * 65;//将植物加载到卡槽里
  6. 		int y = 6;
  7. 		putimage(x, y, &imgCard[i]);
  8. 	}
  9. }

2.6渲染种植后的植物:drawPlantMap()

  1. void drawPlantMap()//渲染种植后的植物
  2. {
  3. 	for (int i = 0; i < 3; i++)//控制行,渲染种植后的植物
  4. 	{
  5. 		for (int j = 0; j < 9; j++)//控制列
  6. 		{
  7. 			if (map[i][j].type > 0)
  8. 			{
  9. 				//int x = 256 + j * 81;//植物种植的横坐标
  10. 				//int y = 179 + i * 102 + 14;//植物种植的纵坐标,位置可自行调整
  11. 				putimagePNG(map[i][j].x, map[i][j].y, imgPLANT[map[i][j].type - 1][map[i][j].frameindex]);
  12. 			}
  13. 		}
  14. 	}
  15. }

2.7渲染鼠标拖动的植物:drawPlantMove()

  1. void drawPlantMove()//渲染鼠标拖动的植物
  2. {
  3. 	if (curPLANT)//渲染拖动时的植物模型
  4. 	{
  5. 		IMAGE* img1 = imgPLANT[curPLANT - 1][0];
  6. 		//实现无背景贴图,让鼠标位于植物的正中间
  7. 		putimagePNG(curX - img1->getwidth() / 2, curY - img1->getheight() / 2, img1);//取植物晃动的第一张图片
  8. 	}
  9. }

2.8渲染豌豆子弹:drawPea()

  1. void drawPea()渲染豌豆
  2. {
  3. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  4. 	for (int i = 0; i < bulletMax; i++)
  5. 	{
  6. 		if (bullets[i].used)
  7. 		{
  8. 			if (bullets[i].blast)//爆炸
  9. 			{
  10. 				IMAGE* img5 = &imgballblast[bullets[i].frameindex];
  11. 				putimagePNG(bullets[i].x, bullets[i].y, img5);
  12. 			}
  13. 			else//正常
  14. 			{
  15. 				putimagePNG(bullets[i].x, bullets[i].y, &imgBulletNormal);
  16. 			}
  17. 		}
  18. 	}
  19. }

2.9显示左上角阳光数:outsunshine()

  1. void outsunshine()//显示左上角阳光数
  2. {
  3. 	char scoreText[8];
  4. 	sprintf_s(scoreText, sizeof(scoreText), "%d", sunshine);//将阳光格式化为字符串并加载进数组
  5. 	outtextxy(279, 67, scoreText);//在指定位置输出字符串
  6. }

2.10渲染：updatewindow()

  1. void updateWindow()//渲染显示图片
  2. {
  3. 	BeginBatchDraw();//开始缓冲
  4. 	putimage(-112, 0, &imgBg);//从最左上角显示草坪
  5. 	putimagePNG(250, 0, &imgBar);//植物栏
  6.  
  7. 	drawCard();//渲染卡牌
  8. 	
  9. 	drawPlantMap();//渲染种植后的植物
  10.  
  11. 	drawPlantMove();//渲染拖动时的植物
  12.  
  13. 	drawsunshine();//渲染阳光
  14.  
  15. 	drawzm();//渲染僵尸
  16.  
  17. 	drawPea();//渲染豌豆
  18.  
  19. 	outsunshine();//显示左上角阳光数
  20.  
  21. 	EndBatchDraw();//结束双缓冲
  22. }

2.11收集阳光：collectsunshine()

  1. void collectsunshine(ExMessage* msg)//实现收集阳光
  2. {
  3. 	int width = imgsunshine[0].getwidth();//获取阳光球的宽
  4. 	int hight = imgsunshine[0].getheight();//获取阳光球的高
  5. 	for (int i = 0; i < ballMax; i++)
  6. 	{
  7. 		if (balls[i].used)//遍历每一个用过的阳光
  8. 		{
  9. 			//int x = balls[i].x;//此阳光球左上角的x坐标
  10. 			//int y = balls[i].y;//此阳光球左上角的y坐标
  11. 			int x = balls[i].pCur.x;
  12. 			int y = balls[i].pCur.y;
  13. 			if (msg->x > x && msg->x<x + width && msg->y>y && msg->y < y + hight)//判断鼠标位置与阳光球的位置
  14. 			{
  15. 				//选中范围近似为矩形
  16. 				//balls[i].used = false;//选中后消失
  17. 				balls[i].status = SUNSHINE_COLLECT;//收集状态
  18. 				PlaySound("res/sunshine.wav", NULL, SND_FILENAME | SND_ASYNC);
  19. 				//mciSendString("play res/sunshine.mp3", 0, 0, NULL);//音乐播放(有延迟)
  20.  
  21. 				//贝塞尔曲线法渲染阳光球飞跃路线
  22. 				balls[i].p1 = balls[i].pCur;//起点:被收集时的位置
  23. 				balls[i].p4 = vector2( 262,0 );//终点
  24. 				balls[i].t = 0;
  25. 				float distance = dis(balls[i].p1 - balls[i].p2);//两点之间的距离
  26. 				float off = 8;//每次移动的像素(可修改)
  27. 				balls[i].speed = 1.0 / (distance / off);//一次移动完成
  28. 				break;
  29.  
  30. 				//获取阳光球与目的地中心连线与水平方向的夹角
  31. 				//float destY = 0;
  32. 				//float destX = 262;//植物栏阳光收集位置的坐标
  33. 				//float angle = atan((y - destY) / (x - destX));//通过反正切函数获取夹角
  34. 				//balls[i].xoff = 40 * cos(angle);
  35. 				//balls[i].yoff = 40 * sin(angle);//4是指定的飞跃速度
  36. 			}
  37. 		}
  38. 	}
  39. }

2.12鼠标操作：userclick()

  1. void userclick()//实现鼠标相关操作
  2. {
  3. 	ExMessage msg;//结构体变量
  4. 	static int status = 0;//判断状态
  5. 	if (peekmessage(&msg))//判断msg的范围内是否有信息
  6. 	{
  7. 		if (msg.message == WM_LBUTTONDOWN)//鼠标左键按下
  8. 		{
  9. 			if (msg.x > 338 && msg.x < 338 + 65 * PLANT_COUNTS && msg.y < 96)//选择植物
  10. 			{
  11. 				int index = (msg.x - 338) / 65;//判断植物卡牌，这是下标
  12. 				status = 1;//表示鼠标左键已经按下
  13. 				//printf("%d\n", index);//测试
  14. 				curPLANT = index + 1;//选择植物
  15. 			}
  16. 			else //收集阳光
  17. 			{
  18. 				collectsunshine(&msg);
  19. 			}
  20. 		}
  21. 		else if (msg.message == WM_MOUSEMOVE && status == 1)//鼠标移动
  22. 		{
  23. 			curX = msg.x;//鼠标移动时图片的x轴位置
  24. 			curY = msg.y;//鼠标移动时图片的y轴位置
  25. 		}
  26. 		else if (msg.message == WM_LBUTTONUP)//鼠标左键抬起
  27. 		{
  28. 			if (msg.x > 144 && msg.y > 179 && msg.y < 489)//草坪的范围
  29. 			{
  30. 				int row = (msg.y - 179) / 102;//植物种植的行，102是行宽
  31. 				int col = (msg.x - 144) / 81;//植物种植的列,81是列宽
  32. 				//printf("%d,%d\n", row, col);//测试
  33. 				if (map[row][col].type == 0)//草坪只有空状态才能种植
  34. 				{
  35. 					map[row][col].type = curPLANT;//表示row行col列的植物类型为curPLANT
  36. 					map[row][col].frameindex = 0;
  37. 					map[row][col].shootTimer = 0;
  38. 					map[row][col].x = 144 + col * 81;
  39. 					map[row][col].y = 179 + row * 102 + 14;
  40. 				}
  41. 			}
  42. 			status = 0;
  43. 			curPLANT = 0;//鼠标左键抬起植物种下
  44. 		}
  45. 	}
  46. }

2.13创建阳光：creatsunshine()

  1. void creatsunshine()//选取阳光,阳光结构体成员的初始化
  2. {
  3. 	static int count = 0;
  4. 	static int fre = 200;
  5. 	count++;
  6. 	if (count >= fre)
  7. 	{
  8. 		fre = 100 + rand() % 200;//每200到399毫秒创建一个阳光
  9. 		count = 0;
  10. 		int i = 0;
  11. 		for (i = 0; i < 29 && balls[i].used; i++);//空循环查询可使用的阳光
  12. 		//used初始为0表示该阳光可以被使用，循环停止
  13. 		if (i >= 29)
  14. 			return;
  15. 		balls[i].used = true;//第i个阳光被使用
  16. 		balls[i].frameINDEX = 0;//动画帧
  17. 		balls[i].timer = 0;
  18. 		//balls[i].x = 260 + rand() % (900 - 260);//阳光球随机在场上刷新
  19. 		//balls[i].y = 60;//初始下落坐标
  20. 		//balls[i].destY = 200 + (rand() % 4 * 90);
  21. 		//balls[i].xoff = 0;
  22. 		//balls[i].yoff = 0;
  23. 		balls[i].status = SUNSHINE_DOWN;//下落状态
  24. 		balls[i].t = 0;
  25. 		balls[i].p1 = vector2( 260 + rand() % (900 - 148) ,60 );//起点
  26. 		balls[i].p4 = vector2( balls[i].p1.x,200 + (rand() % 4 * 90) );//终点
  27. 		int off = 2;
  28. 		float distance = balls[i].p4.y - balls[i].p1.y;
  29. 		balls[i].speed = 1.0 / (distance / off);
  30. 	}
  31. 	//向日葵生产阳光
  32. 	static int sunshinecount = 0;
  33. 	if (++sunshinecount > 2)
  34. 	{
  35. 		sunshinecount = 0;
  36. 		for (int i = 0; i < 3; i++)//遍历3行9列
  37. 		{
  38. 			for (int j = 0; j < 9; j++)
  39. 			{
  40. 				if (map[i][j].type == SUN_FLOWER + 1)
  41. 				{
  42. 					map[i][j].timer++;
  43. 					if (map[i][j].timer > 100)//生产阳光的时间间隔
  44. 					{
  45. 						map[i][j].timer = 0;//归零
  46. 						int k;//找到第k个可用阳光
  47. 						for (k = 0; k < ballMax && balls[k].used; k++);
  48. 						if (k >= ballMax)
  49. 							return;
  50. 						balls[k].used = true;
  51. 						balls[k].p1 = vector2(map[i][j].x, map[i][j].y);//起点
  52. 						int w = (100 + rand() % 50) * (rand() % 2 ? 1 : -1);//阳光掉落位置与向日葵的距离(可在左也可在右)
  53. 						balls[k].p4 = vector2(map[i][j].x + w, map[i][j].y + imgPLANT[SUN_FLOWER][0]->getheight() - imgsunshine[0].getheight());
  54. 						balls[k].p2 = vector2(balls[k].p1.x + w * 0.3, balls[k].p1.y - 100);
  55. 						balls[k].p3 = vector2(balls[k].p1.x + w * 0.7, balls[k].p1.y - 100);
  56. 						balls[k].status = SUNSHINE_PRODUCT;
  57. 						balls[k].speed = 0.05;
  58. 						balls[k].t = 0;
  59. 					}
  60. 				}
  61. 			}
  62. 		}
  63. 	}
  64. }

2.14更新阳光参数：updatesunshine()

  1. void updatesunshine()//更新阳光状态:使用——>未使用，动画帧再初始化
  2. {
  3. 	for (int i = 0; i < ballMax; i++)
  4. 	{
  5. 		if (balls[i].used)//如果阳光球处于使用状态，则更新
  6. 		{
  7. 			balls[i].frameINDEX = (balls[i].frameINDEX + 1) % 29;//防止动画帧越界
  8. 			if (balls[i].status == SUNSHINE_DOWN)//下落
  9. 			{
  10. 				struct sunshineBALL* sun = &balls[i];
  11. 				sun->t += sun->speed;
  12. 				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);//直线运动
  13. 				if (sun->t >= 1)//到达终点
  14. 				{
  15. 					sun->status = SUNSHINE_GROUND;//更改状态
  16. 					sun->timer = 0;
  17. 				}
  18. 			}
  19. 			else if (balls[i].status == SUNSHINE_GROUND)//落地
  20. 			{
  21. 				balls[i].timer++;
  22. 				if (balls[i].timer > 100)
  23. 				{
  24. 					balls[i].used = false;
  25. 					balls[i].timer = 0;
  26. 				}
  27. 			}
  28. 			else if (balls[i].status == SUNSHINE_COLLECT)//收集
  29. 			{
  30. 				struct sunshineBALL* sun = &balls[i];
  31. 				sun->t += sun->speed;
  32. 				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);//直线运动
  33. 				if (sun->t > 1)
  34. 				{
  35. 					sun->used = false;
  36. 					sunshine += 25;
  37. 				}
  38. 			}
  39. 			else if (balls[i].status == SUNSHINE_PRODUCT)//生产
  40. 			{
  41. 				struct sunshineBALL* sun = &balls[i];
  42. 				sun->t += sun->speed;
  43. 				//调用贝塞尔曲线函数
  44. 				sun->pCur = calcBezierPoint(sun->t, sun->p1, sun->p2, sun->p3, sun->p4);//曲线运动
  45. 				if (sun->t > 1)
  46. 				{
  47. 					sun->status = SUNSHINE_GROUND;
  48. 					sun->timer = 0;
  49. 				}
  50. 			}
  51. 			//if (balls[i].timer == 0)//下落过程中停留时间不变为0
  52. 			//{
  53. 			//	balls[i].y += 3;//阳光下落
  54. 			//}
  55. 			//if (balls[i].y >= balls[i].destY)
  56. 			//{
  57. 			//	balls[i].timer++;
  58. 			//	if (balls[i].timer > 100)//停留100帧后消失
  59. 			//	{
  60. 			//		balls[i].used = false;//更新阳光的使用状态
  61. 			//	}
  62. 			//}
  63. 		}
  64. 		//else if (balls[i].xoff)
  65. 		//{
  66. 		//	float destY = 0;
  67. 		//	float destX = 262;//植物栏阳光收集位置的坐标
  68. 		//	float angle = atan((balls[i].y - destY) / (balls[i].x - destX));//通过反正切函数获取夹角
  69. 		//	balls[i].xoff = 40 * cos(angle);
  70. 		//	balls[i].yoff = 40 * sin(angle);//4是指定的飞跃速度
  71. 		//	//每次飞跃时消除误差
  72.  
  73. 		//	balls[i].x -= balls[i].xoff;
  74. 		//	balls[i].y -= balls[i].yoff;
  75. 		//	if (balls[i].x < 262 || balls[i].y < 0)
  76. 		//	{
  77. 		//		balls[i].xoff = 0;
  78. 		//		balls[i].yoff = 0;//偏移量归零
  79. 		//		sunshine += 25;
  80. 		//		balls[i].used = false;//到达目的地后模型消失
  81. 		//	}
  82. 		//}
  83. 	}
  84. }

2.15创建僵尸：creatzomb()

  1. void creatzomb()//创建僵尸
  2. {
  3. 	if (zmCount1 >= 10)
  4. 		return;
  5. 	int i;
  6. 	int zmMax = sizeof(zms) / sizeof(zms[0]);//僵尸的数量
  7. 	static int zmcount = 0;
  8. 	static int zmfre = 40;
  9. 	zmcount++;
  10. 	if (zmcount >= zmfre)
  11. 	{
  12. 		zmfre = 100 + rand() % 100;
  13. 		zmcount = 0;
  14. 		for (i = 0; i < zmMax && zms[i].used; i++);//查询可用的僵尸
  15. 		if (i < zmMax)
  16. 		{
  17. 			memset(&zms[i], 0, sizeof(zms[i]));
  18. 			zms[i].used = true;//表示该僵尸已经用过
  19. 			zms[i].x = WIN_WIDTH;//僵尸的横坐标
  20. 			zms[i].zmrow = rand() % 3;
  21. 			zms[i].y = 173 + (zms[i].zmrow + 1) * 100;//行高近似为100
  22. 			zms[i].speed = 1;//初始速度
  23. 			zms[i].blood = 150;//10个豌豆
  24. 			zms[i].dead = false;
  25. 			zmCount1++;
  26. 		}
  27. 		else
  28. 		{
  29. 			printf("创建僵尸失败\n");
  30. 		}
  31. 	}
  32. }

2.16更新僵尸参数:updatezomb()

  1. void updatezomb()//更新僵尸的数据
  2. {
  3. 	int zmMax = sizeof(zms) / sizeof(zms[0]);//僵尸的数量
  4. 	static int count = 0;
  5. 	count++;
  6. 	if (count > 2)
  7. 	{
  8. 		count = 0;
  9. 		for (int i = 0; i < zmMax; i++)
  10. 		{
  11. 			if (zms[i].used)//被使用则更新
  12. 			{
  13. 				zms[i].x -= zms[i].speed;
  14. 				if (zms[i].x <= 28)
  15. 				{
  16. 					//printf("GAME OVER\n");
  17. 					//MessageBox(NULL, "over", "over", 0);//显示对话框
  18. 					//exit(0);//退出程序(待优化)
  19. 					gameStatus = FAIL;//游戏失败
  20. 				}
  21. 			}
  22. 		}
  23. 	}
  24.  
  25. 	static int count2 = 0;
  26. 	count2++;
  27. 	if (count2 > 8)
  28. 	{
  29. 		count2 = 0;
  30. 		for (int i = 0; i < zmMax; i++)//更新僵尸的图片帧
  31. 		{
  32. 			if (zms[i].used)
  33. 			{
  34. 				if (zms[i].dead)//判断僵尸死亡
  35. 				{
  36. 					zms[i].frameIndex++;
  37. 					if (zms[i].frameIndex >= 20)
  38. 					{
  39. 						zms[i].used = false;
  40. 						killcount++;
  41. 						if (killcount == ZM_MAX)
  42. 							gameStatus = WIN;//游戏胜利
  43. 					}
  44. 				}
  45. 				else if (zms[i].eating)
  46. 				{
  47. 					zms[i].frameIndex = (zms[i].frameIndex + 1) % 21;
  48. 				}
  49. 				else
  50. 				{
  51. 					zms[i].frameIndex = (zms[i].frameIndex + 1) % 22;//防止越界
  52. 				}
  53. 			}
  54. 		}
  55. 	}
  56. }

2.17发射豌豆：shoot()

  1. void shoot()//发射豌豆
  2. {
  3. 	static int count6 = 0;
  4. 	if (++count6 < 5)
  5. 		return;
  6. 	count6 = 0;
  7. 	int lines[3] = { 0 };//表示3行草坪
  8. 	int zmMax = sizeof(zms) / sizeof(zms[0]);//僵尸数量
  9. 	int peaMax = sizeof(bullets) / sizeof(bullets[0]);
  10. 	int dangerX = WIN_WIDTH;//- imgzombie[0].getwidth();//发射豌豆的距离(可调节)
  11. 	for (int i = 0; i < zmMax; i++)
  12. 	{
  13. 		if (zms[i].used && zms[i].x < dangerX)//僵尸出现在草坪上
  14. 		{
  15. 			lines[zms[i].zmrow] = 1;//僵尸出现的行表示为1
  16. 		}
  17. 	}
  18.  
  19. 	for (int i = 0; i < 3; i++)//遍历草坪
  20. 	{
  21. 		for (int j = 0; j < 9; j++)
  22. 		{
  23. 			if (map[i][j].type == PEA + 1 && lines[i])//植物类型是1代表豌豆射手，可以发射子弹
  24. 			{
  25. 				map[i][j].shootTimer++;
  26. 				if (map[i][j].shootTimer > 15)//调节豌豆发射的频率(可调节)
  27. 				{
  28. 					map[i][j].shootTimer = 0;
  29. 					int k;
  30. 					for (k = 0; k < peaMax && bullets[k].used; k++);//查找可用子弹
  31. 					if (k < peaMax)
  32. 					{
  33. 						bullets[k].used = true;
  34. 						bullets[k].pearow = i;//第i+1行
  35. 						bullets[k].speed = 3;
  36. 						bullets[k].blast = false;//最开始没有发生爆炸
  37. 						bullets[k].frameindex = 0;
  38.  
  39. 						int peax = 144 + j * 81;//植物种植的横坐标
  40. 						int peay = 179 + i * 102 + 14;//植物种植的纵坐标,位置可自行调整
  41. 						//发射位置是豌豆左上角坐标加上一个身位的嘴部,-10可自行调整,只是为了更接近原版
  42. 						bullets[k].x = peax + imgPLANT[map[i][j].type - 1][0]->getwidth() - 10;
  43. 						bullets[k].y = peay + 5;
  44. 					}
  45. 				}
  46. 			}
  47. 		}
  48. 	}
  49. }

2.18更新子弹参数：updatebullets()

  1. void updatebullets()//更新子弹的数据
  2. {
  3. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);//子弹数目
  4. 	for (int i = 0; i < bulletMax; i++)
  5. 	{
  6. 		if (bullets[i].used)
  7. 		{
  8. 			bullets[i].x += bullets[i].speed;//更新x坐标
  9. 			if (bullets[i].x > WIN_WIDTH)
  10. 			{
  11. 				bullets[i].used = false;//对超出边界的豌豆回收
  12. 			}
  13. 			if (bullets[i].blast)//子弹符合爆炸条件
  14. 			{
  15. 				bullets[i].frameindex++;
  16. 				if (bullets[i].frameindex >= 4)
  17. 				{
  18. 					bullets[i].used = false;//爆炸结束
  19. 				}
  20. 			}
  21. 		}
  22. 	}
  23. }

2.19豌豆->僵尸：checkbullet()

  1. void checkbullet()//豌豆->僵尸
  2. {
  3. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  4. 	int zombMax = sizeof(zms) / sizeof(zms[0]);
  5. 	for (int i = 0; i < bulletMax; i++)//遍历子弹
  6. 	{
  7. 		if (bullets[i].used == false || bullets[i].blast)
  8. 			continue;//如果子弹还未出现或已经爆炸则无需做爆炸检测
  9. 		for (int j = 0; j < zombMax; j++)//遍历僵尸
  10. 		{
  11. 			if (zms[j].used == false)
  12. 				continue;//僵尸还未出现无需检测
  13. 			int x1 = zms[j].x + 80;
  14. 			int x2 = zms[j].x + 110;//僵尸模型的范围
  15. 			int x = bullets[i].x;//子弹的坐标
  16. 			if (zms[j].dead == false && bullets[i].pearow == zms[j].zmrow && x > x1 && x < x2)//保证僵尸和子弹在同一行
  17. 			{
  18. 				//僵尸死亡不用做碰撞检测
  19. 				zms[j].blood -= 20;//扣20滴血
  20. 				bullets[i].blast = true;//子弹爆炸
  21. 				bullets[i].speed = 0;
  22. 				if (zms[j].blood <= 0)
  23. 				{
  24. 					zms[j].dead = true;//僵尸死亡
  25. 					zms[j].speed = 0;
  26. 					zms[j].frameIndex = 0;
  27. 				}
  28. 				break;
  29. 			}
  30. 		}
  31. 	}
  32. }

2.20僵尸->植物：checkeat()

  1. void checkeat()//僵尸->植物
  2. {
  3. 	int zmcount = sizeof(zms) / sizeof(zms[0]);
  4. 	for (int i = 0; i < zmcount; i++)//遍历僵尸
  5. 	{
  6. 		if (zms[i].dead)
  7. 			continue;
  8. 		int samerow = zms[i].zmrow;
  9. 		for (int k = 0; k < 9; k++)//只遍历相同行的9个格子
  10. 		{
  11. 			if (map[samerow][k].type == 0)//该格子没有种植植物
  12. 				continue;
  13. 			int plantX = 144 + k * 81;//植物图片左上角的坐标
  14. 			int x1 = plantX + 10;//植物的左边界
  15. 			int x2 = plantX + 60;//植物的右边界
  16. 			int x3 = zms[i].x + 80;//僵尸的左边界
  17. 			if (x3 > x1 && x3 < x2)
  18. 			{
  19. 				if (map[samerow][k].catched)//植物被捕获
  20. 				{
  21. 					map[samerow][k].deadtime ++;
  22. 					if (map[samerow][k].deadtime > 100)
  23. 					{
  24. 						map[samerow][k].deadtime = 0;
  25. 						map[samerow][k].type = 0;
  26. 						zms[i].eating = false;
  27. 						zms[i].frameIndex = 0;
  28. 						zms[i].speed = 2;
  29. 						map[samerow][k].catched = false;
  30. 					}
  31. 				}
  32. 				else
  33. 				{
  34. 					map[samerow][k].catched = true;
  35. 					map[samerow][k].deadtime = 0;//死亡倒计时
  36. 					zms[i].eating = true;//僵尸开吃
  37. 					zms[i].speed = 0;
  38. 					zms[i].frameIndex = 0;
  39. 				}
  40. 			}
  41. 		}
  42. 	}
  43. }

2.21碰撞检测：collisioncheck()

  1. void collisioncheck()//碰撞检测
  2. {
  3. 	checkbullet();//子弹碰撞
  4. 	checkeat();//僵尸捕获植物
  5. }

2.22更新植物参数：updatePlant()

  1. void updatePlant()//更新植物
  2. {
  3. 	static int count = 0;//频度控制
  4. 	if (++count > 2)
  5. 	{
  6. 		count = 0;
  7. 		for (int i = 0; i < 3; i++)
  8. 		{
  9. 			for (int j = 0; j < 9; j++)
  10. 			{
  11. 				if (map[i][j].type > 0)
  12. 				{
  13. 					map[i][j].frameindex++;//从第一张图片到最后一张图片
  14. 					//判断能否打开文件,打不开证明是最后一帧
  15. 					if (imgPLANT[map[i][j].type - 1][map[i][j].frameindex] == NULL)
  16. 					{
  17. 						map[i][j].frameindex = 0;//再初始化，从第一帧重新开始
  18. 					}
  19. 				}
  20. 			}
  21. 		}
  22. 	}
  23. }

2.23更改参数：updategame()

  1. void updateGame()//在每次循环后更改相应的参数
  2. {
  3. 	updatePlant();//更新植物
  4.  
  5. 	creatsunshine();//创建阳光
  6. 	updatesunshine();//更新阳光
  7.  
  8. 	creatzomb();//创建僵尸
  9. 	updatezomb();//更新僵尸
  10.  
  11. 	shoot();//发射豌豆
  12. 	updatebullets();//更新豌豆
  13.  
  14. 	collisioncheck();//碰撞检测
  15. }

2.24起始菜单：startUI()

  1. void startUI()//起始菜单
  2. {
  3. 	mciSendString("play res/bg.mp3", 0, 0, NULL);
  4. 	IMAGE imgBG, imgMenu1, imgMenu2;
  5. 	loadimage(&imgBG, "res/menu.png");
  6. 	loadimage(&imgMenu1, "res/menu1.png");//选中选项卡
  7. 	loadimage(&imgMenu2, "res/menu2.png");//未选中选项卡
  8. 	int flag = 0;//表示是否选中，选中则为1
  9. 	
  10. 	while (1)
  11. 	{
  12. 		BeginBatchDraw();
  13. 		putimage(0, 0, &imgBG);
  14. 		putimagePNG(474, 75, flag ? &imgMenu2 : &imgMenu1);
  15.  
  16. 		ExMessage msg;
  17. 		if (peekmessage(&msg))
  18. 		{
  19. 			if (msg.message == WM_LBUTTONDOWN &&
  20. 				msg.x > 474 && msg.x < 474 + 300 && msg.y>75 &&
  21. 				msg.y < 75 + 140)
  22. 			{
  23. 				flag = 1;//表示选中
  24. 			}
  25. 			else if (msg.message == WM_LBUTTONUP && flag)
  26. 			{
  27. 				EndBatchDraw();
  28. 				break;
  29. 			}
  30. 		}
  31. 		EndBatchDraw();
  32. 	}
  33. 	mciSendString("close res/bg.mp3", 0, 0, 0);
  34. }

2.25画面巡视：viewScene()

  1. void viewScene()//视角移动
  2. {
  3. 	int xMax = WIN_WIDTH - imgBg.getwidth();//窗口宽-图片宽(坐标为负数)
  4. 	vector2 point[9] = { {550,80},{530,160},{630,170},{530,200},{515,270},
  5. 		{565,370},{605,340},{705,280},{690,340} };//阅览僵尸站位(可修改)
  6.  
  7. 	int index[9];
  8. 	for (int j = 0; j < 9; j++)
  9. 	{
  10. 		index[j] = rand() % 11;//僵尸起始帧序号
  11. 	}
  12. 	
  13. 	int scenecount = 0;
  14.  
  15. 	//画面巡视
  16. 	for (int i = 0; i >= xMax; i -= 2)
  17. 	{
  18. 		BeginBatchDraw();
  19.  
  20. 		putimage(i, 0, &imgBg);
  21. 		scenecount++;
  22. 		for (int k = 0; k < 9; k++)//绘制僵尸站位
  23. 		{
  24. 			putimagePNG(point[k].x - xMax + i, point[k].y, &imgzmStand[index[k]]);
  25. 			if (scenecount >= 10)
  26. 				index[k] = (index[k] + 1) % 11;
  27. 		}
  28. 		if (scenecount >= 10)
  29. 			scenecount = 0;
  30.  
  31. 		EndBatchDraw();
  32. 		Sleep(5);
  33. 	}
  34.  
  35. 	//画面停留时间(可修改)
  36. 	for (int i = 0; i < 50; i++)
  37. 	{
  38. 		BeginBatchDraw();
  39. 		
  40. 		putimage(xMax, 0, &imgBg);
  41. 		for (int k = 0; k < 9; k++)
  42. 		{
  43. 			putimagePNG(point[k].x, point[k].y, &imgzmStand[index[k]]);
  44. 			index[k] = (index[k] + 1) % 11;
  45. 		}
  46.  
  47. 		EndBatchDraw();
  48. 		Sleep(30);
  49. 	}
  50.  
  51. 	//画面返回
  52. 	for (int k = xMax; k <= -112; k += 2)
  53. 	{
  54. 		BeginBatchDraw();
  55.  
  56. 		putimage(k, 0, &imgBg);
  57. 		scenecount++;
  58. 		for (int i = 0; i < 9; i++)
  59. 		{
  60. 			putimagePNG(point[i].x - xMax + k, point[i].y, &imgzmStand[index[i]]);
  61. 			if (scenecount >= 10)
  62. 				index[i] = (index[i] + 1) % 11;
  63. 		}
  64. 		if (scenecount >= 10)
  65. 			scenecount = 0;
  66.  
  67. 		EndBatchDraw();
  68. 		Sleep(5);
  69. 	}
  70. }

2.26工具栏下降:barsDown()

  1. void barsDown()//工具栏下降
  2. {
  3. 	int hight = imgBar.getheight();//获取工具栏的高
  4. 	for (int i = -hight; i <= 0; i++)
  5. 	{
  6. 		BeginBatchDraw();
  7.  
  8. 		putimage(-112, 0, &imgBg);
  9. 		putimagePNG(250, i, &imgBar);
  10.  
  11. 		for (int k = 0; k < PLANT_COUNTS; k++)
  12. 		{
  13. 			int x = 338 + k * 65;
  14. 			int y = 6 + i;
  15. 			putimage(x, y, &imgCard[k]);
  16. 		}
  17.  
  18. 		EndBatchDraw();
  19. 		Sleep(10);
  20. 	}
  21. }

2.27判定游戏结束：checkOver()

  1. bool checkOver()//游戏结束画面
  2. {
  3. 	bool ret = false;
  4. 	if (gameStatus == WIN)//游戏胜利
  5. 	{
  6. 		mciSendString("play res/win.mp3", 0, 0, NULL);
  7. 		Sleep(2000);
  8. 		mciSendString("close res/win.mp3", 0, 0, NULL);
  9. 		IMAGE* img7 = NULL;
  10. 		loadimage(img7, "res/gameWin.png");
  11. 		putimage(0, 0, img7);
  12. 		ret = true;
  13. 	}
  14. 	else if (gameStatus == FAIL)
  15. 	{
  16. 		mciSendString("play res/lose.mp3", 0, 0, NULL);
  17. 		Sleep(2000);
  18. 		mciSendString("close res/lose.mp3", 0, 0, NULL);
  19. 		IMAGE* img9 = NULL;
  20. 		loadimage(img9, "res/gameFail.png");
  21. 		putimage(0, 0, img9);
  22. 		ret = true;
  23. 	}
  24. 	return ret;
  25. }

2.28主函数

  1. int main()
  2. {
  3. 	gameInit();
  4. 	startUI();
  5. 	viewScene();
  6. 	barsDown();
  7. 	
  8. 	int timer = 0;//实现帧等待
  9. 	bool flag = true;
  10.  
  11. 	while (1)//循环退出条件:用户单击
  12. 	{
  13. 		userclick();
  14.  
  15. 		timer += getDelay();//运行时间间隔
  16. 		if (timer > 10)//运行时间间隔大于10毫秒
  17. 		{
  18. 			flag = true;
  19. 			timer = 0;//再初始化
  20. 		}
  21. 		if (flag)
  22. 		{
  23. 			flag = false;
  24. 			updateWindow();
  25. 			updateGame();
  26. 			if (checkOver())
  27. 				break;
  28. 		}
  29. 	}
  30. 	
  31. 	system("pause");//暂停
  32. 	return 0;
  33. }

3.头文件tools.h(工具文件)

  1. #pragma once
  2. #include <graphics.h>
  3.  
  4. void putimagePNG(int  picture_x, int picture_y, IMAGE* picture);
  5. int getDelay();

4.源文件tools.cpp(工具文件)

  1. #include "tools.h"
  2.  
  3. // 载入PNG图并去透明部分
  4. void _putimagePNG(int  picture_x, int picture_y, IMAGE* picture) //x为载入图片的X坐标，y为Y坐标
  5. {
  6. 	DWORD* dst = GetImageBuffer();    // GetImageBuffer()函数，用于获取绘图设备的显存指针，EASYX自带
  7. 	DWORD* draw = GetImageBuffer();
  8. 	DWORD* src = GetImageBuffer(picture); //获取picture的显存指针
  9. 	int picture_width = picture->getwidth(); //获取picture的宽度，EASYX自带
  10. 	int picture_height = picture->getheight(); //获取picture的高度，EASYX自带
  11. 	int graphWidth = getwidth();       //获取绘图区的宽度，EASYX自带
  12. 	int graphHeight = getheight();     //获取绘图区的高度，EASYX自带
  13. 	int dstX = 0;    //在显存里像素的角标
  14.  
  15. 	// 实现透明贴图 公式： Cp=αp*FP+(1-αp)*BP ， 贝叶斯定理来进行点颜色的概率计算
  16. 	for (int iy = 0; iy < picture_height; iy++)
  17. 	{
  18. 		for (int ix = 0; ix < picture_width; ix++)
  19. 		{
  20. 			int srcX = ix + iy * picture_width; //在显存里像素的角标
  21. 			int sa = ((src[srcX] & 0xff000000) >> 24); //0xAArrggbb;AA是透明度
  22. 			int sr = ((src[srcX] & 0xff0000) >> 16); //获取RGB里的R
  23. 			int sg = ((src[srcX] & 0xff00) >> 8);   //G
  24. 			int sb = src[srcX] & 0xff;              //B
  25. 			if (ix >= 0 && ix <= graphWidth && iy >= 0 && iy <= graphHeight && dstX <= graphWidth * graphHeight)
  26. 			{
  27. 				dstX = (ix + picture_x) + (iy + picture_y) * graphWidth; //在显存里像素的角标
  28. 				int dr = ((dst[dstX] & 0xff0000) >> 16);
  29. 				int dg = ((dst[dstX] & 0xff00) >> 8);
  30. 				int db = dst[dstX] & 0xff;
  31. 				draw[dstX] = ((sr * sa / 255 + dr * (255 - sa) / 255) << 16)
  32. 					| ((sg * sa / 255 + dg * (255 - sa) / 255) << 8)
  33. 					| (sb * sa / 255 + db * (255 - sa) / 255);
  34. 			}
  35. 		}
  36. 	}
  37. }
  38.  
  39. // 适用于 y <0 以及x<0的任何情况
  40. void putimagePNG(int x, int y, IMAGE* picture) {
  41.  
  42. 	IMAGE imgTmp, imgTmp2, imgTmp3;
  43. 	int winWidth = getwidth();
  44. 	int winHeight = getheight();
  45. 	if (y < 0) {
  46. 		SetWorkingImage(picture);
  47. 		getimage(&imgTmp, 0, -y,
  48. 			picture->getwidth(), picture->getheight() + y);
  49. 		SetWorkingImage();
  50. 		y = 0;
  51. 		picture = &imgTmp;
  52. 	}
  53. 	else if (y >= getheight() || x >= getwidth()) {
  54. 		return;
  55. 	}
  56. 	else if (y + picture->getheight() > winHeight) {
  57. 		SetWorkingImage(picture);
  58. 		getimage(&imgTmp, x, y, picture->getwidth(), winHeight - y);
  59. 		SetWorkingImage();
  60. 		picture = &imgTmp;
  61. 	}
  62.  
  63. 	if (x < 0) {
  64. 		SetWorkingImage(picture);
  65. 		getimage(&imgTmp2, -x, 0, picture->getwidth() + x, picture->getheight());
  66. 		SetWorkingImage();
  67. 		x = 0;
  68. 		picture = &imgTmp2;
  69. 	}
  70.  
  71. 	if (x > winWidth - picture->getwidth()) {
  72. 		SetWorkingImage(picture);
  73. 		getimage(&imgTmp3, 0, 0, winWidth - x, picture->getheight());
  74. 		SetWorkingImage();
  75. 		picture = &imgTmp3;
  76. 	}
  77.  
  78.  
  79. 	_putimagePNG(x, y, picture);
  80. }
  81.  
  82. int getDelay() {//时间差函数
  83. 	static unsigned long long lastTime = 0;
  84. 	unsigned long long currentTime = GetTickCount();//获取游戏开始到现在的时间
  85. 	if (lastTime == 0) {
  86. 		lastTime = currentTime;
  87. 		return 0;
  88. 	}
  89. 	else {
  90. 		int ret = currentTime - lastTime;
  91. 		lastTime = currentTime;
  92. 		return ret;//返回此次调用与上次调用的时间差
  93. 	}
  94. }

5.源文件vector2.cpp(工具文件:实现贝塞尔曲线)

  1. //头文件要求
  2. #include <cmath>
  3. #include "vector2.h"
  4.  
  5. //加法
  6. vector2 operator +(vector2 x, vector2 y) { 
  7. 	return vector2(x.x + y.x, x.y + y.y ); 
  8. }
  9.  
  10. //减法
  11. vector2 operator -(vector2 x, vector2 y) {
  12. 	return vector2(x.x - y.x, x.y - y.y);
  13. }
  14.  
  15. // 乘法
  16. vector2 operator *(vector2 x, vector2 y) {
  17. 	return vector2(x.x * y.x - x.y * y.y, x.y * y.x + x.x * y.y);
  18. }
  19.  
  20. // 乘法
  21. vector2 operator *(vector2 y, float x) {
  22. 	return vector2(x*y.x, x*y.y);
  23. }
  24.  
  25. vector2 operator *(float x, vector2 y) {
  26. 	return vector2(x * y.x, x * y.y);
  27. }
  28.  
  29. //叉积
  30. long long cross(vector2 x, vector2 y) { return x.y * y.x - x.x * y.y; }
  31.  
  32. //数量积 点积
  33. long long dot(vector2 x, vector2 y) { return x.x * y.x + x.y * y.y; }
  34.  
  35. //四舍五入除法
  36. long long dv(long long a, long long b) {//注意重名！！！ 
  37. 	return b < 0 ? dv(-a, -b)
  38. 		: (a < 0 ? -dv(-a, b)
  39. 			: (a + b / 2) / b);
  40. }
  41.  
  42. //模长平方
  43. long long len(vector2 x) { return x.x * x.x + x.y * x.y; }
  44.  
  45. //模长
  46. long long dis(vector2 x) { return sqrt(x.x * x.x + x.y * x.y); }
  47.  
  48. //向量除法
  49. vector2 operator /(vector2 x, vector2 y) {
  50. 	long long l = len(y);
  51. 	return vector2(dv(dot(x, y), l), dv(cross(x, y), l));
  52. }
  53.  
  54. //向量膜
  55. vector2 operator %(vector2 x, vector2 y) { return x - ((x / y) * y); }
  56.  
  57. //向量GCD 
  58. vector2 gcd(vector2 x, vector2 y) { return len(y) ? gcd(y, x % y) : x; }
  59.  
  60.  
  61. vector2 calcBezierPoint(float t, vector2 p0, vector2 p1, vector2 p2, vector2 p3) {
  62. 	float u = 1 - t;
  63. 	float tt = t * t;
  64. 	float uu = u * u;
  65. 	float uuu = uu * u;
  66. 	float ttt = tt * t;
  67.  
  68. 	vector2 p = uuu * p0;
  69. 	p = p + 3 * uu * t * p1;
  70. 	p = p + 3 * u * tt * p2;
  71. 	p = p + ttt * p3;
  72.  
  73. 	return p;
  74. }

6.头文件vector2.h(工具文件:实现贝塞尔曲线)

  1. #pragma once
  2.  
  3. //头文件要求
  4. #include <cmath>
  5.  
  6. struct vector2 {
  7. 	vector2(int _x=0, int _y=0) :x(_x), y(_y) {}
  8. 	vector2(int* data) :x(data[0]), y(data[1]){}
  9. 	long long x, y;
  10. };
  11.  
  12. //加法
  13. vector2 operator +(vector2 x, vector2 y);
  14.  
  15. //减法
  16. vector2 operator -(vector2 x, vector2 y);
  17.  
  18. // 乘法
  19. vector2 operator *(vector2 x, vector2 y);
  20. vector2 operator *(vector2, float);
  21. vector2 operator *(float, vector2);
  22.  
  23. //叉积
  24. long long cross(vector2 x, vector2 y);
  25.  
  26. //数量积 点积
  27. long long dot(vector2 x, vector2 y);
  28.  
  29. //四舍五入除法
  30. long long dv(long long a, long long b);
  31.  
  32.  
  33. //模长平方
  34. long long len(vector2 x);
  35.  
  36. //模长
  37. long long dis(vector2 x);
  38.  
  39. //向量除法
  40. vector2 operator /(vector2 x, vector2 y);
  41.  
  42. //向量膜
  43. vector2 operator %(vector2 x, vector2 y);
  44.  
  45. //向量GCD 
  46. vector2 gcd(vector2 x, vector2 y);
  47.  
  48. //贝塞尔曲线
  49. vector2 calcBezierPoint(float t, vector2 p0, vector2 p1, vector2 p2, vector2 p3);

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

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

  

闽ICP备14008679号