devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言游戏实战（12）：植物大战僵尸（坤版）_c语言项目实训-火爆辣椒

作者：我家自动化 | 2024-05-26 11:55:24

赞

踩

c语言项目实训-火爆辣椒

植物大战僵尸

前言：

本游戏使用C语言和easyx图形库编写，通过这个项目我们可以深度的掌握C语言的各种语言特性和高级开发技巧，以及锻炼我们独立的项目开发能力，

在开始编写代码之前，我们需要先了解一下游戏的基本规则和功能：

游戏界面：游戏界面是一个矩形区域，玩家可以在区域内进行植物的放置和铲除等操作。

僵尸：僵尸会从游戏界面的右侧向左测移动，靠近植物后会停下来吃植物。

植物：不同的植物有不同的功能，在这里我们可以将植物分为三大类：

1. 生产型植物（如太阳花）：这种植物的特点是在一定的时间生产出太阳，以增加太阳的产量。

2.发射型植物（如豌豆射手）：这种植物的特点是发射相应类型的子弹，对僵尸产生伤害和特定的效果。

3. 爆炸性植物（火爆辣椒）：这种植物的特点是对一定区域的所有僵尸产生高额伤害。（一次性植物）

接下来，我们将通过以下几个步骤来实现这个游戏：

初始化游戏界面。

实现僵尸的创建、僵尸的更新、僵尸吃植物的检测。

实现的植物的放置。

实现植物的功能：

对于生产型植物我们需要写出阳光的生产，以及阳光的收集操作。

对于发射型植物我们需要判断植物是否发射子弹，发射子弹后还需更新子弹、检测子弹与僵尸的碰撞。

对于爆炸型植物，我们需要判断僵尸是否在爆炸范围内，然后杀死在爆炸范围内的僵尸。

1. 初始化游戏界面

我们需要先将游戏地图、卡牌和卡牌槽绘制出来。可以利用windows自带的画图工具测出游戏地图的位置，从而将这些卡牌和卡牌槽放置到合适的位置。

  1. //地图
  2. putimage(-150, 0, &img);
  3. //卡牌槽
  4. putimagePNG(80, -10, &imgBar);	
  5. //植物卡牌
  6. 	for (int i = 0; i < PLANT_COUNT + 2; i++)
  7. 	{
  8. 		if(i==PLANT_COUNT)
  9. 			putimagePNG(163 + i * 65 + 8, -5, &imgCards[i]);
  10. 		else
  11. 			putimagePNG(163 + i * 65, 0, &imgCards[i]);
  12. 	}

2.  放置植物

因为需要在这个9*5的草地区域内放置植物，所以我们得计算出每个草方块的位置。我利用画图软件测出每个草方块大约是长81、宽100个像素点。 第一个草方块距离游戏窗口大约101个像素点。

这样就可以得出每个草方块的位置：256 - 150 + col * 81;100 + row * 100 - 15； 

