• C语言游戏实战（12）：植物大战僵尸（坤版）

    植物大战僵尸

    前言：

    本游戏使用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
    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
    5. #include
    6. #include
    7. #include
    8. #include"tools.h"
    9. #include
    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 
    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 
    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 
    3.  
    4. void putimagePNG(int  picture_x, int picture_y, IMAGE* picture);
    5. int getDelay();
  • 相关阅读:
    使用Spring+Postman实现数据交互
    Python 中 key 参数的含义及用法
    NBU计算机大三下期末考
    计算机视觉：驾驶员疲劳检测
    6-羧基四甲基罗丹明，CAS号: 91809-67-5
    JAVA 读取写入文件
    融云「百幄」之数字人，升级交互体验的「新同事」
    【uni-app】总结uni-app订单支付和打包发布
    Docker-07：Docker网络管理
    DockerFile的使用
  • 原文地址：https://blog.csdn.net/weixin_58252863/article/details/138923241