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

c语言小游戏-飞机大战_c语言飞机大战

作者：小丑西瓜9 | 2024-04-04 13:33:39

赞

踩

c语言飞机大战

（创作不易，感谢有你，你的支持，就是我前行的最大动力，如果看完对你有帮助，请留下您的足迹）

今天我们来尝试用easyx图形库实现c语言小游戏-飞机大战（源代码和图片已经在结尾给出）

先引用头文件

#include<stdio.h>
#include<time.h>//用于后期制作定时器
#include<graphics.h>//便于引入easyx窗口及其函数
#include<conio.h>//用于按键控制

 接着就是一系列数据的准备工作，先创建一个窗口，为了后续方便，我们用枚举法定义窗口的变量

enum My{WIDTH=591,HEIGHT=864}

int main()

{

    initgraph(WIDTH,HEIGHT);

}

然后对飞机进行定义

struct Plance//定义飞机
{
    int x;
    int y;
    int live;//是否存活
}player; 

接着就是对飞机的相关数据初始化

void gameInit()//初始化数据
{
    player.x = WIDTH / 2;
    player.y = HEIGHT - 120;
    player.live = 1;

}

别忘了将飞机的图片加载进去，在我之前的博客中有讲到如何插入图片http://t.csdn.cn/h4POw

这里我们用两张图片对飞机进行绘制，这样的话才能更好得实现动态图画，减少图片背景的影响

IMAGE bk;//背景图片
IMAGE img_role[2];//飞机图片

void loadImage()//加载图片
{
    loadimage(&bk, "./background.jpg");
    loadimage(&img_role[0], "./planeNormal_1.jpg");
    loadimage(&img_role[1], "./planeNormal_2.jpg");

}

void gameDraw()//输出图片
{
    putimage(0, 0, &bk);
    putimage(player.x, player.y, &img_role[0],NOTSRCERASE);//NOTSRCERASE贴掩码图
    putimage(player.x, player.y, &img_role[1],SRCINVERT);//SRCINVERT贴背景图

}

飞机的相关数据创建好后，就是如何移动飞机，我这里用两种移动方法，在我之前的博客中讲到如何使用键盘移动（http://t.csdn.cn/RNF6C） 注意：这里要注意边界情况，使飞机在触碰边缘后停止移动，防止飞机出界

void playerMove(int speed)//移动玩家
{
    if (_kbhit())//判断是否有按键,有按键才处理，无按键就不处理
    {
        char input = _getch(); //控制台可以直接读取我按的键
        switch (input)
        {
        case 'w':
            player.y -= speed;
            if (player.y <= 0)   //边界处理，下面也是这样
                player.y = 0;
            break;
        case 's':
            player.y += speed;
            if (player.y >= HEIGHT - 120)
                player.y = HEIGHT - 120;
            break;
        case 'a':
            player.x -= speed;
            if (player.x <= -40)
                player.x = -40;
            break;
        case 'd':
            player.x += speed;
            if (player.x >= WIDTH - (117 / 2))
                player.x = WIDTH - (117 / 2);
            break;
        }
        //与上一种按键方式相比，这一种更加丝滑流畅
        if (GetAsyncKeyState(VK_UP))//上键
        {
            player.y -= speed;
            if (player.y <= 0)
                player.y = 0;
        }
        if (GetAsyncKeyState(VK_DOWN))//下键
        {
            player.y += speed;
            if (player.y >= HEIGHT - 120)
                player.y = HEIGHT - 120;
        }
        if (GetAsyncKeyState(VK_LEFT))//左键
        {
            player.x -= speed;
            if (player.x <= -40)
                player.x = -40;
        }
        if (GetAsyncKeyState(VK_RIGHT))//右键
        {
            player.x += speed;
            if (player.x >= WIDTH - (117 / 2))
                player.x = WIDTH - (117 / 2);
        }
    }
}

在飞机变量创建好以后，接下来就是对子弹的变量进行定义以及输出 ，这里为了方便（偷懒），我直接用之前飞机的定义来定义子弹

struct Plance//定义飞机
{
    int x;
    int y;
    int live;//是否存活
}player,bull[BULLET_NUM]