每个植物都有相似的特性，所以我们需要写一个放置植物信息的结构体。然后创建一个5*9的结构体数组，用来表示每个草方块上的植物。

  1. enum {
  2. 	WAN_DOU, TAI_YANG, LA_JIAO, KUN_KUN, JIAN_GUO,
  3. 	HAN_BING_WAN_DOU, YING_TAO, SAN_TOU_WAN_DOU, PLANT_COUNT
  4. };
  5. struct plant
  6. {
  7. 	int type;//植物类型
  8. 	int frameIndex;//植物动作帧
  9. 	//bool catched;//是否被吃
  10. 	int blood;//血量
  11.  
  12. 	int shootTime;//植物子弹的射速
  13.  
  14. 	int timer;//阳光生产的时间
  15. 	int x, y;//植物坐标
  16. 	bool shoot;//判断植物是否处于发射状态
  17. };
  18. struct plant map[5][9];

 在 Windows 编程中，我们可以利用下面的变量获取鼠标信息。

  1. ExMessage msg;
  2. msg.message
  1. ExMessage msg;
  2. static int status = 0;
  3. if (peekmessage(&msg))//判断有没有消息
  4. {
  5. 	if (msg.message == WM_LBUTTONDOWN)//左键按下
  6. 	{
  7.         //鼠标是否在卡牌的位置按下
  8. 		if (msg.x > 163 && msg.x < 163 + 65 * (PLANT_COUNT+2) && msg.y < 96)
  9. 		{
  10. 			//mciSendString("play res/audio/bleep.mp3 alias BGM4", NULL, NULL, NULL);
  11. 			PlaySound("res/audio/bleep.wav", NULL, SND_FILENAME | SND_ASYNC);
  12. 			//PlaySound("res/sunshine.wav", NULL, SND_FILENAME | SND_ASYNC);
  13.  
  14. 			int index = (msg.x - 163) / 65;
  15. 			//坤坤
  16. 		/*	if (index + 1 == KUN_KUN && sunshine >= 100)
  17. 			{
  18. 				curPlant = index + 1;
  19. 				status = 1;
  20. 				curX = msg.x;
  21. 				curY = msg.y;
  22. 				sunshine -= 100;
  23. 			}*/
  24. 			curPlant = index + 1;
  25. 			status = 1;
  26. 			curX = msg.x;
  27. 			curY = msg.y;
  28. 		}
  29. 	}
  30. 	else if (msg.message == WM_MOUSEMOVE && status == 1)//鼠标移动
  31. 	{
  32. 		curX = msg.x;
  33. 		curY = msg.y;
  34. 	}
  35. 	else if (msg.message == WM_LBUTTONUP)//鼠标放下
  36. 	{
  37. 		if (msg.x > 256 - 150 && msg.x < Wide - 70 && msg.y > 100 && msg.y < 590)
  38. 		{
  39. 			int row = (msg.y - 100) / 102;
  40. 			int col = (msg.x - 256 + 150 ) / 81;
  41. 			
  42. 			
  43. 			if (map[row][col].type == 0 && curPlant != PLANT_COUNT + 1 && curPlant != PLANT_COUNT + 2)
  44. 			{
  45. 				//printf("%d\n", map[col][row].type);
  46. 				map[row][col].type = curPlant;
  47. 				map[row][col].frameIndex = 0;
  48.  
  49. 				if(curPlant!=0)
  50. 					PlaySound("res/audio/coffee.wav", NULL, SND_FILENAME | SND_ASYNC);
  51.  
  52. 				if (curPlant == 5)
  53. 					map[row][col].blood = KUNKUN_BLOOD * 50;
  54. 				else
  55. 					map[row][col].blood = KUNKUN_BLOOD;
  56.  
  57. 				map[row][col].shootTime = 0;
  58. 				map[row][col].shoot = false;
  59.  
  60. 				map[row][col].x = 256 - 150 + col * 81;
  61. 				map[row][col].y = 100 + row * 100 - 15;
  62. 				
  63. 			}
  64. 			else if (map[row][col].type != 0 && curPlant == PLANT_COUNT + 1)
  65. 			{
  66. 				PlaySound("res/audio/coffee.wav", NULL, SND_FILENAME | SND_ASYNC);
  67.  
  68. 				map[row][col].type = 0;
  69. 				map[row][col].blood = 0;
  70. 				
  71. 			}
  72. 		}
  73. 	}
  74. 	else if (msg.message == WM_RBUTTONDOWN)//鼠标右键
  75. 	{
  76. 		curPlant = 0;
  77. 		status = 0;
  78. 	}

3. 僵尸

 3.1 创建僵尸

僵尸也是和植物一样需要创建一个结构体存放信息。然后创建一个结构体数组，作为一个僵尸池，当需要创建一个僵尸时，我们就从这个池里取一个未被使用的僵尸。

  1. struct zm
  2. {
  3. 	int x, y;//僵尸的坐标
  4. 	int frameIndex;//僵尸动作帧
  5. 	bool used;//僵尸是否被使用
  6. 	int speed;//僵尸每一次移动的位移
  7. 	int row;//僵尸所在行
  8. 	int blood;//僵尸血量
  9. 	bool dead;//僵尸是否死亡
  10. 	bool eating;//僵尸是否在吃植物
  11. 	bool boom;//僵尸是否被炸死
  12. 	int zmSpeed;//僵尸的移动快慢
  13. };
  14. struct zm zms[ZM_MAX];
  1. //找一个可用的僵尸
  2. int i;
  3. for (i = 0; i < zmMax && zms[i].used && zms[i].dead == false; i++);

到一定的时间就创建一个僵尸。

  1.  
  2. void createZM()
  3. {
  4. 	if (zmCount >= zmCount_max)
  5. 		return;
  6.  
  7. 	static int zmFre = 500;
  8. 	static int count = 0;
  9. 	
  10.     //控制僵尸的生成快慢
  11. 	count++;
  12. 	if (count > zmFre)
  13. 	{
  14. 		count = 0;
  15. 		zmFre = 200;
  16. 		int i = 0;
  17. 		int zmMax = sizeof(zms) / sizeof(zms[0]);
  18. 		for (i = 0; i < zmMax && zms[i].used && zms[i].dead == false; i++);
  19. 		if (i < zmMax)
  20. 		{
  21. 			memset(&zms[i], 0, sizeof(zms[i]));
  22. 			zms[i].used = true;
  23. 			zms[i].speed = 2;
  24. 			zms[i].row = rand() % 5;
  25. 			zms[i].y = 100 + (zms[i].row) * 100 + 70;
  26. 			zms[i].x = Wide;
  27. 			zms[i].blood = ORDINARY_ZM_BLOOD;
  28. 			zms[i].dead = false;
  29. 			zms[i].boom = false;
  30. 			zms[i].zmSpeed = 4;
  31. 			zmCount++;
  32. 		}
  33. 	}
  34. }

3. 2 检测僵尸对植物的伤害检测

僵尸靠近植物就将僵尸置为吃东西的状态，减植物的血量，当植物的血量小于等于0时，就去除植物。

  1. void checkZM2Zhiwu()
  2. {
  3. 	char name[64];
  4. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  5. 	for (int i = 0; i < zCount; i++)
  6. 	{
  7. 		//killCount = 0;
  8. 		if (zms[i].dead)continue;
  9.  
  10. 		//zms[i].chomptime = 0;
  11. 		int row = zms[i].row;
  12. 		for (int j = 0; j < 9; j++)
  13. 		{
  14. 			//if (map[row][j].type == 0)continue;
  15. 			
  16. 			//
  17. 			int zhiwuX = 101 + j * 81;
  18. 			int x1 = zhiwuX;
  19. 			int x2 = zhiwuX + 81;
  20. 			int x3 = zms[i].x + 100;
  21. 			if (x3 >= x1 && x3 <= x2)
  22. 			{
  23. 				if (map[row][j].blood <= 0 || (map[row][j].type == 0 && zms[i].eating != false))
  24. 				{
  25. 					map[row][j].blood = 0;
  26. 					map[row][j].type = 0;
  27. 					zms[i].eating = false;
  28. 					//zms[i].frameIndex = 0;
  29. 					zms[i].speed = 3;
  30. 				}
  31. 				else if (map[row][j].type != 0)
  32. 				{
  33. 					//mciSendString("play ZM_BGM repeat", NULL, NULL, NULL);
  34. 					//mciSendString("play name repeat", NULL, 0, NULL);
  35. 					zms[i].eating = true;
  36. 					zms[i].speed = 0;
  37. 					if (map[row][j].type != 3 && map[row][j].type != 7)
  38. 						map[row][j].blood--;
  39. 					//zms[i].frameIndex = 0;
  40. 				}
  41.  
  42. 			}
  43. 			else if (x3 > 830)
  44. 			{
  45. 				zms[i].eating = false;
  46. 				zms[i].speed = 3;
  47. 			}
  48. 		}
  49. 	}
  50. }

4. 植物子弹

4.1 发射子弹

当僵尸出现在游戏界面时，与该僵尸同一行的发射性植物就发射出子弹。

同样需要创建一个结构体存放子弹的信息，然后创建一个子弹池。

  1. //子弹
  2. struct bullet
  3. {
  4. 	double x, y;//子弹的坐标
  5. 	bool used;//子弹是否被使用
  6. 	int row;//子弹所在行
  7. 	int speed;//子弹速度
  8. 	bool blast;//是否发生爆炸
  9. 	int frameIndex;//帧序号
  10. };
  11. //坤坤
  12. struct bullet bullets[1000];

 以坤坤为例：

  1. void shoot()
  2. {
  3. 	int lines[5] = { 0 };
  4. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  5. 	
  6. 	int zmCount = sizeof(zms) / sizeof(zms[0]);
  7. 	int dangerX = Wide - 80;
  8. 	for (int i = 0; i < zmCount; i++)
  9. 	{
  10. 		if (zms[i].dead == false && zms[i].x < dangerX && zms[i].x>100)
  11. 		{
  12. 			lines[zms[i].row] = 1;
  13. 		}
  14. 	}
  15.  
  16. 	for (int i = 0; i < 5; i++)
  17. 	{
  18. 		for (int j = 0; j < 9; j++)
  19. 		{
  20. 			//坤坤
  21. 			if (map[i][j].type == KUN_KUN + 1 && lines[i])
  22. 			{
  23. 				map[i][j].shootTime++;
  24. 				if (map[i][j].shootTime > 20)
  25. 				{
  26. 					map[i][j].shootTime = 0;
  27.                     //子弹池
  28. 					int k;
  29. 					for (k = 0; k < bulletMax && bullets[k].used; k++);
  30. 					if (k < bulletMax)
  31. 					{
  32. 						map[i][j].frameIndex = 3;
  33. 						bullets[k].used = true;
  34. 						bullets[k].row = i;
  35. 						bullets[k].speed = 10;
  36.  
  37. 						bullets[k].blast = false;
  38. 						bullets[k].frameIndex = 0;
  39.  
  40. 						int zwX = 256 - 150 + j * 81;
  41. 						int zwY = 100 + i * 100 - 15;
  42. 						bullets[k].x = zwX + imgPlant[map[i][j].type - 1][0]->getwidth() - 10;
  43. 						bullets[k].y = zwY + 5;
  44. 					}
  45. 				}
  46. 			}
  47.  
  48. 			
  49. 		}
  50. 	}
  51. }

4. 2  更新子弹

不断的改变加子弹的横坐标，当子弹出游戏界面时，子弹就被置为未被使用。

以坤坤为例：

  1. void updateBullets_kunkun()
  2. {
  3. 	int countMax = sizeof(bullets) / sizeof(bullets[0]);
  4. 	for (int i = 0; i < countMax; i++)
  5. 	{
  6. 		if (bullets[i].used)
  7. 		{
  8. 			bullets[i].x += bullets[i].speed;
  9. 			
  10. 			if (bullets[i].x > Wide)
  11. 			{
  12. 				bullets[i].used = false;
  13. 			}
  14.  
  15. 		}
  16. 	}
  17. }

 4.3 检测子弹对僵尸的伤害

当子弹靠近僵尸时减去僵尸的一定量血量，然后对僵尸造成一定的效果（例如，坤坤子弹的效果是击退僵尸，那么我们只需要更改僵尸的横坐标即可。），最后将子弹置为未被使用。

以坤坤为例：

  1. void checkBullet2Zm_kunkun()
  2. {
  3. 	int bCount = sizeof(bullets) / sizeof(bullets[0]);
  4. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  5. 	for (int i = 0; i < bCount; i++)
  6. 	{
  7. 		{
  8. 			for (int j = 0; j < zCount; j++)
  9. 			{
  10. 				if (zms[j].used == false)continue;
  11. 				int x1 = zms[j].x + 80;
  12. 				int x2 = zms[j].x + 110;
  13. 				int x = bullets[i].x;
  14. 				if (zms[j].dead == false &&
  15. 					bullets[i].row == zms[j].row && x > x1 && x < x2 && bullets[i].used) {
  16. 					zms[j].blood -= 20;
  17. 					zms[j].x += 1;
  18. 					bullets[i].blast = true;
  19. 					bullets[i].speed = 0;
  20. 					//bullets[i].x = 0;
  21.  
  22. 					if (zms[j].blood <= 0)
  23. 					{
  24. 						killCount++;
  25.  
  26. 						zms[j].dead = true;
  27. 						zms[j].speed = 0;
  28. 						zms[j].frameIndex = 0;
  29. 					}
  30. 					break;
  31. 				}
  32. 			}
  33. 		}
  34. 	}
  35. }

 5. 爆炸性植物

爆炸性植物是一次性的，当植物的动作帧执行完最后一帧后植物就置为死亡，在爆炸范围内的僵尸也死亡。

以火爆辣椒为例：

  1. void checkBoom2Zm()
  2. {
  3. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  4.  
  5. 	for (int i = 0; i < 5; i++)
  6. 	{
  7. 		for (int j = 0; j < 9; j++)
  8. 		{
  9. 			//火爆辣椒
  10. 			else if (map[i][j].type == LA_JIAO + 1)
  11. 			{
  12. 				if (map[i][j].frameIndex > 7)
  13. 				{
  14. 					for (int k = 0; k < zCount; k++)
  15. 					{
  16. 						if (zms[k].used == false)continue;
  17.  
  18. 						if (zms[k].row == i && zms[k].x < Wide - 80 - 70 && zms[k].dead == false)
  19. 						{
  20. 							killCount++;
  21.  
  22. 							zms[k].boom = true;
  23. 							zms[k].dead = true;
  24. 							zms[k].speed = 0;
  25. 							zms[k].frameIndex = 0;
  26. 							zms[k].blood = 0;
  27. 						}
  28. 					}
  29. 					if (map[i][j].frameIndex > 14)
  30. 					{
  31. 						map[i][j].type = 0;
  32. 						map[i][j].frameIndex = 0;
  33. 					}
  34. 				}
  35. 			}
  36. 		}
  37. 	}
  38. }

6. 小推车

 创建存放小车信息的结构体数组，小推车一条路一辆共5辆，所以我们只需写一个大小为5的结构体数组即可。

  1. //小推车
  2. struct car
  3. {
  4. 	bool move;//是否处于移动状态
  5. 	int x, y;//位置
  6. 	bool used;//是否被使用
  7. };
  8. struct car cars[5];

放置小推车 

  1. 	for (int i = 0; i < 5; i++)
  2. 	{
  3. 		cars[i].x = 50;
  4. 		cars[i].y = 100 + i * 100 - 15;
  5. 		cars[i].used = true;
  6. 		cars[i].move = false;
  7. 	}

检测小推车对小车的伤害 

当僵尸的横坐标小于等于小推车最左端的坐标时，小车置为移动状态，处于小推车左边的僵尸死亡。

  1. void checkcars2Zm()
  2. {
  3. 	for (int i = 0; i < 5; i++)
  4. 	{
  5. 		int carsX = cars[i].x + 70;
  6. 		for (int j = 0; j < ZM_MAX; j++)
  7. 		{
  8. 			if (zms[j].used && zms[j].dead == false && zms[j].row == i)
  9. 			{
  10. 				int zmX = zms[j].x + 80;
  11. 				if (carsX > zmX && cars[i].used)
  12. 				{
  13. 					if (cars[i].move == false)
  14. 						cars[i].move = true;
  15. 					else
  16. 					{
  17. 						killCount++;
  18. 						zms[j].dead = true;
  19. 						zms[j].speed = 0;
  20. 						zms[j].frameIndex = 0;
  21. 					}
  22. 				}
  23. 			}
  24. 		}
  25. 	}
  26. }

更新小推车的位置

当小车被置为移动时，小推车开始移动。

  1. void updatecar()
  2. {
  3. 	for (int i = 0; i < 5; i++)
  4. 	{
  5. 		if (cars[i].move)
  6. 		{
  7. 			cars[i].x += 20;
  8. 		}
  9. 		if (cars[i].x > Wide)
  10. 		{
  11. 			cars[i].move = false;
  12. 			cars[i].used = false;
  13. 		}
  14. 	}
  15. }

源码：

test.cpp文件： 

  1. #include"game.h"
  2.  
  3. //判断文件是否存在
  4. bool fileExist(const char* name)
  5. {
  6. 	FILE* pf = fopen(name, "r");
  7. 	if (pf == NULL)
  8. 	{
  9. 		return false;
  10. 	}
  11. 	else
  12. 	{
  13. 		fclose(pf);
  14. 		return true;
  15. 	}
  16. }
  17.  
  18. //初始化豌豆子弹的帧图片数组
  19. void bulletsInit()
  20. {
  21. 	//坤坤篮球
  22. 	loadimage(&imgBulletNormal, "res/bullets/basketball.png", 40, 40);
  23. 	memset(bullets, 0, sizeof(bullets));
  24. 	//初始化豌豆子弹的帧图片数组
  25. 	loadimage(&imgBallBlast[3], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png");
  26. 	for (int i = 0; i < 3; i++)
  27. 	{
  28. 		float k = (i + 1) * 0.2;
  29. 		loadimage(&imgBallBlast[i], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png",
  30. 			imgBallBlast[3].getwidth() * k,
  31. 			imgBallBlast[3].getheight() * k, true);
  32. 	}
  33. 	//豌豆子弹
  34. 	loadimage(&imgBulletNormal_wandou, "res/bullets/bullet_normal.png");
  35. 	memset(bullets_wandou, 0, sizeof(bullets_wandou));
  36. 	//初始化豌豆子弹的帧图片数组
  37. 	loadimage(&imgBallBlast_wandou[3], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png");
  38. 	for (int i = 0; i < 3; i++)
  39. 	{
  40. 		float k = (i + 1) * 0.2;
  41. 		loadimage(&imgBallBlast_wandou[i], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png",
  42. 			imgBallBlast_wandou[3].getwidth() * k,
  43. 			imgBallBlast_wandou[3].getheight() * k, true);
  44. 	}
  45. 	//寒冰豌豆子弹
  46. 	loadimage(&imgBulletNormal_hanbing, "res/bullets/PeaIce/PeaIce_0.png");
  47. 	memset(bullets_hanbing, 0, sizeof(bullets_hanbing));
  48. 	//初始化豌豆子弹的帧图片数组
  49. 	loadimage(&imgBallBlast_hanbing[3], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png");
  50. 	for (int i = 0; i < 3; i++)
  51. 	{
  52. 		float k = (i + 1) * 0.2;
  53. 		loadimage(&imgBallBlast_hanbing[i], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png",
  54. 			imgBallBlast_hanbing[3].getwidth() * k,
  55. 			imgBallBlast_hanbing[3].getheight() * k, true);
  56. 	}
  57. 	//三头豌豆子弹
  58. 	loadimage(&imgBulletNormal_santou, "res/bullets/bullet_normal.png");
  59. 	memset(bullets_santou, 0, sizeof(bullets_santou));
  60. 	//初始化豌豆子弹的帧图片数组
  61. 	loadimage(&imgBallBlast_santou[3], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png");
  62. 	for (int i = 0; i < 3; i++)
  63. 	{
  64. 		float k = (i + 1) * 0.2;
  65. 		loadimage(&imgBallBlast_santou[i], "res/bullets/PeaNormalExplode/PeaNormalExplode_0.png",
  66. 			imgBallBlast_santou[3].getwidth() * k,
  67. 			imgBallBlast_santou[3].getheight() * k, true);
  68. 	}
  69. }
  70.  
  71. void gameInit()
  72. {
  73. 	char name[64];
  74. 	//音效
  75. 	mciSendString("open res/bg.mp3 alias BGM", NULL, NULL, NULL);
  76. 	mciSendString("open res/audio/UraniwaNi.mp3 alias BGM2", NULL, NULL, NULL);
  77. 	mciSendString("open res/audio/WateryGraves.mp3 alias BGM3", NULL, NULL, NULL);
  78. 	mciSendString("open res/audio/readysetplant.mp3 alias BGM4", NULL, NULL, NULL);
  79. 	mciSendString("open res/audio/chomp.mp3 alias ZM_BGM", NULL, NULL, NULL);
  80. 	
  81. 	loadimage(&img, "res/map/map0.jpg");
  82. 	loadimage(&imgBar, "res/bar5.png");
  83. 	//loadimage(&imgnotify, "res/screen/PanelBackground.png");
  84. 	
  85. 	memset(imgPlant, 0, sizeof(imgPlant));
  86. 	memset(map, 0, sizeof(map));
  87. 	memset(cars, 0, sizeof(cars));
  88.  
  89. 	//开场动画
  90. 	for (int i = 0; i < 29; i++)
  91. 	{
  92. 		sprintf_s(name, sizeof(name), "res/yuanshen/%d.png", i + 1);
  93. 		loadimage(&imgopena[i], name, 1196, 670);
  94. 	}
  95.  
  96. 	//植物卡牌
  97. 	for (int i = 0; i < PLANT_COUNT + 2; i++)
  98. 	{
  99. 		sprintf_s(name, sizeof(name), "res/Cards/card_%d.png", i + 1);
  100. 		loadimage(&imgCards[i], name,64,89);
  101.  
  102. 		for (int j = 0; j < 20; j++)
  103. 		{
  104. 			sprintf_s(name, sizeof(name), "res/zhiwu/%d/%d.png",i , j + 1);
  105. 			//先判断文件是否存在
  106. 			if (fileExist(name))
  107. 			{
  108. 				imgPlant[i][j] = new IMAGE;
  109. 				if (i != 3)
  110. 				{
  111. 					loadimage(imgPlant[i][j], name);
  112. 				}
  113. 				else
  114. 				{
  115. 					loadimage(imgPlant[i][j], name,65,100);
  116. 				}
  117. 			}
  118. 			else
  119. 			{
  120. 				break;
  121. 			}
  122. 		}
  123. 	}
  124.  
  125. 	memset(balls, 0, sizeof(balls));
  126. 	for (int i = 0; i < 29; i++)
  127. 	{
  128. 		sprintf_s(name, sizeof(name), "res/sunshine/%d.png", i + 1);
  129. 		loadimage(&imgSunshineBall[i], name);
  130. 	}
  131.  
  132. 	curPlant = 0;
  133. 	sunshine = 50;
  134.  
  135. 	initgraph(Wide, Hight);
  136.  
  137. 	//设置字体
  138. 	LOGFONT f;
  139. 	gettextstyle(&f);
  140. 	f.lfHeight = 30;
  141. 	f.lfWeight = 15;
  142. 	strcpy(f.lfFaceName, "Segoe UI Black");
  143. 	f.lfQuality = ANTIALIASED_QUALITY;//抗锯齿效果
  144. 	settextstyle(&f);
  145. 	setbkmode(TRANSPARENT);//字体透明
  146. 	setcolor(BLACK);
  147.  
  148. 	//初始化子弹的帧图片数组
  149. 	bulletsInit();
  150.  
  151. 	//初始化僵尸数据
  152. 	memset(zms, 0, sizeof(zms));
  153. 	for (int i = 0; i < 22; i++)
  154. 	{
  155. 		sprintf_s(name, sizeof(name), "res/zm/%d.png", i + 1);
  156. 		loadimage(&imgZm[i], name);
  157. 	}
  158.  
  159. 	killCount = 0;
  160. 	zmCount = 0;
  161. 	gameStatus = GOING;
  162.  
  163. 	//初始化僵尸
  164. 	for (int i = 0; i < 38; i++)
  165. 	{
  166. 		sprintf_s(name, sizeof(name), "res/zm_dead/%d.png",i + 1);
  167. 		loadimage(&imgZMDead[i], name);
  168. 	}
  169.  
  170. 	for (int i = 0; i < 21; i++)
  171. 	{
  172. 		sprintf_s(name, sizeof(name), "res/zm_eat/%d.png", i + 1);
  173. 		loadimage(&imgZMEat[i], name);
  174. 	}
  175.  
  176. 	for (int i = 0; i < 11; i++)
  177. 	{
  178. 		sprintf_s(name, sizeof(name), "res/zm_stand/%d.png", i + 1);
  179. 		loadimage(&imgZmStand[i], name);
  180. 	}
  181. 	for (int i = 0; i < 20; i++)
  182. 	{
  183. 		sprintf_s(name, sizeof(name), "res/zm_dead2/%d.png", i + 1);
  184. 		loadimage(&imgzmboom[i], name);
  185. 	}
  186. 	//小推车
  187. 	loadimage(&imgcar, "res/Screen/car.png");
  188. 	for (int i = 0; i < 5; i++)
  189. 	{
  190. 		cars[i].x = 50;
  191. 		cars[i].y = 100 + i * 100 - 15;
  192. 		cars[i].used = true;
  193. 		cars[i].move = false;
  194. 	}
  195. 	//StartButton
  196. 	loadimage(&imgready, "res/Screen/Boom.png");
  197. }
  198.  
  199. void drawZm()
  200. {
  201. 	int zmCount = sizeof(zms) / sizeof(zms[0]);
  202. 	for (int i = 0; i < zmCount; i++)
  203. 	{
  204. 		if (zms[i].used)
  205. 		{//IMAGE* img = (zms[i].dead) ? &imgZMDead[zms[i].frameIndex] : &imgZm[zms[i].frameIndex];
  206. 			IMAGE* img = NULL;
  207. 			if (zms[i].dead)
  208. 			{
  209. 				if (zms[i].boom == true)
  210. 					img = &imgzmboom[zms[i].frameIndex];
  211. 				else
  212. 					img = &imgZMDead[zms[i].frameIndex];
  213. 			}
  214. 			else if (zms[i].eating) img = &imgZMEat[zms[i].frameIndex];
  215. 			else img = &imgZm[zms[i].frameIndex];
  216.  
  217. 			putimagePNG(zms[i].x, zms[i].y - img->getheight(), img);
  218. 		}
  219. 	}
  220. }
  221.  
  222. void drawSunshine()
  223. {
  224. 	int ballMax = sizeof(balls) / sizeof(balls[0]);
  225. 	for (int i = 0; i < ballMax; i++)
  226. 	{
  227. 		//if (balls[i].used || balls[i].xoff)
  228. 		if(balls[i].used)
  229. 		{
  230. 			IMAGE* img = &imgSunshineBall[balls->frameIndex];
  231. 			//putimagePNG(balls[i].x, balls[i].y, img);
  232. 			putimagePNG(balls[i].pCur.x, balls[i].pCur.y, img);
  233. 		}
  234. 	}
  235. }
  236.  
  237. void drawBullets_kunkun()
  238. {
  239. 	int bulletsMax = sizeof(bullets) / sizeof(bullets[0]);
  240. 	for (int i = 0; i < bulletsMax; i++)
  241. 	{
  242. 		if (bullets[i].used) {
  243. 			if (bullets[i].blast) {
  244. 				IMAGE* img = &imgBallBlast[bullets[i].frameIndex];
  245. 				putimagePNG(bullets[i].x, bullets[i].y - 10, img);
  246. 			}
  247. 			else {
  248. 				putimagePNG(bullets[i].x, bullets[i].y, &imgBulletNormal);
  249. 			}
  250. 		}
  251. 	}
  252. }
  253.  
  254. void drawBullets_wandou()
  255. {
  256. 	int bulletsMax = sizeof(bullets_wandou) / sizeof(bullets_wandou[0]);
  257. 	for (int i = 0; i < bulletsMax; i++)
  258. 	{
  259. 		if (bullets_wandou[i].used) {
  260. 			if (bullets_wandou[i].blast) {
  261. 				IMAGE* img = &imgBallBlast_wandou[bullets_wandou[i].frameIndex];
  262. 				putimagePNG(bullets_wandou[i].x, bullets_wandou[i].y, img);
  263. 			}
  264. 			else {
  265. 				putimagePNG(bullets_wandou[i].x, bullets_wandou[i].y, &imgBulletNormal_wandou);
  266. 			}
  267. 		}
  268. 	}
  269. }
  270.  
  271. void drawBullets_hanbing()
  272. {
  273. 	int bulletsMax = sizeof(bullets_hanbing) / sizeof(bullets_hanbing[0]);
  274. 	for (int i = 0; i < bulletsMax; i++)
  275. 	{
  276. 		if (bullets_hanbing[i].used) {
  277. 			if (bullets_hanbing[i].blast) {
  278. 				IMAGE* img = &imgBallBlast_hanbing[bullets_hanbing[i].frameIndex];
  279. 				putimagePNG(bullets_hanbing[i].x, bullets_hanbing[i].y, img);
  280. 			}
  281. 			else {
  282. 				putimagePNG(bullets_hanbing[i].x, bullets_hanbing[i].y, &imgBulletNormal_hanbing);
  283. 			}
  284. 		}
  285. 	}
  286. }
  287.  
  288. void drawBullets_santou()
  289. {
  290. 	int bulletsMax = sizeof(bullets_santou) / sizeof(bullets_santou[0]);
  291. 	for (int i = 0; i < bulletsMax; i++)
  292. 	{
  293. 		if (bullets_santou[i].used) {
  294. 			if (bullets_santou[i].blast) {
  295. 				IMAGE* img = &imgBallBlast_santou[bullets_santou[i].frameIndex];
  296. 				putimagePNG(bullets_santou[i].x, bullets_santou[i].y, img);
  297. 			}
  298. 			else {
  299. 				putimagePNG(bullets_santou[i].x, bullets_santou[i].y, &imgBulletNormal_santou);
  300. 			}
  301. 		}
  302. 	}
  303. }
  304.  
  305. void drawBullets()
  306. {
  307. 	//坤坤
  308. 	drawBullets_kunkun();
  309. 	//豌豆
  310. 	drawBullets_wandou();
  311. 	//寒冰豌豆
  312. 	drawBullets_hanbing();
  313. 	//三头豌豆
  314. 	drawBullets_santou();
  315. }
  316.  
  317. void show()//渲染游戏画面
  318. {
  319. 	BeginBatchDraw();
  320.  
  321. 	putimage(-150, 0, &img);
  322. 	putimagePNG(80, -10, &imgBar);
  323. 	char scoreText[8];
  324. 	char scoreText1[16];
  325. 	sprintf_s(scoreText, sizeof(scoreText), "%d", sunshine);
  326. 	sprintf_s(scoreText1, sizeof(scoreText1), "Wave %d zombies", wava_count);
  327. 	//sprintf_s(name, sizeof(name), "res/yuanshen/%d.png", i + 1);
  328. 	outtextxy(105, 60, scoreText);
  329. 	outtextxy(700, 570, scoreText1);
  330. 	//outtextxy(700, 570, "s");
  331.  
  332. 	//小推车
  333. 	for (int i = 0; i < 5; i++)
  334. 	{
  335. 		if(cars[i].used)
  336. 			putimagePNG(cars[i].x, cars[i].y, &imgcar);
  337. 	}
  338.  
  339. 	//植物卡牌
  340. 	for (int i = 0; i < PLANT_COUNT + 2; i++)
  341. 	{
  342. 		if(i==PLANT_COUNT)
  343. 			putimagePNG(163 + i * 65 + 8, -5, &imgCards[i]);
  344. 		else
  345. 			putimagePNG(163 + i * 65, 0, &imgCards[i]);
  346. 	}
  347.  
  348.  
  349. 	//植物
  350. 	for (int i = 0; i < 5; i++)
  351. 	{
  352. 		for (int j = 0; j < 9; j++)
  353. 		{
  354. 			if (map[i][j].type > 0)
  355. 			{
  356. 				/*int x = 256 - 150 + j * 81;
  357. 				int y = 100 + i * 100 - 15;*/
  358. 				int PlantType = map[i][j].type - 1;
  359. 				int index = map[i][j].frameIndex;
  360. 				if (map[i][j].type != 4 && map[i][j].type != YING_TAO + 1 && map[i][j].type != LA_JIAO + 1)
  361. 				{
  362. 					putimagePNG(map[i][j].x, map[i][j].y, imgPlant[PlantType][index]);
  363. 				}
  364. 				else if (map[i][j].type == YING_TAO + 1)
  365. 				{
  366. 					if (index == 8)
  367. 						putimagePNG(map[i][j].x - 75, map[i][j].y-35, imgPlant[PlantType][index]);
  368. 					else
  369. 						putimagePNG(map[i][j].x - 22, map[i][j].y, imgPlant[PlantType][index]);
  370. 				}
  371. 				else if (map[i][j].type == LA_JIAO + 1)
  372. 				{
  373. 					if (index > 7)
  374. 						putimagePNG(100, map[i][j].y - 35, imgPlant[PlantType][index]);
  375. 					else
  376. 						putimagePNG(map[i][j].x, map[i][j].y, imgPlant[PlantType][index]);
  377. 				}
  378. 				else
  379. 				{
  380. 					putimagePNG(map[i][j].x + 5, map[i][j].y - 20, imgPlant[PlantType][index]);
  381. 				}
  382. 			}
  383. 		}
  384. 	}
  385.  
  386. 	//渲染子弹
  387. 	drawBullets();
  388.  
  389. 	//铲子
  390. 	if (curPlant != PLANT_COUNT + 1)
  391. 	{
  392. 		IMAGE* img = imgPlant[8][0];
  393. 		putimagePNG(163 + 8 * 65 + 8, 0, img);
  394. 	}
  395.  
  396. 	//僵尸
  397. 	drawZm();
  398.  
  399. 	//渲染拖动中的植物
  400. 	if (curPlant > 0)
  401. 	{
  402. 		IMAGE* img = imgPlant[curPlant - 1][0];
  403. 		putimagePNG(curX - img->getwidth() / 2, curY - img->getheight() / 2, img);
  404. 	}
  405.  
  406. 	//渲染阳光
  407. 	drawSunshine();
  408. 	EndBatchDraw();
  409. }
  410.  
  411. void collectSunshine(ExMessage* msg)
  412. {
  413. 	int count = sizeof(balls) / sizeof(balls[0]);
  414. 	int w = imgSunshineBall[0].getwidth();
  415. 	int h = imgSunshineBall[0].getheight();
  416. 	for (int i = 0; i < count; i++)
  417. 	{
  418. 		if (balls[i].used)
  419. 		{
  420. 			//int x = balls[i].x;
  421. 		    //int y = balls[i].y;
  422. 			int x = balls[i].pCur.x;
  423. 			int y = balls[i].pCur.y;
  424.  
  425. 			if (msg->x > x && msg->x<x + w
  426. 				&& msg->y>y && msg->y < y + h)
  427. 			{
  428. 				sunshine += 25;
  429. 				//balls[i].used = false;
  430. 				balls[i].status = SUNSHINE_COLLECT;
  431. 				//音效
  432. 				//mciSendString("play res/sunshine.mp3", 0, 0, 0);
  433. 				//不支持MP3格式
  434. 				PlaySound("res/sunshine.wav", NULL, SND_FILENAME | SND_ASYNC);
  435. 				balls[i].p1 = balls[i].pCur;
  436. 				balls[i].p4 = vector2(100, 0);
  437. 				balls[i].t = 0;
  438. 				float distance = dis(balls[i].p1 - balls[i].p4);
  439. 				float off = 8;
  440. 				balls[i].speed = 1.0 / (distance / off);
  441. 				break;
  442. 				/*float destX = 0;
  443. 				float destY = 262;
  444. 				float angle = atan((y - destY) / (x - destX));
  445. 				balls[i].xoff = 4 * cos(angle);
  446. 				balls[i].yoff = 4 * sin(angle);*/
  447. 			}
  448. 		}
  449. 	}
  450. }
  451.  
  452. void userClick()
  453. {
  454. 	ExMessage msg;
  455. 	static int status = 0;
  456. 	if (peekmessage(&msg))//判断有没有消息
  457. 	{
  458. 		if (msg.message == WM_LBUTTONDOWN)//左键按下
  459. 		{
  460. 			if (msg.x > 163 && msg.x < 163 + 65 * (PLANT_COUNT+2) && msg.y < 96)
  461. 			{
  462. 				//mciSendString("play res/audio/bleep.mp3 alias BGM4", NULL, NULL, NULL);
  463. 				PlaySound("res/audio/bleep.wav", NULL, SND_FILENAME | SND_ASYNC);
  464. 				//PlaySound("res/sunshine.wav", NULL, SND_FILENAME | SND_ASYNC);
  465.  
  466. 				int index = (msg.x - 163) / 65;
  467. 				//坤坤
  468. 			/*	if (index + 1 == KUN_KUN && sunshine >= 100)
  469. 				{
  470. 					curPlant = index + 1;
  471. 					status = 1;
  472. 					curX = msg.x;
  473. 					curY = msg.y;
  474. 					sunshine -= 100;
  475. 				}*/
  476. 				curPlant = index + 1;
  477. 				status = 1;
  478. 				curX = msg.x;
  479. 				curY = msg.y;
  480. 			}
  481. 			else
  482. 			{
  483. 				collectSunshine(&msg);
  484. 			}
  485. 		}
  486. 		else if (msg.message == WM_MOUSEMOVE && status == 1)//鼠标移动
  487. 		{
  488. 			curX = msg.x;
  489. 			curY = msg.y;
  490. 		}
  491. 		else if (msg.message == WM_LBUTTONUP)//鼠标放下
  492. 		{
  493. 			if (msg.x > 256 - 150 && msg.x < Wide - 70 && msg.y > 100 && msg.y < 590)
  494. 			{
  495. 				int row = (msg.y - 100) / 102;
  496. 				int col = (msg.x - 256 + 150 ) / 81;
  497. 				
  498. 				
  499. 				if (map[row][col].type == 0 && curPlant != PLANT_COUNT + 1 && curPlant != PLANT_COUNT + 2)
  500. 				{
  501. 					//printf("%d\n", map[col][row].type);
  502. 					map[row][col].type = curPlant;
  503. 					map[row][col].frameIndex = 0;
  504.  
  505. 					if(curPlant!=0)
  506. 						PlaySound("res/audio/coffee.wav", NULL, SND_FILENAME | SND_ASYNC);
  507.  
  508. 					if (curPlant == 5)
  509. 						map[row][col].blood = KUNKUN_BLOOD * 50;
  510. 					else
  511. 						map[row][col].blood = KUNKUN_BLOOD;
  512.  
  513. 					map[row][col].shootTime = 0;
  514. 					map[row][col].shoot = false;
  515.  
  516. 					map[row][col].x = 256 - 150 + col * 81;
  517. 					map[row][col].y = 100 + row * 100 - 15;
  518. 					
  519. 				}
  520. 				else if (map[row][col].type != 0 && curPlant == PLANT_COUNT + 1)
  521. 				{
  522. 					PlaySound("res/audio/coffee.wav", NULL, SND_FILENAME | SND_ASYNC);
  523.  
  524. 					map[row][col].type = 0;
  525. 					map[row][col].blood = 0;
  526. 					
  527. 				}
  528. 				else if (curPlant == PLANT_COUNT + 2)
  529. 				{
  530.  
  531. 					if (zmCount >= ZM_MAX)
  532. 						return;
  533.  
  534. 					int i = 0;
  535. 					int zmMax = sizeof(zms) / sizeof(zms[0]);
  536. 					for (i = 0; i < zmMax && zms[i].used; i++);
  537. 					if (i < zmMax)
  538. 					{
  539. 						PlaySound("res/audio/coffee.wav", NULL, SND_FILENAME | SND_ASYNC);
  540. 						memset(&zms[i], 0, sizeof(zms[i]));
  541. 						zms[i].used = true;
  542. 						zms[i].speed = 2;
  543. 						zms[i].row = row;
  544. 						zms[i].y = 100 + (zms[i].row) * 100 + 70;
  545. 						zms[i].x = 256 - 150 + (col - 1) * 81;
  546. 						zms[i].blood = ORDINARY_ZM_BLOOD;
  547. 						zms[i].dead = false;
  548. 						zms[i].boom = false;
  549. 						zms[i].zmSpeed = 4;
  550. 						zmCount++;
  551. 					}
  552. 				}
  553. 			}
  554. 		}
  555. 		else if (msg.message == WM_RBUTTONDOWN)
  556. 		{
  557. 			curPlant = 0;
  558. 			status = 0;
  559. 		}
  560. 	}
  561. }
  562.  
  563. void createSunshine()
  564. {
  565.  
  566. 	static int count = 0;
  567. 	static int fre = 200;
  568. 	count++;
  569. 	if (count >= fre)
  570. 	{
  571. 		fre = 200 + rand() % 200;
  572. 		count = 0;
  573.  
  574. 		//从阳光池取一个可以使用的
  575. 		int ballMax = sizeof(balls) / sizeof(balls[0]);
  576.  
  577. 		int i;
  578. 		for (i = 0; i < ballMax && balls[i].used; i++);
  579. 			if (i >= ballMax)return;
  580.  
  581. 			balls[i].used = true;
  582. 			balls[i].frameIndex = 0;
  583. 		/*	balls[i].x = 160 + rand() % 600;
  584. 			balls[i].y = 60;
  585. 			balls[i].destY = (rand() % 4) * 90 + 160;*/
  586. 			balls[i].timer = 0;
  587. 		/*	balls[i].xoff = 0;
  588. 			balls[i].yoff = 0;*/
  589.  
  590. 			balls[i].status = SUNSHINE_DOWN;
  591. 			balls[i].t = 0;
  592. 			balls[i].p1 = vector2(160 + rand() % 600, 60);
  593. 			balls[i].p4 = vector2(balls[i].p1.x, (rand() % 4) * 90 + 160);
  594. 			int off = 2;
  595. 			float distance = balls[i].p4.y - balls[i].p1.y;
  596. 			balls[i].speed = 1.0 / (distance / off);
  597. 	}
  598.  
  599. 	int ballMax = sizeof(balls) / sizeof(balls[0]);
  600. 	//向日葵生产阳光
  601. 	for (int i = 0; i < 5; i++)
  602. 	{
  603. 		for (int j = 0; j < 9; j++)
  604. 		{
  605. 			if (map[i][j].type == TAI_YANG + 1)
  606. 			{
  607. 				map[i][j].timer++;
  608. 				if (map[i][j].timer > 100)
  609. 				{
  610. 					map[i][j].timer = 0;
  611.  
  612. 					int k;
  613. 					for (k = 0; k < ballMax && balls[k].used; k++);
  614. 					if (k >= ballMax)return;
  615.  
  616. 					balls[k].used = true;
  617. 					balls[k].p1 = vector2(map[i][j].x, map[i][j].y);
  618. 					int w = (40 + rand() % 50) * (rand() % 2 ? 1 : -1);
  619. 					balls[k].p4 = vector2(map[i][j].x + w,
  620. 						map[i][j].y + imgPlant[TAI_YANG][0]->getheight() - imgSunshineBall[0].getheight());
  621. 					balls[k].p2 = vector2(balls[k].p1.x + w * 0.3, balls[k].p1.y - 100);
  622. 					balls[k].p3 = vector2(balls[k].p1.x + w * 0.7, balls[k].p1.y - 100);
  623. 					balls[k].status = SUNSHINE_RPODUCT;
  624. 					balls[k].speed = 0.05;
  625. 					balls[k].t = 0;
  626. 				}
  627. 			}
  628. 		}
  629. 	}
  630.  
  631. }
  632.  
  633. void updatSunshine()
  634. {
  635. 	int ballMax = sizeof(balls) / sizeof(balls[0]);
  636. 	for (int i = 0; i < ballMax; i++)
  637. 	{
  638. 		if (balls[i].used)
  639. 		{
  640. 			balls[i].frameIndex = (balls[i].frameIndex + 1) % 29;
  641. 			if (balls[i].status == SUNSHINE_DOWN)
  642. 			{
  643. 				struct sunshineBall* sun = &balls[i];
  644. 				sun->t += sun->speed;
  645. 				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);
  646. 				if (sun->t >= 1)
  647. 				{
  648. 					sun->status = SUNSHINE_GROUND;
  649. 					sun->timer = 0;
  650. 				}
  651. 			}
  652. 			else if (balls[i].status == SUNSHINE_GROUND)
  653. 			{
  654. 				balls[i].timer++;
  655. 				if (balls[i].timer > 100)
  656. 				{
  657. 					balls[i].used = false;
  658. 					balls[i].timer = 0;
  659. 				}
  660. 			}
  661. 			else if (balls[i].status == SUNSHINE_COLLECT)
  662. 			{
  663. 				struct sunshineBall* sun = &balls[i];
  664. 				sun->t += sun->speed;
  665. 				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);
  666. 				if (sun->t > 1)
  667. 				{
  668. 					sun->used = false;
  669. 					sunshine += 25;
  670. 				}
  671. 			}
  672. 			else if (balls[i].status == SUNSHINE_RPODUCT)
  673. 			{
  674. 				struct sunshineBall* sun = &balls[i];
  675. 				sun->t += sun->speed;
  676. 				sun->pCur = calcBezierPoint(sun->t,sun->p1, sun->p2, sun->p3, sun->p4);
  677. 				if (sun->t > 1)
  678. 				{
  679. 					sun->status = SUNSHINE_GROUND;
  680. 					sun->timer = 0;
  681. 				}
  682.  
  683. 			}
  684. 		}
  685. 	}
  686. }
  687.  
  688. int mciZmTime = 0;
  689. void createZM()
  690. {
  691. 	if (zmCount >= zmCount_max)
  692. 		return;
  693.  
  694. 	static int zmFre = 5000000;
  695. 	static int count = 0;
  696. 	
  697. 	count++;
  698. 	if (count > zmFre)
  699. 	{
  700. 		if (mciZmTime == 0)
  701. 		{
  702. 			mciSendString("play res/audio/awooga.mp3", 0, 0, 0);
  703. 			mciZmTime++;
  704. 		}
  705. 		count = 0;
  706. 		zmFre = 202 - 20 * wava_count;
  707. 		int i = 0;
  708. 		int zmMax = sizeof(zms) / sizeof(zms[0]);
  709. 		for (i = 0; i < zmMax && zms[i].used && zms[i].dead == false; i++);
  710. 		if (i < zmMax)
  711. 		{
  712. 			memset(&zms[i], 0, sizeof(zms[i]));
  713. 			zms[i].used = true;
  714. 			zms[i].speed = 2;
  715. 			zms[i].row = rand() % 5;
  716. 			zms[i].y = 100 + (zms[i].row) * 100 + 70;
  717. 			zms[i].x = Wide;
  718. 			zms[i].blood = ORDINARY_ZM_BLOOD;
  719. 			zms[i].dead = false;
  720. 			zms[i].boom = false;
  721. 			zms[i].zmSpeed = 4;
  722. 			zmCount++;
  723. 		}
  724. 	}
  725. }
  726.  
  727. int zmSpeed = 6;
  728. void updateZM()
  729. {
  730. 	int zmMax = sizeof(zms) / sizeof(zms[0]);
  731. 	static int count[ZM_MAX] = { 0 };
  732. 	//更新僵尸的位置
  733. 	for (int i = 0; i < zmMax; i++)
  734. 	{
  735. 		count[i]++;
  736. 		if (count[i] >= (gameStatus == GOING ? zms[i].zmSpeed : zmSpeed))
  737. 		{
  738. 			//printf("%d ", (gameStatus == GOING ? zms[i].zmSpeed : zmSpeed));
  739. 			count[i] = 0;
  740.  
  741. 			if (zms[i].used)
  742. 			{
  743. 				if (zms[i].dead)
  744. 				{
  745. 					zms[i].frameIndex++;
  746. 					if (zms[i].boom == true)
  747. 					{
  748. 						if (zms[i].frameIndex >= 20)
  749. 						{
  750. 							//printf("%d ", killCount);
  751. 							zms[i].used = false;
  752. 							zms[i].row = 0;
  753. 							//killCount++;
  754. 							if (killCount >= ZM_MAX)
  755. 								gameStatus = WIN;
  756. 							else if (killCount >= zmCount_max)
  757. 							{
  758. 								wava_count++;
  759. 								zmCount_max *= 2;
  760. 								killCount = 0;
  761. 								zmCount = 0;
  762. 							}
  763. 						}
  764. 					}
  765. 					else
  766. 					{
  767. 						if (zms[i].frameIndex >= 38)
  768. 						{
  769. 							//printf("%d ", killCount);
  770.  
  771. 							zms[i].used = false;
  772. 							zms[i].row = 0;
  773. 							
  774. 							if (killCount >= ZM_MAX)
  775. 								gameStatus = WIN;
  776. 							else if (killCount >= zmCount_max)
  777. 							{
  778. 								wava_count++;
  779. 								zmCount_max *= 2;
  780. 								killCount = 0;
  781. 								zmCount = 0;
  782. 							}
  783. 						}
  784. 					}
  785. 				}
  786. 				else if (zms[i].eating)
  787. 				{
  788.  
  789. 					//mciSendString("play res/audio/chomp.mp3", 0, 0, 0);
  790. 					//mciSendString("play res/audio/chompsoft.mp3", 0, 0, 0);
  791. 					zms[i].frameIndex = (zms[i].frameIndex + 1) % 21;
  792. 				}
  793. 				else
  794. 				{
  795. 					zms[i].frameIndex++;
  796. 					if (zms[i].frameIndex >= 22)
  797. 					{
  798. 						zms[i].frameIndex = 0;
  799. 					}
  800. 				}
  801. 				zms[i].x -= zms[i].speed;
  802. 				if (zms[i].x < 0)
  803. 				{
  804. 					//printf("GAME OVER\n");
  805. 					//MessageBox(NULL, "over", "over", 0);//待优化
  806. 					//exit(0);//待优化
  807. 					gameStatus = FAIL;
  808. 				}
  809. 			}
  810. 		}
  811. 	}
  812. }
  813.  
  814. void shoot()
  815. {
  816. 	int lines[5] = { 0 };
  817. 	int bulletMax = sizeof(bullets) / sizeof(bullets[0]);
  818. 	int bulletMax_wandou = sizeof(bullets_wandou) / sizeof(bullets_wandou[0]);
  819. 	int bulletMax_hanbing = sizeof(bullets_hanbing) / sizeof(bullets_hanbing[0]);
  820. 	int bulletMax_santou = sizeof(bullets_santou) / sizeof(bullets_santou[0]);
  821. 	int zmCount = sizeof(zms) / sizeof(zms[0]);
  822. 	int dangerX = Wide - 80;
  823. 	for (int i = 0; i < zmCount; i++)
  824. 	{
  825. 		if (zms[i].dead == false && zms[i].x < dangerX && zms[i].x>100)
  826. 		{
  827. 			lines[zms[i].row] = 1;
  828. 		}
  829. 	}
  830.  
  831. 	for (int i = 0; i < 5; i++)
  832. 	{
  833. 		for (int j = 0; j < 9; j++)
  834. 		{
  835. 			//坤坤
  836. 			if (map[i][j].type == KUN_KUN + 1 && lines[i])
  837. 			{
  838. 				map[i][j].shootTime++;
  839. 				if (map[i][j].shootTime > 20)
  840. 				{
  841. 					map[i][j].shootTime = 0;
  842.  
  843. 					int k;
  844. 					for (k = 0; k < bulletMax && bullets[k].used; k++);
  845. 					if (k < bulletMax)
  846. 					{
  847. 						map[i][j].frameIndex = 3;
  848. 						bullets[k].used = true;
  849. 						bullets[k].row = i;
  850. 						bullets[k].speed = 10;
  851.  
  852. 						bullets[k].blast = false;
  853. 						bullets[k].frameIndex = 0;
  854.  
  855. 						int zwX = 256 - 150 + j * 81;
  856. 						int zwY = 100 + i * 100 - 15;
  857. 						bullets[k].x = zwX + imgPlant[map[i][j].type - 1][0]->getwidth() - 10;
  858. 						bullets[k].y = zwY + 5;
  859. 					}
  860. 				}
  861. 			}
  862.  
  863. 			//豌豆
  864. 			else if (map[i][j].type == WAN_DOU + 1 && lines[i])
  865. 			{
  866. 				map[i][j].shootTime++;
  867. 				if (map[i][j].shootTime > 35)
  868. 				{
  869. 					map[i][j].shootTime = 0;
  870. 					int k;
  871. 					for (k = 0; k < bulletMax_wandou && bullets_wandou[k].used; k++);
  872. 					if (k < bulletMax_wandou)
  873. 					{
  874. 						//map[i][j].shoot = true;
  875. 						//if(map[i][j].frameIndex > 1)
  876. 						map[i][j].frameIndex = 2;
  877. 						bullets_wandou[k].used = true;
  878. 						bullets_wandou[k].row = i;
  879. 						bullets_wandou[k].speed = 8;
  880.  
  881. 						bullets_wandou[k].blast = false;
  882. 						bullets_wandou[k].frameIndex = 0;
  883.  
  884. 						int zwX = 256 - 150 + j * 81;
  885. 						int zwY = 100 + i * 100 - 15;
  886. 						bullets_wandou[k].x = zwX + imgPlant[map[i][j].type - 1][0]->getwidth() - 10;
  887. 						bullets_wandou[k].y = zwY + 5;
  888. 					}
  889. 				}
  890. 			}
  891.  
  892. 			//寒冰豌豆
  893. 			else if (map[i][j].type == HAN_BING_WAN_DOU + 1 && lines[i])
  894. 			{
  895. 				map[i][j].shootTime++;
  896. 				if (map[i][j].shootTime > 35)
  897. 				{
  898. 					map[i][j].shootTime = 0;
  899. 					int k;
  900. 					for (k = 0; k < bulletMax_hanbing && bullets_hanbing[k].used; k++);
  901. 					if (k < bulletMax_hanbing)
  902. 					{
  903. 						//map[i][j].shoot = true;
  904. 						//if(map[i][j].frameIndex > 1)
  905. 						map[i][j].frameIndex = 4;
  906. 						bullets_hanbing[k].used = true;
  907. 						bullets_hanbing[k].row = i;
  908. 						bullets_hanbing[k].speed = 10;
  909.  
  910. 						bullets_hanbing[k].blast = false;
  911. 						bullets_hanbing[k].frameIndex = 0;
  912.  
  913. 						int zwX = 256 - 150 + j * 81;
  914. 						int zwY = 100 + i * 100 - 15;
  915. 						bullets_hanbing[k].x = zwX + imgPlant[map[i][j].type - 1][0]->getwidth() - 10;
  916. 						bullets_hanbing[k].y = zwY + 5;
  917. 					}
  918. 				}
  919. 			}
  920.  
  921. 			//三头豌豆
  922. 			else if (map[i][j].type == SAN_TOU_WAN_DOU + 1 && lines[i])
  923. 			{
  924. 				map[i][j].shootTime++;
  925. 				if (map[i][j].shootTime > 35)
  926. 				{
  927. 					map[i][j].shootTime = 0;
  928. 					int k;
  929. 					for (int b = 0; b < 3; b++)
  930. 					{
  931. 						for (k = 0; k < bulletMax_santou && bullets_santou[k].used; k++);
  932. 						if (k < bulletMax_santou)
  933. 						{
  934. 							//map[i][j].shoot = true;
  935. 							//if(map[i][j].frameIndex > 1)
  936. 							//map[i][j].frameIndex = 2;
  937. 							bullets_santou[k].used = true;
  938. 							bullets_santou[k].row = i;
  939. 							bullets_santou[k].speed = 8;
  940.  
  941. 							bullets_santou[k].blast = false;
  942. 							bullets_santou[k].frameIndex = 0;
  943.  
  944. 							int zwX = 256 - 150 + j * 81;
  945. 							int zwY = 100 + i * 100 - 15;
  946. 							bullets_santou[k].x = zwX + imgPlant[map[i][j].type - 1][0]->getwidth() - 30;
  947. 							bullets_santou[k].y = zwY + 16;
  948. 							direction_santou[k] = b;
  949. 							row_santou[k] = i;
  950. 						}
  951. 					}
  952. 				}
  953. 			}
  954. 		}
  955. 	}
  956. }
  957.  
  958. void updateBullets_kunkun()
  959. {
  960. 	int countMax = sizeof(bullets) / sizeof(bullets[0]);
  961. 	for (int i = 0; i < countMax; i++)
  962. 	{
  963. 		if (bullets[i].used)
  964. 		{
  965. 			//static double angle = 0;
  966. 			bullets[i].x += bullets[i].speed;
  967. 			//angle += bullets[i].speed;
  968. 			//bullets[i].y += 10;
  969.  
  970. 			//bullets[i].x += bullets[i].speed;
  971. 			if (bullets[i].x > Wide)
  972. 			{
  973. 				bullets[i].used = false;
  974. 			}
  975.  
  976. 			//待完善
  977. 			if (bullets[i].blast)
  978. 			{
  979. 				bullets[i].frameIndex++;
  980. 				if (bullets[i].frameIndex >= 4)
  981. 				{
  982. 					bullets[i].used = false;
  983. 				}
  984. 			}
  985. 		}
  986. 	}
  987. }
  988.  
  989. void updateBullets_wandou()
  990. {
  991. 	int countMax_wandou = sizeof(bullets_wandou) / sizeof(bullets_wandou[0]);
  992. 	for (int i = 0; i < countMax_wandou; i++)
  993. 	{
  994. 		if (bullets_wandou[i].used)
  995. 		{
  996. 			//static double angle = 0;
  997. 			bullets_wandou[i].x += bullets_wandou[i].speed;
  998. 			//angle += bullets[i].speed;
  999. 			//bullets[i].y += 10;
  1000.  
  1001. 			//bullets[i].x += bullets[i].speed;
  1002. 			if (bullets_wandou[i].x > Wide)
  1003. 			{
  1004. 				bullets_wandou[i].used = false;
  1005. 			}
  1006.  
  1007. 			//待完善
  1008. 			if (bullets_wandou[i].blast)
  1009. 			{
  1010. 				bullets_wandou[i].frameIndex++;
  1011. 				if (bullets_wandou[i].frameIndex >= 4)
  1012. 				{
  1013. 					bullets_wandou[i].used = false;
  1014. 				}
  1015. 			}
  1016. 		}
  1017. 	}
  1018. }
  1019.  
  1020. void updateBullets_hanbing()
  1021. {
  1022. 	int countMax_hanbing = sizeof(bullets_hanbing) / sizeof(bullets_hanbing[0]);
  1023. 	for (int i = 0; i < countMax_hanbing; i++)
  1024. 	{
  1025. 		if (bullets_hanbing[i].used)
  1026. 		{
  1027. 			//static double angle = 0;
  1028. 			bullets_hanbing[i].x += bullets_hanbing[i].speed;
  1029. 			//angle += bullets[i].speed;
  1030. 			//bullets[i].y += 10;
  1031.  
  1032. 			//bullets[i].x += bullets[i].speed;
  1033. 			if (bullets_hanbing[i].x > Wide)
  1034. 			{
  1035. 				bullets_hanbing[i].used = false;
  1036. 			}
  1037.  
  1038. 			//待完善
  1039. 			if (bullets_hanbing[i].blast)
  1040. 			{
  1041. 				bullets_hanbing[i].frameIndex++;
  1042. 				if (bullets_hanbing[i].frameIndex >= 4)
  1043. 				{
  1044. 					bullets_hanbing[i].used = false;
  1045. 				}
  1046. 			}
  1047. 		}
  1048. 	}
  1049. }
  1050.  
  1051. void updateBullets_santou()
  1052. {
  1053. 	int countMax_santou = sizeof(bullets_santou) / sizeof(bullets_santou[0]);
  1054. 	for (int i = 0; i < countMax_santou; i++)
  1055. 	{
  1056. 		if (bullets_santou[i].used)
  1057. 		{
  1058. 			if (direction_santou[i] == MIDDLE)
  1059. 			{//static double angle = 0;
  1060. 				bullets_santou[i].x += bullets_santou[i].speed;
  1061.  
  1062. 				//bullets[i].x += bullets[i].speed;
  1063. 				if (bullets_santou[i].x > Wide)
  1064. 				{
  1065. 					bullets_santou[i].used = false;
  1066. 				}	
  1067. 			}
  1068. 			else if (direction_santou[i] == UP)
  1069. 			{
  1070. 				int destY = 85 + (row_santou[i] - 1) * 100;
  1071. 				//int zwX = 256 - 150 + j * 81;
  1072. 				float angle = atan(0.6);
  1073. 				bullets_santou[i].x += bullets_santou[i].speed;
  1074. 				bullets_santou[i].y -= bullets_santou[i].speed * tan(angle);
  1075. 				//printf("%d\n", row_santou[i]);
  1076. 				//printf("destY = %d\n", destY);
  1077. 				//printf("bullets[i].y = %lf\n", bullets[i].y);
  1078. 				if (bullets_santou[i].y <= destY + 16)
  1079. 				{
  1080. 					direction_santou[i] = MIDDLE;
  1081. 				}
  1082.  
  1083. 			}
  1084. 			else if (direction_santou[i] == DOWN)
  1085. 			{
  1086. 				int destY = 85 + (row_santou[i] + 1) * 100;
  1087. 				float angle = atan(0.6);
  1088. 				bullets_santou[i].x += bullets_santou[i].speed;
  1089. 				bullets_santou[i].y += bullets_santou[i].speed * tan(angle);
  1090. 				if (bullets_santou[i].y >= destY + 16)
  1091. 				{
  1092. 					direction_santou[i] = MIDDLE;
  1093. 				}
  1094. 			}
  1095. 			//待完善
  1096. 			if (bullets_santou[i].blast)
  1097. 			{
  1098. 				bullets_santou[i].frameIndex++;
  1099. 				if (bullets_santou[i].frameIndex >= 4)
  1100. 				{
  1101. 					bullets_santou[i].used = false;
  1102. 				}
  1103. 			}
  1104. 		}
  1105. 	}
  1106. }
  1107.  
  1108. void updateBullets()
  1109. {
  1110. 	//坤坤
  1111. 	updateBullets_kunkun();
  1112. 	//豌豆射手
  1113. 	updateBullets_wandou();
  1114. 	//寒冰豌豆
  1115. 	updateBullets_hanbing();
  1116. 	//三头豌豆
  1117. 	updateBullets_santou();
  1118. }
  1119.  
  1120. void checkBullet2Zm_kunkun()
  1121. {
  1122. 	int bCount = sizeof(bullets) / sizeof(bullets[0]);
  1123. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  1124. 	for (int i = 0; i < bCount; i++)
  1125. 	{
  1126. 		//if (bullets[i].used || bullets[i].blast == false)
  1127. 		{
  1128. 			for (int j = 0; j < zCount; j++)
  1129. 			{
  1130. 				if (zms[j].used == false)continue;
  1131. 				int x1 = zms[j].x + 80;
  1132. 				int x2 = zms[j].x + 110;
  1133. 				int x = bullets[i].x;
  1134. 				if (zms[j].dead == false &&
  1135. 					bullets[i].row == zms[j].row && x > x1 && x < x2 && bullets[i].used) {
  1136. 					zms[j].blood -= 20;
  1137. 					zms[j].x += 1;
  1138. 					bullets[i].blast = true;
  1139. 					bullets[i].speed = 0;
  1140. 					//bullets[i].x = 0;
  1141.  
  1142. 					if (zms[j].blood <= 0)
  1143. 					{
  1144. 						killCount++;
  1145.  
  1146. 						zms[j].dead = true;
  1147. 						zms[j].speed = 0;
  1148. 						zms[j].frameIndex = 0;
  1149. 					}
  1150. 					break;
  1151. 				}
  1152. 			}
  1153. 		}
  1154. 	}
  1155. }
  1156.  
  1157. void checkBullet2Zm_wandou()
  1158. {
  1159. 	int bCount = sizeof(bullets_wandou) / sizeof(bullets_wandou[0]);
  1160. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  1161. 	for (int i = 0; i < bCount; i++)
  1162. 	{
  1163. 		//if (bullets[i].used || bullets[i].blast == false)
  1164. 			for (int j = 0; j < zCount; j++)
  1165. 			{
  1166. 				if (zms[j].used == false)continue;
  1167. 				int x1 = zms[j].x + 80;
  1168. 				int x2 = zms[j].x + 110;
  1169. 				int x = bullets_wandou[i].x;
  1170. 				if (zms[j].dead == false &&
  1171. 					bullets_wandou[i].row == zms[j].row && x > x1 && x < x2 && bullets_wandou[i].used) {
  1172. 					zms[j].blood -= 20;
  1173. 					bullets_wandou[i].blast = true;
  1174. 					bullets_wandou[i].speed = 0;
  1175. 					//bullets_wandou[i].x = 0;
  1176.  
  1177. 					if (zms[j].blood <= 0)
  1178. 					{
  1179. 						killCount++;
  1180.  
  1181. 						zms[j].dead = true;
  1182. 						zms[j].speed = 0;
  1183. 						zms[j].frameIndex = 0;
  1184. 					}
  1185. 					break;
  1186. 				}
  1187. 			}
  1188. 	}
  1189. }
  1190.  
  1191. void checkBullet2Zm_hanbing()
  1192. {
  1193. 	int bCount = sizeof(bullets_hanbing) / sizeof(bullets_hanbing[0]);
  1194. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  1195. 	for (int i = 0; i < bCount; i++)
  1196. 	{
  1197. 		//if (bullets[i].used || bullets[i].blast == false)
  1198. 		for (int j = 0; j < zCount; j++)
  1199. 		{
  1200. 			if (zms[j].used == false)continue;
  1201. 			int x1 = zms[j].x + 80;
  1202. 			int x2 = zms[j].x + 110;
  1203. 			int x = bullets_hanbing[i].x;
  1204. 			if (zms[j].dead == false &&
  1205. 				bullets_hanbing[i].row == zms[j].row && x > x1 && x < x2 && bullets_hanbing[i].used) {
  1206. 				zms[j].blood -= 20;
  1207. 				zms[j].zmSpeed = 7;
  1208. 				bullets_hanbing[i].blast = true;
  1209. 				bullets_hanbing[i].speed = 0;
  1210. 				//bullets_hanbing[i].x = 0;
  1211.  
  1212. 				if (zms[j].blood <= 0)
  1213. 				{
  1214. 					killCount++;
  1215. 					zms[j].dead = true;
  1216. 					zms[j].speed = 0;
  1217. 					zms[j].frameIndex = 0;
  1218. 					zms[j].zmSpeed = 4;
  1219. 				}
  1220. 				break;
  1221. 			}
  1222. 		}
  1223. 	}
  1224. }
  1225.  
  1226. void checkBullet2Zm_santou()
  1227. {
  1228. 	int bCount = sizeof(bullets_santou) / sizeof(bullets_santou[0]);
  1229. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  1230. 	for (int i = 0; i < bCount; i++)
  1231. 	{
  1232. 		bullets_santou[i].row = (bullets_santou[i].y - 85+5) / 100;
  1233. 		//if (bullets[i].used || bullets[i].blast == false)
  1234. 		for (int j = 0; j < zCount; j++)
  1235. 		{
  1236. 			//100 + i * 100 - 15
  1237.  
  1238. 			if (zms[j].used == false)continue;
  1239. 			int x1 = zms[j].x + 80;
  1240. 			int x2 = zms[j].x + 110;
  1241. 			int x = bullets_santou[i].x;
  1242. 			if (zms[j].dead == false &&
  1243. 				bullets_santou[i].row == zms[j].row && x > x1 && x < x2 && bullets_santou[i].used) {
  1244. 				zms[j].blood -= 20;
  1245. 				bullets_santou[i].blast = true;
  1246. 				bullets_santou[i].speed = 0;
  1247. 				//bullets_santou[i].x = 0;
  1248.  
  1249. 				if (zms[j].blood <= 0)
  1250. 				{
  1251. 					killCount++;
  1252.  
  1253. 					zms[j].dead = true;
  1254. 					zms[j].speed = 0;
  1255. 					zms[j].frameIndex = 0;
  1256. 					zms[j].zmSpeed = 4;
  1257. 				}
  1258. 				break;
  1259. 			}
  1260. 		}
  1261. 	}
  1262. }
  1263.  
  1264. void checkBullet2Zm()
  1265. {
  1266. 	//坤坤
  1267. 	checkBullet2Zm_kunkun();
  1268. 	//豌豆
  1269. 	checkBullet2Zm_wandou();
  1270. 	//寒冰豌豆
  1271. 	checkBullet2Zm_hanbing();
  1272. 	//三头豌豆
  1273. 	checkBullet2Zm_santou();
  1274. }
  1275.  
  1276. void checkBoom2Zm()
  1277. {
  1278. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  1279.  
  1280. 	for (int i = 0; i < 5; i++)
  1281. 	{
  1282. 		for (int j = 0; j < 9; j++)
  1283. 		{
  1284. 			//樱桃
  1285. 			if (map[i][j].type == YING_TAO + 1)
  1286. 			{
  1287. 				if (map[i][j].frameIndex > 8)
  1288. 				{
  1289. 					PlaySound("res/audio/cherrybomb.wav", NULL, SND_FILENAME | SND_ASYNC);
  1290. 					//map[row][col].x = 256 - 150 + col * 81;
  1291. 					//map[row][col].y = 100 + row * 100 - 15;
  1292. 					map[i][j].type = 0;
  1293. 					map[i][j].frameIndex = 0;
  1294. 					int x1 = 100 + 81 * (j - 1);
  1295. 					int x2 = 100 + 81 * (j + 2);
  1296. 					int y1 = 85 + (i - 1) * 100;
  1297. 					int y2 = 85 + (i + 2) * 100;
  1298. 					for (int k = 0; k < zCount; k++)
  1299. 					{
  1300. 						if (zms[k].used == false)continue;
  1301.  
  1302. 						int zmX = zms[k].x + imgZm[0].getwidth() / 2;
  1303. 						int zmY = zms[k].y;
  1304. 						if (zmX <= x2 && zmX >= x1 && zmY >= y1 && zmY <= y2 && zms[k].dead == false)
  1305. 						{
  1306. 							killCount++;
  1307.  
  1308. 							zms[k].boom = true;
  1309. 							zms[k].dead = true;
  1310. 							zms[k].speed = 0;
  1311. 							zms[k].frameIndex = 0;
  1312. 							zms[k].blood = 0;
  1313. 						
  1314. 						}
  1315. 					}
  1316. 				}
  1317. 			}
  1318. 			//火爆辣椒
  1319. 			else if (map[i][j].type == LA_JIAO + 1)
  1320. 			{
  1321. 				if (map[i][j].frameIndex > 7)
  1322. 				{
  1323. 					if (map[i][j].frameIndex == 8)
  1324. 						PlaySound("res/audio/firepea.wav", NULL, SND_FILENAME | SND_ASYNC);
  1325.  
  1326. 					for (int k = 0; k < zCount; k++)
  1327. 					{
  1328. 						if (zms[k].used == false)continue;
  1329.  
  1330. 						if (zms[k].row == i && zms[k].x < Wide - 80 - 70 && zms[k].dead == false)
  1331. 						{
  1332. 							killCount++;
  1333.  
  1334. 							zms[k].boom = true;
  1335. 							zms[k].dead = true;
  1336. 							zms[k].speed = 0;
  1337. 							zms[k].frameIndex = 0;
  1338. 							zms[k].blood = 0;
  1339. 						}
  1340. 					}
  1341. 					if (map[i][j].frameIndex > 14)
  1342. 					{
  1343. 						map[i][j].type = 0;
  1344. 						map[i][j].frameIndex = 0;
  1345. 					}
  1346. 				}
  1347. 			}
  1348. 		}
  1349. 	}
  1350. }
  1351.  
  1352. void checkZM2Zhiwu()
  1353. {
  1354. 	int chomp = 0;
  1355. 	//mciSendString("play ZM_BGM repeat", NULL, NULL, NULL);
  1356. 	char name[64];
  1357. 	int bCount = sizeof(bullets) / sizeof(bullets[0]);
  1358. 	int zCount = sizeof(zms) / sizeof(zms[0]);
  1359. 	for (int i = 0; i < zCount; i++)
  1360. 	{
  1361. 		//killCount = 0;
  1362. 		if (zms[i].dead)continue;
  1363.  
  1364. 		//zms[i].chomptime = 0;
  1365. 		int row = zms[i].row;
  1366. 		for (int j = 0; j < 9; j++)
  1367. 		{
  1368. 			//if (map[row][j].type == 0)continue;
  1369. 			
  1370. 			//
  1371. 			int zhiwuX = 101 + j * 81;
  1372. 			int x1 = zhiwuX;
  1373. 			int x2 = zhiwuX + 81;
  1374. 			int x3 = zms[i].x + 100;
  1375. 			if (x3 >= x1 && x3 <= x2)
  1376. 			{
  1377. 				if (map[row][j].blood <= 0 || (map[row][j].type == 0 && zms[i].eating != false))
  1378. 				{
  1379. 					map[row][j].blood = 0;
  1380. 					map[row][j].type = 0;
  1381. 					zms[i].eating = false;
  1382. 					//zms[i].frameIndex = 0;
  1383. 					zms[i].speed = 3;
  1384. 				}
  1385. 				else if (map[row][j].type != 0)
  1386. 				{
  1387. 					//mciSendString("play ZM_BGM repeat", NULL, NULL, NULL);
  1388. 					//mciSendString("play name repeat", NULL, 0, NULL);
  1389. 					zms[i].eating = true;
  1390. 					zms[i].speed = 0;
  1391. 					if (map[row][j].type != 3 && map[row][j].type != 7)
  1392. 						map[row][j].blood--;
  1393. 					//zms[i].frameIndex = 0;
  1394. 				}
  1395. 				if (zms[i].eating && chomp == 0)
  1396. 					chomp = 1;
  1397.  
  1398. 			}
  1399. 			else if (x3 > 830)
  1400. 			{
  1401. 				zms[i].eating = false;
  1402. 				zms[i].speed = 3;
  1403. 			}
  1404. 		}
  1405. 	}
  1406. 	static int chomp_time = 0;
  1407. 	chomp_time++;
  1408. 	if (chomp&&chomp_time>20)
  1409. 	{
  1410. 		chomp_time = 0;
  1411. 		PlaySound("res/audio/chomp.wav", NULL, SND_FILENAME | SND_ASYNC);
  1412. 		//mciSendString("play ZM_BGM", NULL, NULL, NULL);
  1413. 		//printf("1 ");
  1414. 	}
  1415. }
  1416.  
  1417. void checkcars2Zm()
  1418. {
  1419. 	for (int i = 0; i < 5; i++)
  1420. 	{
  1421. 		int carsX = cars[i].x + 70;
  1422. 		for (int j = 0; j < ZM_MAX; j++)
  1423. 		{
  1424. 			if (zms[j].used && zms[j].dead == false && zms[j].row == i)
  1425. 			{
  1426. 				int zmX = zms[j].x + 80;
  1427. 				if (carsX > zmX && cars[i].used)
  1428. 				{
  1429. 					if (cars[i].move == false)
  1430. 						cars[i].move = true;
  1431. 					else
  1432. 					{
  1433. 						killCount++;
  1434. 						zms[j].dead = true;
  1435. 						zms[j].speed = 0;
  1436. 						zms[j].frameIndex = 0;
  1437. 					}
  1438. 				}
  1439. 			}
  1440. 		}
  1441. 	}
  1442. }
  1443.  
  1444. void collistionCheck()
  1445. {
  1446. 	//子弹对僵尸的检测
  1447. 	checkBullet2Zm();
  1448. 	//僵尸对植物的检测
  1449. 	checkZM2Zhiwu();
  1450. 	//爆炸对植物的检测
  1451. 	checkBoom2Zm();
  1452. 	//小推车对僵尸的检测
  1453. 	checkcars2Zm();
  1454. }
  1455.  
  1456. void updatecar()
  1457. {
  1458. 	for (int i = 0; i < 5; i++)
  1459. 	{
  1460. 		if (cars[i].move)
  1461. 		{
  1462. 			cars[i].x += 20;
  1463. 		}
  1464. 		if (cars[i].x > Wide)
  1465. 		{
  1466. 			cars[i].move = false;
  1467. 			cars[i].used = false;
  1468. 		}
  1469. 	}
  1470. }
  1471.  
  1472. void updateGame()
  1473. {
  1474. 	srand((unsigned)time(NULL));
  1475. 	static int count = 0;
  1476. 	count++;
  1477. 	if (count > 4)
  1478. 	{
  1479. 		count = 0;
  1480. 		for (int i = 0; i < 5; i++)
  1481. 		{
  1482. 			for (int j = 0; j < 9; j++)
  1483. 			{
  1484. 				if (map[i][j].type > 0)
  1485. 				{
  1486. 					map[i][j].frameIndex++;
  1487. 					int PlantType = map[i][j].type - 1;
  1488. 					int index = map[i][j].frameIndex;
  1489. 					if (map[i][j].shoot)
  1490. 					{
  1491. 						if (map[i][j].frameIndex > 1)
  1492. 						{
  1493. 							map[i][j].shoot = false;
  1494. 						}
  1495. 					}
  1496. 					else
  1497. 					{
  1498. 						if (imgPlant[PlantType][index] == NULL)
  1499. 						{
  1500. 							map[i][j].frameIndex = 0;
  1501. 						}
  1502. 					}
  1503. 				}
  1504. 			}
  1505. 		}
  1506. 	}
  1507.  
  1508. 	createSunshine();//创建阳光
  1509. 	updatSunshine();//更新阳光状态
  1510.  
  1511. 	createZM();//创建僵尸
  1512. 	updateZM();//更新僵尸状态
  1513.  
  1514. 	shoot();//发射豌豆子弹
  1515. 	updateBullets();//更新子弹
  1516. 	collistionCheck();//实现豌豆子弹的碰撞检测
  1517.  
  1518. 	updatecar();//更新小推车
  1519. }
  1520.  
  1521. void menu()
  1522. {
  1523. 	mciSendString("play BGM", NULL, NULL, NULL);
  1524.  
  1525. 	IMAGE imgBg, imgMenu1, imgMenu2;
  1526. 	loadimage(&imgBg, "res/menu.png");
  1527. 	loadimage(&imgMenu1, "res/menu2.png");
  1528. 	loadimage(&imgMenu2, "res/menu1.png");
  1529. 	int flag = 0;
  1530.  
  1531. 	while (1)
  1532. 	{
  1533. 		BeginBatchDraw();
  1534. 		putimage(0, 0, &imgBg);
  1535. 		putimagePNG(474, 75, flag ? &imgMenu1 : &imgMenu2);
  1536.  
  1537. 		ExMessage msg;
  1538. 		if (peekmessage(&msg))
  1539. 		{
  1540. 			if (msg.message == WM_LBUTTONDOWN &&
  1541. 				msg.x > 474 && msg.x < 474 + 300 &&
  1542. 				msg.y>75 && msg.y < 75 + 140)
  1543. 			{
  1544. 				flag = 1;
  1545. 				PlaySound("res/audio/bleep.wav", NULL, SND_FILENAME | SND_ASYNC);
  1546. 			}
  1547. 			else if (msg.message == WM_LBUTTONUP && flag == 1)
  1548. 			{
  1549. 				EndBatchDraw();
  1550. 				break;
  1551. 			}
  1552. 		}
  1553. 		EndBatchDraw();
  1554. 	}
  1555. }
  1556.  
  1557. void viewScence()
  1558. {
  1559. 	mciSendString("play BGM3", NULL, NULL, NULL);
  1560.  
  1561. 	//开头场景时僵尸的位置
  1562. 	vector2 points[9] = {
  1563. 		{550,80},{530,160},{630,170},{530,200},{515,270},
  1564. 		{565,370},{605,340},{705,280},{690,340}
  1565. 	};
  1566. 	int index[9];
  1567. 	for (int i = 0; i < 9; i++)
  1568. 	{
  1569. 		index[i] = rand() % 11;
  1570. 	}
  1571.  
  1572. 	int count = 0;
  1573. 	for (int i = 0; i >= -500; i-=3)
  1574. 	{
  1575. 		BeginBatchDraw();
  1576. 		putimage(i, 0, &img);
  1577.  
  1578. 		count++;
  1579. 		for (int k = 0; k < 9; k++)
  1580. 		{
  1581. 			putimagePNG(points[k].x + 500 + i,
  1582. 				points[k].y, &imgZmStand[index[k]]);
  1583. 			if (count >= 10)
  1584. 			{
  1585. 				index[k] = (index[k] + 1) % 11;
  1586. 			} 
  1587. 		}
  1588. 		if (count >= 10)count = 0;
  1589. 		EndBatchDraw();
  1590. 		Sleep(10);
  1591. 	}
  1592. 	
  1593. 	for (int i = 0; i < 60; i++)
  1594. 	{
  1595. 		BeginBatchDraw();
  1596.  
  1597. 		putimage(-500, 0, &img);
  1598. 		for (int k = 0; k < 9; k++)
  1599. 		{
  1600. 			putimagePNG(points[k].x, points[k].y, &imgZmStand[index[k]]);
  1601. 			index[k] = (index[k] + 1) % 11;
  1602. 		}
  1603.  
  1604. 		EndBatchDraw();
  1605. 		Sleep(50);
  1606. 	}
  1607.  
  1608. 	for (int i = -500; i <= -150; i += 2)
  1609. 	{
  1610. 		BeginBatchDraw();
  1611.  
  1612. 		putimage(i, 0, &img);
  1613. 		count++;
  1614. 		for (int k = 0; k < 9; k++)
  1615. 		{
  1616. 			putimagePNG(points[k].x + 500 + i,
  1617. 				points[k].y, &imgZmStand[index[k]]);
  1618. 			if (count >= 10)
  1619. 			{
  1620. 				index[k] = (index[k] + 1) % 11;
  1621. 			}
  1622. 			if (count >= 10) count = 0;
  1623. 		}
  1624. 		EndBatchDraw();
  1625. 		Sleep(10);
  1626. 	}
  1627.  
  1628. }
  1629.  
  1630. void barsDown()
  1631. {
  1632. 	int height = imgBar.getheight();
  1633. 	for (int y = -height; y <= -10; y++)
  1634. 	{
  1635. 		BeginBatchDraw();
  1636.  
  1637. 		putimagePNG(80, y, &imgBar);
  1638. 		for (int i = 0; i < PLANT_COUNT + 2; i++)
  1639. 		{
  1640. 			putimagePNG(163 + i * 65, y + 10, &imgCards[i]);
  1641. 		}
  1642. 		
  1643. 		EndBatchDraw();
  1644. 		Sleep(10);
  1645. 	}
  1646. 	for (int i = 0; i < 5; i++)
  1647. 	{
  1648. 		putimagePNG(50, 100 + i * 100 - 15, &imgcar);
  1649. 	}
  1650. 	mciSendString("close BGM3", NULL, 0, NULL);
  1651. 	mciSendString("play BGM4", NULL, NULL, NULL);
  1652. 	Sleep(1000);
  1653. 	putimagePNG(450 - imgready.getwidth()/2, 300 - imgready.getheight()/2, &imgready);
  1654. 	Sleep(200);
  1655. }
  1656.  
  1657. void failScence()
  1658. {
  1659. 	for (int i = -150; i <= -100; i += 1)
  1660. 	{
  1661. 		BeginBatchDraw();
  1662. 		//zmSpeed = 6;
  1663. 		putimage(i, 0, &img);
  1664. 		//show();
  1665. 		drawZm();
  1666. 		//updateGame();
  1667. 		createZM();//创建僵尸
  1668. 		updateZM();//更新僵尸状态
  1669. 		
  1670. 		EndBatchDraw();
  1671. 		Sleep(50);
  1672. 	}
  1673. }
  1674.  
  1675. bool checkOver()
  1676. {
  1677. 	int ret = false;
  1678. 	if (gameStatus == WIN)
  1679. 	{
  1680. 		mciSendString("close BGM2", NULL, NULL, NULL);
  1681.  
  1682. 		loadimage(0, "res/win2.png");
  1683. 		mciSendString("play res/win.mp3", 0, 0, 0);
  1684. 		ret = true;
  1685. 	}
  1686. 	else if (gameStatus == FAIL)
  1687. 	{
  1688. 		mciSendString("close BGM2", NULL, NULL, NULL);
  1689.  
  1690. 		mciSendString("play res/lose.mp3", 0, 0, 0);
  1691. 		failScence();
  1692. 		Sleep(500);
  1693. 		loadimage(0, "res/fail2.png");
  1694. 		ret = true;
  1695. 	}
  1696. 	return ret;
  1697. }
  1698.  
  1699. void OpeningAnimation()
  1700. {
  1701. 	mciSendString("play res/audio/yuanshen.mp3", 0, 0, 0);
  1702. 	for (int i = 0; i < 29; i++)
  1703. 	{
  1704. 		BeginBatchDraw();
  1705. 		putimage(-148, -35, &imgopena[i]);
  1706.  
  1707. 		EndBatchDraw();
  1708. 		Sleep(50);
  1709. 	}
  1710. 	Sleep(4000);
  1711. }
  1712.  
  1713. int main()
  1714. {
  1715. 	//加载游戏画面
  1716. 	gameInit();
  1717. 	//开场动画
  1718. 	OpeningAnimation();
  1719. 	menu();
  1720. 	mciSendString("close BGM", NULL, 0, NULL);
  1721. 	//游戏开始时的场景切换
  1722. 	viewScence();
  1723. 	//游戏开始时卡牌和卡牌槽的下落
  1724. 	barsDown();
  1725. 	int timer = 0;
  1726. 	bool flag = true;
  1727. 	
  1728. 	mciSendString("play BGM2 repeat", NULL, NULL, NULL);
  1729. 	while (1)
  1730. 	{
  1731. 		//用户操作
  1732. 		userClick();
  1733. 		//游戏更新时间
  1734. 		timer += getDelay();
  1735. 		if (timer > 20)
  1736. 		{
  1737. 			flag = true;
  1738. 			timer = 0;
  1739. 		}
  1740. 		if (flag)
  1741. 		{
  1742. 			flag = false;
  1743. 			//绘制游戏画面
  1744. 			show();
  1745. 			//更新游戏画面
  1746. 			updateGame();
  1747. 			if(checkOver()) break;
  1748. 		}
  1749. 	}
  1750. 	closegraph;
  1751. 	system("pause");
  1752. 	return 0;
  1753. }

game.h文件

  1. #pragma once
  2. #define _CRT_SECURE_NO_WARNINGS 1
  3.  
  4. #include<easyx.h>
  5. #include<stdio.h>
  6. #include<time.h>
  7. #include<math.h>
  8. #include"tools.h"
  9. #include<mmsystem.h>
  10. #include"vector2.h"
  11. #pragma comment(lib,"winmm.lib")
  12.  
  13. #define Wide 900
  14. #define Hight 600
  15. #define KUNKUN_BLOOD 100//非坚果植物的血量
  16. #define ORDINARY_ZM_BLOOD 1270*3//僵尸血量
  17. #define ZM_MAX 1024//创建僵尸的最大数量
  18.  
  19. enum {
  20. 	WAN_DOU, TAI_YANG, LA_JIAO, KUN_KUN, JIAN_GUO,
  21. 	HAN_BING_WAN_DOU, YING_TAO, SAN_TOU_WAN_DOU, PLANT_COUNT
  22. };
  23. IMAGE img;//地图
  24. IMAGE imgBar;//卡牌槽
  25. IMAGE imgCards[PLANT_COUNT + 2];//卡牌
  26. IMAGE* imgPlant[PLANT_COUNT + 2][20];//植物动作
  27. IMAGE imgZmStand[11];//开场僵尸的站立
  28. IMAGE imgcar;//小推车
  29. IMAGE imgopena[29];//开场动画
  30. IMAGE imgready;
  31. IMAGE imgnotify;
  32.  
  33. int curX, curY;//当前选中植物，在移动过程中植物的坐标
  34. int curPlant;// 0：没有选中，1：选中了第一种种植物
  35. int sunshine;
  36.  
  37. enum { GOING, WIN, FAIL };
  38. int killCount;//已经杀掉的僵尸个数
  39. int zmCount;//已经出现的僵尸个数
  40. int zmCount_max = 1;//每波出现的僵尸数量
  41. int gameStatus;//游戏的状态
  42. int wava_count = 1;//第wava_count波僵尸
  43.  
  44. struct plant
  45. {
  46. 	int type;//植物类型
  47. 	int frameIndex;//植物动作帧
  48. 	//bool catched;//是否被吃
  49. 	int blood;//血量
  50.  
  51. 	int shootTime;//植物子弹的射速
  52.  
  53. 	int timer;//阳光生产的时间
  54. 	int x, y;//植物坐标
  55. 	bool shoot;//判断植物是否处于发射状态
  56. };
  57. struct plant map[5][9];
  58.  
  59. enum { SUNSHINE_DOWN, SUNSHINE_GROUND, SUNSHINE_COLLECT, SUNSHINE_RPODUCT };
  60.  
  61. struct sunshineBall
  62. {
  63. 	int x, y;
  64. 	int frameIndex;//当前显示的图片帧序号
  65. 	int destY;//飘落的目标位置的y坐标
  66. 	bool used;//是否在使用
  67. 	int timer;
  68.  
  69. 	float xoff;
  70. 	float yoff;
  71.  
  72. 	float t;//贝塞尔曲线的时间点
  73. 	vector2 p1, p2, p3, p4;
  74. 	vector2 pCur;//当前时刻阳光球的位置
  75. 	float speed;
  76. 	int status;
  77. };
  78.  
  79. //10个阳光球
  80. struct sunshineBall balls[10];
  81. IMAGE imgSunshineBall[29];
  82.  
  83. struct zm
  84. {
  85. 	int x, y;//僵尸的坐标
  86. 	int frameIndex;//僵尸动作帧
  87. 	bool used;//僵尸是否被使用
  88. 	int speed;//僵尸每一次移动的位移
  89. 	int row;//僵尸所在行
  90. 	int blood;//僵尸血量
  91. 	bool dead;//僵尸是否死亡
  92. 	bool eating;//僵尸是否在吃植物
  93. 	bool boom;//僵尸是否被炸死
  94. 	int zmSpeed;//僵尸的移动快慢
  95. };
  96. struct zm zms[ZM_MAX];
  97. IMAGE imgZm[22];
  98. IMAGE imgZMDead[38];
  99. IMAGE imgzmboom[20];
  100. IMAGE imgZMEat[21];
  101.  
  102. //子弹
  103. struct bullet
  104. {
  105. 	double x, y;//子弹的坐标
  106. 	bool used;//子弹是否被使用
  107. 	int row;//子弹所在行
  108. 	int speed;//子弹速度
  109. 	bool blast;//是否发生爆炸
  110. 	int frameIndex;//帧序号
  111. };
  112. //坤坤
  113. struct bullet bullets[10000];
  114. IMAGE imgBulletNormal;
  115. IMAGE imgBallBlast[4];
  116. //豌豆
  117. struct bullet bullets_wandou[200];
  118. IMAGE imgBallBlast_wandou[4];
  119. IMAGE imgBulletNormal_wandou;
  120. //寒冰豌豆
  121. struct bullet bullets_hanbing[200];
  122. IMAGE imgBallBlast_hanbing[4];
  123. IMAGE imgBulletNormal_hanbing;
  124. //三头豌豆
  125. struct bullet bullets_santou[200];
  126. IMAGE imgBallBlast_santou[4];
  127. IMAGE imgBulletNormal_santou;
  128. int direction_santou[200];
  129. int row_santou[200];//三头豌豆发射子弹时所在的行数
  130. enum { MIDDLE, UP, DOWN };
  131.  
  132. //小推车
  133. struct car
  134. {
  135. 	bool move;//是否处于移动状态
  136. 	int x, y;//位置
  137. 	bool used;//是否被使用
  138. };
  139. struct car cars[5];
  140. /*
  141. * 增加植物的步骤：
  142. * 1. 创建子弹的相关变量
  143. * 2. 加载植物子弹图片
  144. * 3. 渲染植物子弹
  145. * 4. 发射植物子弹
  146. * 5. 检查植物子弹与僵尸的碰撞
  147. * 6. 更新植物子弹
  148. */

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. }

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. vector2 calcBezierPoint(float t, vector2 p0, vector2 p1, vector2 p2, vector2 p3);

tools.cpp文件（透明贴图）

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

tools.h文件 

  1. #pragma once
  2. #include <graphics.h>
  3.  
  4. void putimagePNG(int  picture_x, int picture_y, IMAGE* picture);
  5. int getDelay();
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/626560
推荐阅读
相关标签

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

  

闽ICP备14008679号