• 用VS开发一款“飞机大战“单机游戏＜C++＞

    显示界面如上图所示

    自己找的背景和飞机素材,先将素材奉上.

     

    接下来我先简单分析一下这个单机游戏的运行逻辑:

    就像显示界面所显示的那样,我们想要实现的是自己的飞机在发射子弹(子弹在上图没显示),然后当子弹射到敌方飞机,这里设置了两种类型的飞机,如果读者想定义更多类型的,直接添加属性就可以.当子弹射到飞机的时候,飞机的血量减少,就像CS一样,并不一定是一发子弹就死亡,读者可以根据自己喜欢去设置,博主这里设置大飞机的血量是3发子弹,而小飞机的血量是1发子弹,也就是说,当有3发子弹射到大飞机的时候,大飞机就消失,一发子弹小飞机消失.至于其他的动态效果,博主这里暂时不做介绍.具体往下看:

    面向对象开发,每一个对象我们都需要给他设置相对应的对象属性,在语言当中,我们将其设置成结构体就可以:

    1. enum My
    2. {
    3. 	WIDTH = 500,
    4. 	HIGHT = 700,
    5. 	BULLET_NUM = 100,//玩家子弹数量
    6. 	ENEMY_NUM = 10,//敌机的数量
    7. 	BIG,
    8. 	SMALL,
    9. };
    10. struct Plane
    11. {
    12. 	int x;
    13. 	int y;
    14. 	bool live;//是否存活
    15. 	int width;
    16. 	int hight;
    17. 	int hp;
    18. 	int type;//敌机类型  big small
    19.  
    20. }player,bull[BULLET_NUM],enemy[ENEMY_NUM];

    首先设定了一个联合,用于设置弹出窗口的基本参数和其他属性. 

    上面是不是把敌方飞机,自己飞机和自己发射的子弹都定义成了一个结构体.下面我们就可以直接用了.

    (x,y)代表的是对象在窗口当中的坐标,width和hight是对象自身的尺寸,而hp是血量,type是博主自己定义了两种敌机类型.布尔类型live判断飞机是否存活状态.

    第一步我们应该是要先创建图形窗口

    1. 	/*测试
    2. circle(50, 50, 50);//画空心圆
    3. setfillcolor(GREEN);//圆的颜色
    4. fillcircle(100, 100, 50);///实心⚪*/
    5. 	//创建图形窗口
    6. 	initgraph(WIDTH, HIGHT,SHOWCONSOLE);//宽长

    initgraph()函数直接用

    第二步加载窗口里面使用到的图片   //无论什么时候用,我们都要进行图片加载的,因此此处我们将其设定到一个函数下,方便之后也可以随时添加和删除.

    1. //把图片加载进程序
    2. IMAGE bk;//背景图
    3. //保存玩家图片
    4. IMAGE img_role;
    5. //保存子弹
    6. IMAGE img_bull;
    7. //
    8. IMAGE img_enemy[4];
    9. void loadImg()
    10. {
    11. 	//加载图片
    12. 	loadimage(&bk, "D:/program/飞机大战/images/bk.png");
    13. 	//加载玩家图片
    14. 	loadimage(&img_role, "D:/program/飞机大战/images/fly.png");
    15. 	//加载子弹图片
    16. 	loadimage(&img_bull, "D:/program/飞机大战/images/子弹.jpg");
    17. 	//加载敌机的图片
    18. 	loadimage(&img_enemy[0], "D:/program/飞机大战/images/enemy1.png");
    19. 	loadimage(&img_enemy[1], "D:/program/飞机大战/images/enemy2.png");
    20. 	//loadimage(&img_enemy[2], "D:/program/飞机大战/images/enemy3.jpg");
    21. 	//loadimage(&img_enemy[3], "D:/program/飞机大战/images/enemy4.jpg");
    22. }

    IMAGE 是easyx里面的一个参数,直接用

    此案例当中,需要我们加载的图片有背景图,自己飞机图,子弹图,敌方飞机1和敌方飞机2,如果读者也自己添加第三台和第四台敌机,也可以直接添加,不过要注意,当一种对象,存在多个类型的时候,要采用数组将其存储,方便之后进行使用.

    第三步,要干嘛?设置好窗口了,加载完图片了,是不是要把图片添加进去了?

    那图片添加到哪里去?怎么添加?哪一种图片应该添加在哪里呢?

    这里我们是不是首先要初始化一下图片的基本属性?of course,买衣服我总的知道我适合穿多大尺码的衣服吧?

    1. void gameinit()//初始化数据
    2. {
    3. 	player.x = WIDTH / 2;
    4. 	player.y = HIGHT - 120;
    5. 	player.live = true;
    6. 	//初始化子弹
    7. 	for (int i = 0; i < BULLET_NUM; i++)
    8. 	{
    9. 		bull[i].x = 0;
    10. 		bull[i].y = 0;
    11. 		bull[i].live = false;
    12. 	}
    13. 	//初始化敌机
    14. 	for (int i = 0; i < ENEMY_NUM; i++)
    15. 	{
    16. 		enemy[i].live = false;
    17. 		enemyHP(i);
    18. 	}
    19. }

    想想我们一共有几个对象,去除背景图片不需要我们在这里初始化之外,另外就是自己飞机,敌方飞机和子弹三个对象.那么我们就定义一个函数,用于初始化这些对象的第一属性.

    在初始化敌方飞机的时候,博主之前把敌方飞机设置有两种类型,那么这两种类型飞机的基本属性一定有一些是不一样的呀,要不然怎么叫做2呢?

    博主这里主要用飞机的大小和血量来区分这两种飞机.具体看enemyHP()函数

    1. void enemyHP(int i)
    2. {
    3. 	int flag = rand() % 10;
    4. 	if (flag>=0 && flag<=2)//0-9
    5. 	{
    6. 		enemy[i].type = BIG;
    7. 		enemy[i].hp = 3;
    8. 		enemy[i].width = 100;
    9. 		enemy[i].hight = 100;
    10. 	}
    11. 	else
    12. 	{
    13. 		enemy[i].type = SMALL;
    14. 		enemy[i].hp = 1;
    15. 		enemy[i].width = 50;
    16. 		enemy[i].hight = 50;
    17. 	}
    18.  
    19. }

    在这个函数当中,我们要注意,大飞机和小飞机出现的次数是不是正常情况下是不一样的?比如小飞机出现了5次,而大飞机才出现一次这样,当然敌飞机出现肯定不是我们可以控制的,它肯定是随机出现的,所以这里我们采用一个随机范围,如果在0-2之间就出现大飞机,3-9之间小飞机,这样是不是小飞机的概率要高于大飞机.其余的进入条件之内直接初始化就可以了.

    第四步,上面我们把全部图片都加载好,然后对象都进行了初始化,接下来我们要干嘛?

    那肯定是要将这些图片绘制到对应的窗口坐标上了!!!!!!!

    1. void gameDraw()
    2. {
    3. 	loadImg();
    4. 	//把背景贴在窗口上
    5. 	putimage(0, 0, &bk);
    6. 	putimage(player.x, player.y, &img_role,SRCINVERT);
    7. 	for (int i = 0; i < BULLET_NUM; i++)
    8. 	{
    9. 		if (bull[i].live)
    10. 		{
    11. 			putimage(bull[i].x, bull[i].y, &img_bull, SRCINVERT);
    12. 		}
    13. 	}
    14. 	//绘制敌机
    15. 	for (int i = 0; i < ENEMY_NUM; i++)
    16. 	{
    17. 		if (enemy[i].live)
    18. 		{
    19. 			if(enemy[i].type==SMALL)
    20. 			putimage(enemy[i].x, enemy[i].y, &img_enemy[0], SRCINVERT);//x和y是飞机在窗口中的坐标
    21. 			else
    22. 			putimage(enemy[i].x, enemy[i].y, &img_enemy[1], SRCINVERT);
    23. 		}
    24. 	}
    25.  
    26. }

    绘制背景,绘制自己飞机,绘制子弹,绘制敌方飞机都采用putimage()函数就可以了

    需要注意的有可能就是对于敌方飞机和子弹只有live是true的时候才绘制,而对于敌方飞机还区分了两种类型的飞机,加一个if-else输出对应的敌方飞机就可以了;

    第五步,第四步我们绘制的图片是个啥,是初始化的位置,是一个静态的图,我们要实现的动态图,那接下来我们应该干嘛????????

    当然是让子弹,自己飞机和敌方飞机都动起来了,也就是创建动画

    首先让自己飞机动起来

    1. void playermove(int speed)
    2. {
    3. #if 0
    4.  
    5. 	if (_kbhit) {
    6. 		//有两种方式
    7. 	//1,getch()  阻塞函数,和scanf一样,如果没有输入,就会卡住程序,一直等待输入,
    8. 	//这个函数不是c语言标准函数,需要头文件<conio.h>
    9. 		char key = _getch();
    10. 		switch (key)
    11. 		{
    12. 		case 'w':
    13. 		case 'W':
    14. 			player.y -= speed;
    15. 			break;
    16. 		case 's':
    17. 		case 'S':
    18. 			player.y += speed;
    19. 			break;
    20. 		case 'a':
    21. 		case 'A':
    22. 			player.x -= speed;
    23. 			break;
    24. 		case 'd':
    25. 		case 'D':
    26. 			player.x += speed;
    27. 			break;
    28. 		default:
    29. 			break;
    30. 		}
    31. 	}
    32. }
    33. #elif 1
    34. 	//2.使用Windows函数获取键盘输入
    35. 	//非阻塞函数,特别流畅
    36. 	//如果用字母,必须要用大写,大写可以识别大小写
    37. 	if (GetAsyncKeyState(VK_UP) || GetAsyncKeyState('W'))
    38. 	{
    39. 		if(player.y > 0)
    40. 			player.y -= speed;
    41. 	}
    42. 	if (GetAsyncKeyState(VK_DOWN) || GetAsyncKeyState('S'))
    43. 	{
    44. 		if (player.y < HIGHT-78)//78是飞机的高度
    45. 		player.y += speed;
    46. 	}
    47. 	if (GetAsyncKeyState(VK_LEFT) || GetAsyncKeyState('A'))
    48. 	{
    49. 		if(player.x+59>0)// 119/2  = 59是控制飞机子弹在左右边界的时候可以打到敌机
    50. 		player.x -= speed;
    51. 	}
    52. 	if (GetAsyncKeyState(VK_RIGHT) || GetAsyncKeyState('D'))
    53. 	{
    54. 		if (player.x-59 < WIDTH-119)//119是飞机的宽度
    55. 		player.x += speed;
    56. 	}
    57. #endif // 0
    58. 	
    59. 	if (GetAsyncKeyState(VK_SPACE) && Timer(100,1))//
    60. 	{
    61. 		//创建一个子弹
    62. 		createBullet();
    63. 	}
    64.  
    65. }

    这里尝试了两种让自己飞机动起来的方法,第一种是_kbhit,如果按下键盘,判断按下的是什么键,如果wsad当中的一个则执行对应的操作,但是这种方法运行之后,你会发现很卡,就是一个帧当中只能运行一个动作,不能运行右上这样的操作,关键是很卡

    所以我们用了第二种方案非阻塞函数GetAsyncKeyState(),分别对键盘当中的上下左右和英文字符当中的wasd进行case分析,其他不变,此处要注意的有可能就是要控制自己的飞机运行,只能在窗口范围内运行,为其设定边界就可以.

    最后还加了一个和子弹相关的函数,如果说按下空格键了,就要发射子弹了,同时这里结合了一个定时器的函数,用于控制子弹发射的速度100ms,不要再100ms内发射两颗子弹,防止出现子弹重叠的现象.

    1. bool Timer(int ms, int id)//定时器
    2. {
    3. 	static DWORD t[10];
    4. 	if (clock() - t[id] > ms)
    5. 	{
    6. 		t[id] = clock();
    7. 		return true;
    8. 	}
    9. 	return false;
    10. }

    定义了一个无符号长整形的时间数组,是因为本案例当中有多个函数都用到了定时器函数.

    自己飞机动起来,接下来就很明显了,让子弹跟着发射,对不对????也就是进入createBullet()函数

    1. void createBullet()
    2. {
    3. 	for (int i = 0; i < BULLET_NUM; i++)
    4. 	{
    5. 		if (!bull[i].live)
    6. 		{
    7. 			bull[i].x = player.x+59;
    8. 			bull[i].y = player.y;
    9. 			bull[i].live = true;
    10. 			break;
    11. 		}
    12. 	}
    13. }

     刚开始子弹都是的状态都是false,然后条件正确后,初始化了子弹的第一个位置发射出来,然后将子弹的状态改为true.跳出这一个,执行下一个,要注意此时只是静态化绘制了子弹,还没有动起来,那么接下来就让子弹垂直向上运行就好.

    1. void Bullmove(int speed)
    2. {
    3. 	for (int i = 0; i < BULLET_NUM; i++)
    4. 	{
    5. 		if (bull[i].live)
    6. 		{
    7. 			bull[i].y -=speed;
    8. 			if (bull[i].y < 0)
    9. 			{
    10. 				bull[i].live = false;
    11. 			}
    12. 		}
    13. 	}
    14. }

    如果子弹到了最上方了,改变子弹的状态为false,继续循环

    自己飞机和子弹都结束了,接下来就是敌方飞机了

    1. //产生敌机
    2. void createenemy()
    3. {
    4. 	for (int i = 0; i < ENEMY_NUM; i++)
    5. 	{
    6. 		if (!enemy[i].live)
    7. 		{
    8. 			enemy[i].live = true;
    9. 			enemy[i].x = rand()%(WIDTH-75);
    10. 			enemy[i].y = 0;
    11. 			enemyHP(i);
    12. 			printf("pos(%d,%d) %d %d\n", enemy[i].x, enemy[i].y, enemy[i].live, enemy[i].hp);
    13. 			break;
    14. 		}
    15. 	}
    16. }

    在窗口的最上面随机产生敌机,敌机也要动的.是不是参考子弹的就可以了,如下

    1. //敌机的移动
    2. void enemymove(int speed)
    3. {
    4. 	for (int i = 0; i < ENEMY_NUM; i++)
    5. 	{
    6. 		if (enemy[i].live)
    7. 		{
    8. 			enemy[i].y += speed;
    9.  
    10. 			if (enemy[i].y > HIGHT)
    11. 			{
    12. 				enemy[i].live = false;
    13. 			}
    14. 		}
    15. 	}
    16. }

     最后就是打飞机,当子弹到了敌方飞机的范围内是,敌方飞机就消失

    1. //开始打飞机
    2. void playplane()
    3. {
    4. 	for (int i = 0; i < ENEMY_NUM; i++)
    5. 	{
    6. 		if (!enemy[i].live)
    7. 			continue;
    8. 		for (int k = 0; k < BULLET_NUM; k++)
    9. 		{
    10. 			if (!bull[k].live)
    11. 				continue;
    12. 			if (bull[k].x > enemy[i].x && bull[k].x<enemy[i].x + enemy[i].width
    13. 				&& bull[k].y>enemy[i].y && bull[k].y < enemy[i].y + enemy[i].hight)//子弹在飞机的界面内
    14. 				//则代表子弹打住了飞机
    15. 			{
    16. 				bull[k].live = false;
    17. 				enemy[i].hp--;
    18. 			}
    19. 		}
    20. 		if (enemy[i].hp == 0)
    21. 		{
    22. 			enemy[i].live = false;
    23. 		}
    24.  
    25. 	}
    26. }

    1. 			if (bull[k].x > enemy[i].x && bull[k].x<enemy[i].x + enemy[i].width
    2. 				&& bull[k].y>enemy[i].y && bull[k].y < enemy[i].y + enemy[i].hight)//子弹在飞机的界面内
    3. 				//则代表子弹打住了飞机

    这是个啥?意思是当子弹到了敌方飞机那个矩形图之内,条件就正确

     这里要注意大飞机血量是3,小飞机血量是1,一颗子弹一格血量.当血量为0,则飞机死亡

    最后一步,上主函数

    1. int main()
    2. {
    3. 	/*测试
    4. circle(50, 50, 50);//画空心圆
    5. setfillcolor(GREEN);//圆的颜色
    6. fillcircle(100, 100, 50);///实心⚪*/
    7. 	//创建图形窗口
    8. 	initgraph(WIDTH, HIGHT,SHOWCONSOLE);//宽长
    9. 	gameinit();
    10. 	//双缓冲绘图
    11. 	BeginBatchDraw();
    12. 	while (1)
    13. 	{
    14. 		gameDraw();
    15. 		FlushBatchDraw();
    16. 		playermove(5);
    17. 		Bullmove(5);
    18. 		//防止飞机全部一起出来
    19.  
    20. 		if (Timer(500,0))
    21. 		{
    22. 			//创建一个飞机
    23. 			createenemy();
    24. 		}
    25. 		if (Timer(20, 2))
    26. 		{
    27. 			enemymove(1);
    28. 		}
    29. 		playplane();
    30. 	}
    31. 	EndBatchDraw();
    32. 	return 0;
    33. }

    注意这里的

    1. //双缓冲绘图
    2. 	BeginBatchDraw();
    3.  
    4. 	EndBatchDraw();

    是easyx插件里面的一个双缓冲绘图,防止图片在窗口当中出现闪屏

    总代码:

    1. #include<stdio.h>
    2. //图形库,帮助我们新手,快速入门图形编程easyx
    3. #include<graphics.h>
    4. #include<conio.h>
    5. #include<time.h>
    6. enum My
    7. {
    8. 	WIDTH = 500,
    9. 	HIGHT = 700,
    10. 	BULLET_NUM = 100,//玩家子弹数量
    11. 	ENEMY_NUM = 10,//敌机的数量
    12. 	BIG,
    13. 	SMALL,
    14. };
    15. struct Plane
    16. {
    17. 	int x;
    18. 	int y;
    19. 	bool live;//是否存活
    20. 	int width;
    21. 	int hight;
    22. 	int hp;
    23. 	int type;//敌机类型  big small
    24.  
    25. }player,bull[BULLET_NUM],enemy[ENEMY_NUM];
    26.  
    27.  
    28. //把图片加载进程序
    29. IMAGE bk;//背景图
    30. //保存玩家图片
    31. IMAGE img_role;
    32. //保存子弹
    33. IMAGE img_bull;
    34. //
    35. IMAGE img_enemy[4];
    36.  
    37. void loadImg()
    38. {
    39. 	//加载图片
    40. 	loadimage(&bk, "D:/program/飞机大战/images/bk.png");
    41. 	//加载玩家图片
    42. 	loadimage(&img_role, "D:/program/飞机大战/images/fly.png");
    43. 	//加载子弹图片
    44. 	loadimage(&img_bull, "D:/program/飞机大战/images/子弹.jpg");
    45. 	//加载敌机的图片
    46. 	loadimage(&img_enemy[0], "D:/program/飞机大战/images/enemy1.png");
    47. 	loadimage(&img_enemy[1], "D:/program/飞机大战/images/enemy2.png");
    48. 	//loadimage(&img_enemy[2], "D:/program/飞机大战/images/enemy3.jpg");
    49. 	//loadimage(&img_enemy[3], "D:/program/飞机大战/images/enemy4.jpg");
    50. }
    51. bool Timer(int ms, int id)//定时器
    52. {
    53. 	static DWORD t[10];
    54. 	if (clock() - t[id] > ms)
    55. 	{
    56. 		t[id] = clock();
    57. 		return true;
    58. 	}
    59. 	return false;
    60. }
    61. void enemyHP(int i)
    62. {
    63. 	int flag = rand() % 10;
    64. 	if (flag>=0 && flag<=2)//0-9
    65. 	{
    66. 		enemy[i].type = BIG;
    67. 		enemy[i].hp = 3;
    68. 		enemy[i].width = 100;
    69. 		enemy[i].hight = 100;
    70. 	}
    71. 	else
    72. 	{
    73. 		enemy[i].type = SMALL;
    74. 		enemy[i].hp = 1;
    75. 		enemy[i].width = 50;
    76. 		enemy[i].hight = 50;
    77. 	}
    78.  
    79. }
    80.  
    81. void gameinit()//初始化数据
    82. {
    83. 	player.x = WIDTH / 2;
    84. 	player.y = HIGHT - 120;
    85. 	player.live = true;
    86. 	//初始化子弹
    87. 	for (int i = 0; i < BULLET_NUM; i++)
    88. 	{
    89. 		bull[i].x = 0;
    90. 		bull[i].y = 0;
    91. 		bull[i].live = false;
    92. 	}
    93. 	//初始化敌机
    94. 	for (int i = 0; i < ENEMY_NUM; i++)
    95. 	{
    96. 		enemy[i].live = false;
    97. 		enemyHP(i);
    98. 	}
    99. }
    100. //游戏绘制函数
    101. void gameDraw()
    102. {
    103. 	loadImg();
    104. 	//把背景贴在窗口上
    105. 	putimage(0, 0, &bk);
    106. 	putimage(player.x, player.y, &img_role,SRCINVERT);
    107. 	for (int i = 0; i < BULLET_NUM; i++)
    108. 	{
    109. 		if (bull[i].live)
    110. 		{
    111. 			putimage(bull[i].x, bull[i].y, &img_bull, SRCINVERT);
    112. 		}
    113. 	}
    114. 	//绘制敌机
    115. 	for (int i = 0; i < ENEMY_NUM; i++)
    116. 	{
    117. 		if (enemy[i].live)
    118. 		{
    119. 			if(enemy[i].type==SMALL)
    120. 			putimage(enemy[i].x, enemy[i].y, &img_enemy[0], SRCINVERT);//x和y是飞机在窗口中的坐标
    121. 			else
    122. 			putimage(enemy[i].x, enemy[i].y, &img_enemy[1], SRCINVERT);
    123. 		}
    124. 	}
    125.  
    126. }
    127.  
    128. void createBullet()
    129. {
    130. 	for (int i = 0; i < BULLET_NUM; i++)
    131. 	{
    132. 		if (!bull[i].live)
    133. 		{
    134. 			bull[i].x = player.x+59;
    135. 			bull[i].y = player.y;
    136. 			bull[i].live = true;
    137. 			break;
    138. 		}
    139. 	}
    140. }
    141. void Bullmove(int speed)
    142. {
    143. 	for (int i = 0; i < BULLET_NUM; i++)
    144. 	{
    145. 		if (bull[i].live)
    146. 		{
    147. 			bull[i].y -=speed;
    148. 			if (bull[i].y < 0)
    149. 			{
    150. 				bull[i].live = false;
    151. 			}
    152. 		}
    153. 	}
    154. }
    155.  
    156. //角色移动,获取键盘信息,上下左右
    157. void playermove(int speed)
    158. {
    159. #if 0
    160.  
    161. 	if (_kbhit) {
    162. 		//有两种方式
    163. 	//1,getch()  阻塞函数,和scanf一样,如果没有输入,就会卡住程序,一直等待输入,
    164. 	//这个函数不是c语言标准函数,需要头文件<conio.h>
    165. 		char key = _getch();
    166. 		switch (key)
    167. 		{
    168. 		case 'w':
    169. 		case 'W':
    170. 			player.y -= speed;
    171. 			break;
    172. 		case 's':
    173. 		case 'S':
    174. 			player.y += speed;
    175. 			break;
    176. 		case 'a':
    177. 		case 'A':
    178. 			player.x -= speed;
    179. 			break;
    180. 		case 'd':
    181. 		case 'D':
    182. 			player.x += speed;
    183. 			break;
    184. 		default:
    185. 			break;
    186. 		}
    187. 	}
    188. }
    189. #elif 1
    190. 	//2.使用Windows函数获取键盘输入
    191. 	//非阻塞函数,特别流畅
    192. 	//如果用字母,必须要用大写,大写可以识别大小写
    193. 	if (GetAsyncKeyState(VK_UP) || GetAsyncKeyState('W'))
    194. 	{
    195. 		if(player.y > 0)
    196. 			player.y -= speed;
    197. 	}
    198. 	if (GetAsyncKeyState(VK_DOWN) || GetAsyncKeyState('S'))
    199. 	{
    200. 		if (player.y < HIGHT-78)//78是飞机的高度
    201. 		player.y += speed;
    202. 	}
    203. 	if (GetAsyncKeyState(VK_LEFT) || GetAsyncKeyState('A'))
    204. 	{
    205. 		if(player.x+59>0)// 119/2  = 59是控制飞机子弹在左右边界的时候可以打到敌机
    206. 		player.x -= speed;
    207. 	}
    208. 	if (GetAsyncKeyState(VK_RIGHT) || GetAsyncKeyState('D'))
    209. 	{
    210. 		if (player.x-59 < WIDTH-119)//119是飞机的宽度
    211. 		player.x += speed;
    212. 	}
    213. #endif // 0
    214. 	
    215. 	if (GetAsyncKeyState(VK_SPACE) && Timer(100,1))//
    216. 	{
    217. 		//创建一个子弹
    218. 		createBullet();
    219. 	}
    220.  
    221. }
    222. //产生敌机
    223. void createenemy()
    224. {
    225. 	for (int i = 0; i < ENEMY_NUM; i++)
    226. 	{
    227. 		if (!enemy[i].live)
    228. 		{
    229. 			enemy[i].live = true;
    230. 			enemy[i].x = rand()%(WIDTH-75);
    231. 			enemy[i].y = 0;
    232. 			enemyHP(i);
    233. 			printf("pos(%d,%d) %d %d\n", enemy[i].x, enemy[i].y, enemy[i].live, enemy[i].hp);
    234. 			break;
    235. 		}
    236. 	}
    237. }
    238.  
    239. //敌机的移动
    240. void enemymove(int speed)
    241. {
    242. 	for (int i = 0; i < ENEMY_NUM; i++)
    243. 	{
    244. 		if (enemy[i].live)
    245. 		{
    246. 			enemy[i].y += speed;
    247.  
    248. 			if (enemy[i].y > HIGHT)
    249. 			{
    250. 				enemy[i].live = false;
    251. 			}
    252. 		}
    253. 	}
    254. }
    255.  
    256. //开始打飞机
    257. void playplane()
    258. {
    259. 	for (int i = 0; i < ENEMY_NUM; i++)
    260. 	{
    261. 		if (!enemy[i].live)
    262. 			continue;
    263. 		for (int k = 0; k < BULLET_NUM; k++)
    264. 		{
    265. 			if (!bull[k].live)
    266. 				continue;
    267. 			if (bull[k].x > enemy[i].x && bull[k].x<enemy[i].x + enemy[i].width
    268. 				&& bull[k].y>enemy[i].y && bull[k].y < enemy[i].y + enemy[i].hight)//子弹在飞机的界面内
    269. 				//则代表子弹打住了飞机
    270. 			{
    271. 				bull[k].live = false;
    272. 				enemy[i].hp--;
    273. 			}
    274. 		}
    275. 		if (enemy[i].hp == 0)
    276. 		{
    277. 			enemy[i].live = false;
    278. 		}
    279.  
    280. 	}
    281. }
    282.  
    283. void showenemy()//测试飞机能不能一直往下面落
    284. {
    285. 	for (int i = 0; i < ENEMY_NUM; i++)
    286. 	{
    287. 		printf("pos(%d,%d) %d %d\n", enemy[i].x, enemy[i].y,enemy[i].live, enemy[i].hp);
    288. 	}
    289. }
    290.  
    291.  
    292.  
    293. int main()
    294. {
    295. 	/*测试
    296. circle(50, 50, 50);//画空心圆
    297. setfillcolor(GREEN);//圆的颜色
    298. fillcircle(100, 100, 50);///实心⚪*/
    299. 	//创建图形窗口
    300. 	initgraph(WIDTH, HIGHT,SHOWCONSOLE);//宽长
    301. 	gameinit();
    302. 	//双缓冲绘图
    303. 	BeginBatchDraw();
    304. 	while (1)
    305. 	{
    306. 		gameDraw();
    307. 		FlushBatchDraw();
    308. 		playermove(5);
    309. 		Bullmove(5);
    310. 		//防止飞机全部一起出来
    311.  
    312. 		if (Timer(500,0))
    313. 		{
    314. 			//创建一个飞机
    315. 			createenemy();
    316. 		}
    317. 		if (Timer(20, 2))
    318. 		{
    319. 			enemymove(1);
    320. 		}
    321. 		playplane();
    322. 	}
    323. 	EndBatchDraw();
    324. 	return 0;
    325. }
    326.

  • 相关阅读:
    论文阅读之Reasoning Implicit Sentiment with Chain-of-Thought Prompting
    聊城两化融合管理体系贯标
    Pytorch学习——Pytorch的入门操作 02（未完）
    3.5背景图像固定（背景附着）
    【数据结构】静态分配的顺序表插入元素
    spring boot中使用Bean Validation做优雅的参数校验
    virtualbox 网络设置实现主机和虚拟机互相访问
    LangChain和Hub的前世今生
    java+springboot+vue水果蔬菜篮子商城经营平台系统
    【Mycat】Mycat主从复制
  • 原文地址：https://blog.csdn.net/Lukegood/article/details/128140242