然后就是子弹的初始化，这里我枚举了子弹的数量

enum My{WIDTH=591,HEIGHT=864,BULLET_NUM=15}

void gameInit()//初始化数据
{
    player.x = WIDTH / 2;
    player.y = HEIGHT - 120;
    player.live = 1;
    for (int i = 0; i < BULLET_NUM; i++)//初始化子弹
    {
        bull[i].x;
        bull[i].y;
        bull[i].live = 0;
    } 

}

子弹的图片输出与飞机一样

IMAGE img_bull[2];

loadimage(&img_bull[0], "./bullet1.jpg");

loadimage(&img_bull[1], "./bullet2.jpg");

for (int i = 0; i < BULLET_NUM; i++)
    {
        if (bull[i].live == 1)
        {
            putimage(bull[i].x, bull[i].y, &img_bull[0], NOTSRCERASE);
            putimage(bull[i].x, bull[i].y, &img_bull[1] , SRCINVERT);
        }
    } 

然后就是对子弹的控制

if (GetAsyncKeyState(VK_SPACE))//空格发射子弹
        {
            createBullet();
        } 

 接下来就是输出敌机的相关数据，这里我们用两种飞机，一个大飞机和一个小飞机，他们的血量，大小各有差异

enum My{WIDTH=591,HEIGHT=864,BULLET_NUM=15,ENEMY_NUM=10,BIG,SMALL};

struct Plance//定义飞机
{
    int x;
    int y;
    int live;//是否存活
    int width;
    int height;
    int hp;
    int type;//敌机类型
}player,bull[BULLET_NUM],enemy[ENEMY_NUM];

 这里我们对不同类型的飞机的血量，出现概率都要有所调整

void enemyHp(int i)
{
    if (rand() % 10 == 2 )//十分之一的概率出现大飞机
    {
        enemy[i].type = BIG;
        enemy[i].hp = 3;
        enemy[i].width = 104;
        enemy[i].height = 148;
    }
    else
    {
        enemy[i].type = SMALL;
        enemy[i].hp = 1;
        enemy[i].width = 52;
        enemy[i].height = 39;
    }
}

for (int i = 0; i < ENEMY_NUM; i++)//初始化敌机
    {
        enemy[i].live = 0;
        enemyHp(i);
    }

因为上面用到了rand（）函数，为了避免重复，我们在主函数中创建随机函数种子

srand((unsigned int)time(0));//生成随机数种子 

初始化敌机后，接着就是敌机的绘制与移动，绘制与上面相同，这里我就具体讲述移动

void createEnemy()
{
    for (int i = 0; i < ENEMY_NUM; i++)
    {
        if (enemy[i].live == 0)
        {
            enemy[i].live = 1;
            enemy[i].x = rand() % (WIDTH - 60);
            enemy[i].y = 0;
            enemyHp(i);//重置血量，防止一波打完以后飞机不在产生
            break;
        }
    }
}
void enemyMove(int speed)
{
    for (int i = 0; i < ENEMY_NUM; i++)
    {
        if (enemy[i].live == 1)
        {
            enemy[i].y += speed;
            if (enemy[i].y > HEIGHT)
            {
                enemy[i].live = 0;
            }
        }
    }
}  

因为飞机会同时下落，所以这里我们创建一个定时器，使飞机下落时有延续 

定时器，顾名思义，肯定会用到时间的，所以，获取时间我们就要用到time库，所以要引用头文件<time.h>

要做出定时器，首先就需要设定静态变量t1和t2，因为只有在设置静态变量的时候，t1和t2的值才不会在循环中每执行一次就变成原来初始化的值，我们要将其固定住，在下一次循环中执行的初始值为上一次执行后的结果值，所以，就自然地会考虑到使用静态变量这种方法。

接下来，就是在循环中设置一个条件，比如你想两次改变之间的间隔为500毫秒的时候，就可以在条件语句中写入t2 - t1 > 500，这样，就可以很好地表示出来。然后在条件语句中的语句块中先写你想要让程序执行的代码或自定义函数等，并将t2赋值给t1。如果在不满足条件语句的时候，或者执行完条件语句块之后，再将当前时间赋值给t2，所以，这里就需要用到clock函数来获取当前时间。这样，就可以把最基本的定时器很简单的就做出来了，具体的代码如下：

  1. 		static DWORD t1, t2,t3,t4;//定时器
  2. 		if (t2 - t1 > 500)
  3. 		{
  4. 			createEnemy();
  5. 			t1 = t2;
  6. 		}
  7. 		t2 = clock();
  8. 		if (t4 - t3 > 5)
  9. 		{
  10. 			enemyMove(1);
  11. 			t3 = t4;
  12. 		}
  13. 		t4 = clock();

最后就是如何击落敌机了

void playPlance()//击落敌机
{
    for (int i = 0; i < ENEMY_NUM; i++)
    {
        if (enemy[i].live == 0)
        {
            continue;
        }
        for (int k = 0; k < BULLET_NUM; k++)
        {
            if (bull[k].live == 0)
            {
                continue;
            }
            if (bull[k].x > enemy[i].x && bull[k].x<enemy[i].x + enemy[i].width
                && bull[k].y>enemy[i].y && bull[k].y < enemy[i].y + enemy[i].height)
            {
                bull[k].live = 0;
                enemy[i].hp--;
            }
        }
        if (enemy[i].hp <= 0)
        {
            enemy[i].live = 0;

        }
    }
}

总体代码就是这样，如果大家发现bug或者有更好的方法 ，欢迎大家一起来讨论呀，一起加油

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<stdio.h>
  3. #include<time.h>//用于后期制作定时器
  4. #include<graphics.h>//便于引入easyx窗口及其函数
  5. #include<conio.h>//用于按键控制
  6. IMAGE bk;
  7. IMAGE img_role[2];
  8. IMAGE img_bull[2];
  9. IMAGE my_enemy[2];
  10. IMAGE enemyPlane[2];
  11. enum My{WIDTH=591,HEIGHT=864,BULLET_NUM=15,ENEMY_NUM=10,BIG,SMALL};
  12. struct Plance//定义飞机
  13. {
  14. 	int x;
  15. 	int y;
  16. 	int live;//是否存活
  17. 	int width;
  18. 	int height;
  19. 	int hp;
  20. 	int type;//敌机类型
  21. }player,bull[BULLET_NUM],enemy[ENEMY_NUM];
  22. void loadImage()//加载图片
  23. {
  24. 	loadimage(&bk, "./background.jpg");
  25. 	loadimage(&img_role[0], "./planeNormal_1.jpg");
  26. 	loadimage(&img_role[1], "./planeNormal_2.jpg");
  27. 	loadimage(&img_bull[0], "./bullet1.jpg");
  28. 	loadimage(&img_bull[1], "./bullet2.jpg");
  29. 	loadimage(&my_enemy[0], "./enemy_1.jpg");
  30. 	loadimage(&my_enemy[1], "./enmey_2.jpg");
  31. 	loadimage(&enemyPlane[0], "./enemyPlane1.jpg");
  32. 	loadimage(&enemyPlane[1], "./enemyPlane2.jpg");
  33. }
  34. void enemyHp(int i)
  35. {
  36. 	if (rand() % 10 == 2 )//十分之一的概率出现大飞机
  37. 	{
  38. 		enemy[i].type = BIG;
  39. 		enemy[i].hp = 3;
  40. 		enemy[i].width = 104;
  41. 		enemy[i].height = 148;
  42. 	}
  43. 	else
  44. 	{
  45. 		enemy[i].type = SMALL;
  46. 		enemy[i].hp = 1;
  47. 		enemy[i].width = 52;
  48. 		enemy[i].height = 39;
  49. 	}
  50. }
  51. void gameInit()//初始化数据
  52. {
  53. 	player.x = WIDTH / 2;
  54. 	player.y = HEIGHT - 120;
  55. 	player.live = 1;
  56. 	for (int i = 0; i < BULLET_NUM; i++)//初始化子弹
  57. 	{
  58. 		bull[i].x;
  59. 		bull[i].y;
  60. 		bull[i].live = 0;
  61. 	}
  62. 	for (int i = 0; i < ENEMY_NUM; i++)//初始化敌机
  63. 	{
  64. 		enemy[i].live = 0;
  65. 		enemyHp(i);
  66. 	}
  67. }
  68. void createBullet()
  69. {
  70. 	for (int i = 0; i < BULLET_NUM; i++)
  71. 	{
  72. 		if (bull[i].live == 0)
  73. 		{
  74. 			bull[i].x = player.x+60 ;
  75. 			bull[i].y = player.y ;
  76. 			bull[i].live = 1;
  77. 			break;
  78. 		}
  79. 	}
  80. }
  81. void BulletMove()
  82. {
  83. 	for (int i = 0; i < BULLET_NUM; i++)
  84. 	{
  85. 		if (bull[i].live == 1)
  86. 		{
  87. 			bull[i].y -= 1;
  88. 			if (bull[i].y < 0)
  89. 			{
  90. 				bull[i].live = 0;
  91. 			}
  92. 		}
  93. 	}
  94. }
  95. void gameDraw()//输出图片
  96. {
  97. 	BeginBatchDraw();//开始绘图
  98. 	putimage(0, 0, &bk);
  99. 	putimage(player.x, player.y, &img_role[0],NOTSRCERASE);
  100. 	putimage(player.x, player.y, &img_role[1],SRCINVERT);
  101. 	//绘制子弹
  102. 	for (int i = 0; i < BULLET_NUM; i++)
  103. 	{
  104. 		if (bull[i].live == 1)
  105. 		{
  106. 			putimage(bull[i].x, bull[i].y, &img_bull[0], NOTSRCERASE);
  107. 			putimage(bull[i].x, bull[i].y, &img_bull[1] , SRCINVERT);
  108. 		}
  109. 	}
  110. 	//绘制敌机
  111. 	for (int i = 0; i < ENEMY_NUM; i++)
  112. 	{
  113. 		if (enemy[i].live == 1)
  114. 		{
  115. 			if (enemy[i].type == BIG)
  116. 			{
  117. 				putimage(enemy[i].x, enemy[i].y, &enemyPlane[0], NOTSRCERASE);
  118. 				putimage(enemy[i].x, enemy[i].y, &enemyPlane[1], SRCINVERT);
  119. 			}
  120. 			else
  121. 			{
  122. 				putimage(enemy[i].x, enemy[i].y, &my_enemy[0], SRCINVERT);
  123. 				putimage(enemy[i].x, enemy[i].y, &my_enemy[1], NOTSRCERASE);
  124. 			}
  125. 		}
  126. 	}
  127. 	EndBatchDraw();// 结束绘图
  128. }
  129. void createEnemy()
  130. {
  131. 	for (int i = 0; i < ENEMY_NUM; i++)
  132. 	{
  133. 		if (enemy[i].live == 0)
  134. 		{
  135. 			enemy[i].live = 1;
  136. 			enemy[i].x = rand() % (WIDTH - 60);
  137. 			enemy[i].y = 0;
  138. 			enemyHp(i);//重置血量，防止一波打完以后飞机不在产生
  139. 			break;
  140. 		}
  141. 	}
  142. }
  143. void enemyMove(int speed)
  144. {
  145. 	for (int i = 0; i < ENEMY_NUM; i++)
  146. 	{
  147. 		if (enemy[i].live == 1)
  148. 		{
  149. 			enemy[i].y += speed;
  150. 			if (enemy[i].y > HEIGHT)
  151. 			{
  152. 				enemy[i].live = 0;
  153. 			}
  154. 		}
  155. 	}
  156. }
  157. void playerMove(int speed)//移动玩家
  158. {
  159. 	if (_kbhit())//判断是否有按键,有按键才处理，无按键就不处理
  160. 	{
  161. 		char input = _getch(); //控制台可以直接读取我按的键
  162. 		switch (input)
  163. 		{
  164. 		case 'w':
  165. 			player.y -= speed;
  166. 			if (player.y <= 0)   //边界处理
  167. 				player.y = 0;
  168. 			break;
  169. 		case 's':
  170. 			player.y += speed;
  171. 			if (player.y >= HEIGHT - 120)
  172. 				player.y = HEIGHT - 120;
  173. 			break;
  174. 		case 'a':
  175. 			player.x -= speed;
  176. 			if (player.x <= -40)
  177. 				player.x = -40;
  178. 			break;
  179. 		case 'd':
  180. 			player.x += speed;
  181. 			if (player.x >= WIDTH - (117 / 2))
  182. 				player.x = WIDTH - (117 / 2);
  183. 			break;
  184. 		}
  185. 		//与上一种按键方式相比，这一种更加丝滑流畅
  186. 		if (GetAsyncKeyState(VK_UP))//上键
  187. 		{
  188. 			player.y -= speed;
  189. 			if (player.y <= 0)
  190. 				player.y = 0;
  191. 		}
  192. 		if (GetAsyncKeyState(VK_DOWN))//下键
  193. 		{
  194. 			player.y += speed;
  195. 			if (player.y >= HEIGHT - 120)
  196. 				player.y = HEIGHT - 120;
  197. 		}
  198. 		if (GetAsyncKeyState(VK_LEFT))//左键
  199. 		{
  200. 			player.x -= speed;
  201. 			if (player.x <= -40)
  202. 				player.x = -40;
  203. 		}
  204. 		if (GetAsyncKeyState(VK_RIGHT))//右键
  205. 		{
  206. 			player.x += speed;
  207. 			if (player.x >= WIDTH - (117 / 2))
  208. 				player.x = WIDTH - (117 / 2);
  209. 		}
  210. 		if (GetAsyncKeyState(VK_SPACE))//空格发射子弹
  211. 		{
  212. 			createBullet();
  213. 		}
  214. 	}
  215. }
  216. int Timer(int ms)
  217. {
  218. 	static DWORD t1, t2;//定时器
  219. 	if (t2 - t1 > ms)
  220. 	{
  221. 		t1 = t2;
  222. 		return 1;
  223. 	}
  224. 	t2 = clock();
  225. }
  226. void playPlance()//击落敌机
  227. {
  228. 	for (int i = 0; i < ENEMY_NUM; i++)
  229. 	{
  230. 		if (enemy[i].live == 0)
  231. 		{
  232. 			continue;
  233. 		}
  234. 		for (int k = 0; k < BULLET_NUM; k++)
  235. 		{
  236. 			if (bull[k].live == 0)
  237. 			{
  238. 				continue;
  239. 			}
  240. 			if (bull[k].x > enemy[i].x && bull[k].x<enemy[i].x + enemy[i].width
  241. 				&& bull[k].y>enemy[i].y && bull[k].y < enemy[i].y + enemy[i].height)
  242. 			{
  243. 				bull[k].live = 0;
  244. 				enemy[i].hp--;
  245. 			}
  246. 		}
  247. 		if (enemy[i].hp <= 0)
  248. 		{
  249. 			enemy[i].live = 0;
  250.  
  251. 		}
  252. 	}
  253. }
  254. int main()
  255. {
  256. 	srand((unsigned int)time(0));//生成随机数种子
  257. 	//创建一个窗口
  258. 	initgraph(WIDTH,HEIGHT);
  259. 	loadImage();
  260. 	gameInit();
  261. 	//双缓冲绘图
  262. 	BeginBatchDraw();
  263. 	while (1)
  264. 	{
  265. 		gameDraw();
  266. 		FlushBatchDraw();//刷新一下，防止黑屏
  267. 		playerMove(30);
  268. 		BulletMove();
  269. 		static DWORD t1, t2,t3,t4;//定时器
  270. 		if (t2 - t1 > 500)
  271. 		{
  272. 			createEnemy();
  273. 			t1 = t2;
  274. 		}
  275. 		t2 = clock();
  276. 		if (t4 - t3 > 5)
  277. 		{
  278. 			enemyMove(1);
  279. 			t3 = t4;
  280. 		}
  281. 		t4 = clock();
  282. 		playPlance();
  283. 	}
  284. 	EndBatchDraw();
  285. 	return 0;
  286. }

 

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

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

  

闽ICP备14008679号