【C++】做一个飞机空战小游戏(十)——子弹击落炮弹、炮弹与飞机相撞

news2024/11/16 12:29:27

[导读]本系列博文内容链接如下：

【C++】做一个飞机空战小游戏(一)——使用getch()函数获得键盘码值

【C++】做一个飞机空战小游戏(二)——利用getch()函数实现键盘控制单个字符移动
【C++】做一个飞机空战小游戏(三)——getch()函数控制任意造型飞机图标移动

【C++】做一个飞机空战小游戏(四)——给游戏添加背景音乐(多线程技巧应用)

【C++】做一个飞机空战小游戏(五)——getch()控制两个飞机图标移动(控制光标位置)

【C++】做一个飞机空战小游戏(六)——给两架飞机设置不同颜色(cout输出彩色字符、结构体使用技巧)

【C++】做一个飞机空战小游戏(七)——两组按键同时检测平滑移动(GetAsyncKeyState()函数应用)

【C++】做一个飞机空战小游戏(八)——生成敌方炮弹(rand()函数应用)

【C++】做一个飞机空战小游戏(九)——发射子弹的编程技巧

【C++】做一个飞机空战小游戏(十)——子弹击落炮弹、炮弹与飞机相撞

今天这节介绍实现子弹击落炮弹、炮弹与飞机相撞的效果，增加了飞机的血量属性，炮弹撞击一次掉血三分之一，三次撞击则飞机被炮弹击落。还增加了飞机命数属性，飞机设置了3条命，飞机命数大于0的时候可以按复活键进行复活，如果命为0时，飞机不可复活。还增加了游戏暂停功能，按空格键游戏暂停，再按一次即可恢复游戏。

目录

一、炮弹与子弹或飞机相撞

（一）子弹击落炮弹

1、子弹、炮弹初始血量和伤害值

2、子弹与炮弹相撞后血量

3、击落函数

4、击落后血量变化代码

（二）炮弹与飞机相撞

1、飞机结构体

2、飞机初始化函数

（1）单个飞机初始化

（2）所有飞机初始化

3、飞机初始血量

4、飞机与炮弹相撞后血量

（1）炮弹血量

（2）飞机血量

5、飞机命数

6、相撞函数

7、相撞后血量命数变化代码

8、飞机复活

二、游戏暂停功能

（一）game中增加pause属性

（二）游戏暂停按键

（三）游戏暂停代码

三、完整代码

（一）主函数

（二）头文件control_plane.h

（三）库函数control_plane.cpp

四、运行效果

（一）子弹与炮弹相撞

（二）炮弹与飞机相撞、飞机复活

一、炮弹与子弹或飞机相撞

（一）子弹击落炮弹

1、子弹、炮弹初始血量和伤害值

子弹炮弹相撞前：

子弹、炮弹血量hp=1；

子弹、炮弹伤害值dam=1；

2、子弹与炮弹相撞后血量

子弹炮弹相撞后：

相撞后子弹血量=相撞前子弹血量-炮弹伤害值；

相撞后炮弹血量=相撞前炮弹血量-子弹伤害值；

因此，子弹炮弹相撞后，两者血量都为0，alive值都为false，会同归于尽，炮弹被击落。

3、击落函数

 bool shoot(Bullet bullet,Bomb bomb)
{
	bool sbb,sx0,sx1,sy0,sy1;
	sx0=(bomb.location.x>=bullet.location.x-1);
	sx1=(bomb.location.x<=bullet.location.x+1);	
	sy0=(bomb.location.y>=bullet.location.y);
	sy1=(bomb.location.y<=bullet.location.y+1);	
	sbb=sx0 &&sx1&&sy0&&sy1;
	return sbb;
}

4、击落后血量变化代码

这部分代码在子弹位置更新线程中，具体如下：

for(int k=0;k<game.bombs_round;k++)//判断子弹是否击中炮弹 
{			
	if(shoot(bullet[i][j],bomb[k]))
	{
		bomb[k].hp-=bullet[i][j].dam;
		bullet[i][j].hp-=bomb[k].dam;
	}
}

（二）炮弹与飞机相撞

1、飞机结构体

//定义飞机结构体 
typedef struct{
	Location location;		//飞机坐标 
	int color;				//飞机颜色 
	int icon;				//飞机图标编号 
	direction_cmd keycmd;	//飞机移动方向命令 
	bool fire;				//飞机是否开火 
	int cnt_bullets; 		//按一次开火键加1，然后初始化bullet[cnt_bullets],子弹死亡一个减1
	int hp;					//飞机血量 
	bool alive;				//飞机存活标志 
	int No;					//飞机序号 
	int life;				//飞机命数
}Plane;

2、飞机初始化函数

（1）单个飞机初始化

//单个飞机初始化函数
Plane init_plane(Plane plane)
{
	plane.alive=true;	
	plane.hp=3;	
	plane.keycmd=none_cmd;
	plane.location=plocation[plane.No];
	plane.color=plane.No+1;
	plane.icon=plane.No+1;		
	return plane;
}

初始化函数用在游戏开始和飞机复活时，函数中没有设置No和life两项，因为No值不同，而life值每次死亡时减1，复活后不能再恢复为原值。

（2）所有飞机初始化

//所有飞机初始化函数 
void init_planes(void)
{
	for(int i=0;i<game.num_plane;i++)//刷新飞机图标
	{			
		plane[i]=init_plane(plane[i]);
	}
}

3、飞机初始血量

飞机初始血量hp=3，飞机没有设置伤害值，默认其伤害值为无穷大。

4、飞机与炮弹相撞后血量

（1）炮弹血量

炮弹与飞机相撞后，炮弹血量直接降为0，alive值为false。

（2）飞机血量

飞机与炮弹相撞后，相撞后飞机血量值=相撞前血量值-炮弹伤害值。飞机血量值小于等于0时，飞机死亡，alive值为false。

5、飞机命数

飞机命数life初始值为3。如果飞机死亡，其命数life值减1。

6、相撞函数

 bool collide(Plane plane,Bomb bomb)
{
	bool cpb,cx0,cx1,cy0,cy1;
	cx0=bomb.location.x>=plane.location.x-1;
	cx1=bomb.location.x<=plane.location.x+plane_width;
	cy0=bomb.location.y>=plane.location.y;
	cy1=bomb.location.y<=plane.location.y+plane_height; 
	
	cpb=cx0 && cx1 && cy0 && cy1;
	return cpb;
}

7、相撞后血量命数变化代码

飞机血量、命数的变化代码放置在炮弹位置更新线程中，具体内容如下：

for(int j=0;j<game.num_plane;j++)
{
	if(plane[j].alive)
	{
		if(collide(plane[j],bomb[i])) 
		{
			bomb[i].hp=0;
		    plane[j].hp-=bomb[i].dam;	
		}
					
		if(plane[j].hp<=0)
		{
			plane[j].alive=false;
			plane[j].life=plane[j].life-1;
			plane[j].keycmd=none_cmd;
			plane[j].location.x=0;
			plane[j].location.y=b_b+8;									
		}					
	}
					
}

8、飞机复活

按复活键可复活，当命数小于1时，不能再复活，永久死亡。plane[0]的复活代码如下：

if(plane[0].life>0)
{
	if (GetAsyncKeyState('O') & 0x8000)							//飞机复活指令
	{
		plane[0]=init_plane(plane[0]);
		show_plane(plane[0]);
	}
}

二、游戏暂停功能

（一）game中增加pause属性

//定义游戏结构体 
typedef struct{
	int stage;					//游戏当前关 	
	int bombs_round;			//敌方每轮发射炮弹数量 
	int bombs_stage;			//每关总计出现炮弹数量 
	bool clear;					//游戏过关 
	bool complete;				//游戏通关 
	bool gameover;				//游戏结束
	int num_plane;				//飞机数量 
	int cur_num_bomb;			//当前已发射炮弹数量 
	int bomb_interval; 			//位置更新间隔 
	bool bomb_move;				//炮弹是否移动
	bool bullet_move;			//子弹是否移动
	bool pause;					//游戏是否暂停 
}Game;

（二）游戏暂停按键

游戏暂停键为空格键，游戏进行时，按下空格键game.pause=true，游戏暂停，再按一次game.pause=false，游戏恢复，代码在key()函数中，内容如下：

if (GetAsyncKeyState(VK_SPACE) & 0x8000)
{
	Sleep(50);
	game.pause=!game.pause;					
}

代码中Sleep(50)为按键去抖动作用，防止按了一次被识别为多次。

（三）游戏暂停代码

游戏暂停时，主函数中除背景音乐之外所有的线程都暂停。在需要暂停的线程中加入如下代码：

while(game.pause)
{
	;
}

三、完整代码

（一）主函数

#include "control_plane.h"
#include "quenue.h"
using namespace std; 
 
Plane plane[eq_plane];
Game game;
Bomb bomb[eq_bombs_round];
Bullet bullet[eq_plane][eq_bullets_round];
Location plocation[]={{2*r_b/3,b_b},{r_b/3,b_b}};
 
int main(int argc, char** argv) {	
	
	
	init();	//初始化					 
 
	bgmusic();//播放背景音乐
	getkey();
	bomb_location_update();	
	bullet_location_update();	
	
	while(1)					//循环等待键盘指令 
	{
		while(game.pause)
		{
			;
		}
		
		if(plane[0].keycmd!=none_cmd ||plane[1].keycmd!=none_cmd ||game.bomb_move ||game.bullet_move)
		{
			game.bomb_move=false;
			game.bullet_move=false;
			system("cls");
			for(int i=0;i<game.num_plane;i++)
			{
				if(plane[i].alive)
				{
					show_plane(plane[i]);//刷新飞机图标
				}
				
			}
			
			for(int i=0;i<game.bombs_round;i++)
			{
				if(bomb[i].alive)
				{
					show_bomb(bomb[i]);
				}
				
			}
			
			for(int i=0;i<eq_plane;i++)
			{
				for(int j=0;j<eq_bullets_round;j++)
				{				
					if(bullet[i][j].alive)
					{
						show_bullet(bullet[i][j]);
					}
				}	
			}	
		}	
	}
	return 0; 	
}

（二）头文件control_plane.h

#ifndef CONTROL_PLANE_H
#define CONTROL_PLANE
#include <iostream>
#include <ctime>
#include <string>
#include<stdlib.h>
#include<windows.h>
#include <pthread.h>//导入线程头文件库
#include <mmsystem.h> //导入声音头文件库
#pragma comment(lib,"winmm.lib")//导入声音的链接库
#define _CRT_SECURE_NO_WARNINGS 
using namespace std;
 
#define t_b 0  	//图形显示区域上侧边界 
#define l_b 0	//图形显示区域左侧边界
#define r_b 100	//图形显示区域右侧边界
#define b_b 20	//图形显示区域下侧边界
#define plane_width 9
#define plane_height 6

#define eq_plane 2	//飞机架数
#define eq_bombs_round 23	//eq=end quantity最终炮弹数量 
#define eq_rt 10	//复活最大时间
#define eq_bullets_round 20	//eq=end quantity飞机一次发射最多子弹数量 
 
//定义飞机造型 
const string icon_plane1[]={"    ■","■  ■  ■","■■■■■","■  ■  ■","    ■","  ■■■"};
const string icon_plane2[]={"    ■","■  ■  ■","■■■■■","    ■","  ■■■","■■■■■"};

//定义炮弹造型
const string icon_bomb="■";

//定义子弹造型
const string icon_bullet="■";
 
//定义坐标结构体 
typedef struct{
	int x;
	int y;
} Location;
 
 
//定义移动方向命令枚举类型 
typedef  enum {none_cmd,up_cmd,down_cmd,left_cmd,right_cmd} direction_cmd;

//定义游戏结构体 
typedef struct{
	int stage;					//游戏当前关 	
	int bombs_round;			//敌方每轮发射炮弹数量 
	int bombs_stage;			//每关总计出现炮弹数量 
	bool clear;					//游戏过关 
	bool complete;				//游戏通关 
	bool gameover;				//游戏结束
	int num_plane;				//飞机数量 
	int cur_num_bomb;			//当前已发射炮弹数量 
	int bomb_interval; 			//位置更新间隔 
	bool bomb_move;				//炮弹是否移动
	bool bullet_move;			//子弹是否移动
	bool pause;					//游戏是否暂停 
}Game;
 
//定义飞机结构体 
typedef struct{
	Location location;		//飞机坐标 
	int color;				//飞机颜色 
	int icon;				//飞机图标编号 
	direction_cmd keycmd;	//飞机移动方向命令 
	bool fire;				//飞机是否开火 
	int cnt_bullets; 		//按一次开火键加1，然后初始化bullet[cnt_bullets],子弹死亡一个减1
	int hp;					//飞机血量 
	bool alive;				//飞机存活标志 
	int No;					//飞机序号 
	int life;				//飞机命数
}Plane;

//定义敌方炮弹结构体 
typedef struct{
	Location location;	//炮弹位置 
	bool alive;			//炮弹是否存活 
	int color;			//炮弹颜色
	string icon;		//炮弹图标
	int rt;				//rt=respawn time复活时间 
	int hp;				//hp=hit point 生命值，此值<=0时，敌方炮弹死亡，敌方炮弹被飞机子弹击中hp会减少，坠地或与飞机相撞hp直接降为0 
	int dam;			//dam=damage 伤害值
	int type;			//炮弹类型 
}Bomb;

//定义子弹结构体 
typedef struct{
	Location location;	//子弹位置 
	bool alive;			//子弹是否存活 
	int color;			//子弹颜色
	string icon;		//子弹图标	
	int hp;				//hp=hit point 生命值，子弹击中炮弹或冲出屏幕上方hp直接降为0，子弹死亡 
	int dam;			//dam=damage 伤害值
	int type;			//子弹类型 
}Bullet;

 
extern Plane plane[eq_plane];
extern Game game;
extern Bomb bomb[eq_bombs_round];
extern Bullet bullet[eq_plane][eq_bullets_round];

extern Location plocation[];
//extern Location plocation1={r_b/3,b_b};
 
//声明刷新飞机位置函数
void show_plane(Plane plane);
 
//获取键盘指令 
void key(void);
 
//更新所有飞机坐标
void plane_location_update(void);
 
//初始化函数 
void init(void);
 
//播放背景音乐线程 
void* thread_bgmusic(void* arg);
void play_bgmusic();
void bgmusic();
 
//获取按键指令线程
void* thread_key(void* arg);
void getkey();
 
//输出彩色字符函数
template<typename T>	//T表示任何可以被cout输出的类型 
void ColorCout(T t, const int ForeColor = 7, const int BackColor = 0);

void init_bombs(void);
Bomb init_(Bomb bomb);
void* thread_bomb(void* arg);
void bomb_location_update();
void show_bomb(Bomb bomb);


void bullet_location_update();			//子弹位置更新 
void* thread_bullet(void* arg);			//子弹线程函数 
Bullet init_bullet(Bullet bullet);		//单个子弹初始化
void init_bullets(void);				//所有子弹初始化
Bullet fire(Plane plane,Bullet bullet);	//飞机开火函数，确定子弹出现的起始位置 
void show_bullet(Bullet bullet);		//显示子弹图标 


bool collide(Plane plane,Bomb bomb);
bool shoot(Bullet bullet,Bomb bomb);

Plane init_plane(Plane plane);
void init_planes(void);

#endif

（三）库函数control_plane.cpp

#include <iostream>
#include "conio.h"
#include <string>
#include "control_plane.h"
#include<windows.h>
using namespace std;
 
 
//彩色输出函数
template<typename T>	//T表示任何可以被cout输出的类型
void ColorCout(T t, const int ForeColor = 7, const int BackColor = 0)
{
	//	0 = 黑色	1 = 蓝色	 2 = 绿色	 3 = 浅绿色		 4 = 红色	 5 = 紫色	 6 = 黄色	 7 = 白色
	//	8 = 灰色	9 = 淡蓝色	10 = 淡绿色	11 = 淡浅绿色	12 = 淡红色	13 = 淡紫色	14 = 淡黄色	15 = 亮白色
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), ForeColor + BackColor * 0x10);
	cout << t;
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}
 
 
//隐藏光标函数
HANDLE han = GetStdHandle(-11);
void hide(){
	CONSOLE_CURSOR_INFO cursor;
	cursor.bVisible = 0;
	cursor.dwSize = 1;
	SetConsoleCursorInfo(han,&cursor);
}
 
//初始化函数 
void init(void)
{
	plane[0].No=0;
	plane[1].No=1;
	
	plane[0].life=3;		
	plane[1].life=3;
	
	srand(time(NULL));
	
	game.num_plane=2;
	game.bombs_round=3;
	game.bomb_move=false;
	game.bullet_move=false;
	game.bomb_interval=1000;
	game.stage=1;
	game.bombs_stage=100;
	game.pause=false;	
	
	init_bombs();
	init_bullets();
	init_planes();
	
	system("cls");
	for(int i=0;i<game.num_plane;i++)//刷新飞机图标
	{			
		show_plane(plane[i]);
	}
		
	game.bombs_round=3;
	hide();//隐藏光标
}
 
 
 
//********************************************************************************
 //以下三个函数为获得按键指令线程函数 
//********************************************************************************
 
void* thread_key(void* arg)
{
	while(1)
	{
		Sleep(60); 		//获取指令延时一定时间，起滤波作用，延缓获取指令的响应速度 
		key();			//获取按键指令
		plane_location_update() ;//获取完指令马上更新飞机坐标 
	}
}
void getkey()
{
	pthread_t tid; 
  	pthread_create(&tid, NULL, thread_key, NULL);
}
 
//获取键盘指令函数
void key(void)
{
	if (GetAsyncKeyState(VK_SPACE) & 0x8000)
	{
		Sleep(50);
		game.pause=!game.pause;					
	}
	
	if(!game.pause)
	{
		if(plane[0].alive)
		{
			direction_cmd c=none_cmd;
			if (GetAsyncKeyState(VK_UP) & 0x8000)		c = up_cmd;
			if (GetAsyncKeyState(VK_DOWN) & 0x8000)		c = down_cmd;
			if (GetAsyncKeyState(VK_LEFT) & 0x8000)		c = left_cmd;
			if (GetAsyncKeyState(VK_RIGHT) & 0x8000)	c = right_cmd;
			plane[0].keycmd=c;												//刷新飞机方向指令											 
			if (GetAsyncKeyState('P') & 0x8000)		plane[0].fire = true;	//飞机开火指令
		}
		else
		{
			if(plane[0].life>0)
			{
				if (GetAsyncKeyState('O') & 0x8000)							//飞机复活指令
				{
					plane[0]=init_plane(plane[0]);
					show_plane(plane[0]);
				}
			}
			
		}
		
		if(plane[1].alive)
		{
			direction_cmd d=none_cmd;
			if (GetAsyncKeyState('W') & 0x8000)	d = up_cmd;
			if (GetAsyncKeyState('S') & 0x8000)	d = down_cmd;
			if (GetAsyncKeyState('A') & 0x8000)	d = left_cmd;
			if (GetAsyncKeyState('D') & 0x8000)	d = right_cmd;
			plane[1].keycmd=d;//刷新飞机图标
			if (GetAsyncKeyState('F') & 0x8000)			plane[1].fire = true;
		}
		else
		{
			if(plane[1].life>0)
			{
				if (GetAsyncKeyState('Q') & 0x8000)
				{
					plane[1]=init_plane(plane[1]);
					show_plane(plane[1]);
				}
			}					
		}	
	}	
}
 
void gotoxy(int x, int y) {
	COORD pos = { x,y };
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出设备句柄
	SetConsoleCursorPosition(hOut, pos);//两个参数分别指定哪个窗口，具体位置
}
 
 
//飞机图标刷新函数 
void show_plane(Plane plane)		//预先定义字符定位显示函数，x是列坐标，y是行坐标，原点(x=0,y=0)位于屏幕左上角 
{
	int x,y;
	int i,j;
	int rows;
	x=plane.location.x;
	y=plane.location.y;
	
	switch(plane.icon)
	{
		case 1://第一种造型 
			rows=sizeof(icon_plane1)/sizeof(icon_plane1[0]);
			for(i=0;i<rows;i++)				 
			{
				gotoxy(x,y+i);				
				ColorCout(icon_plane1[i],plane.color);
			}
			break;
		case 2://第二种造型 
			rows=sizeof(icon_plane2)/sizeof(icon_plane2[0]);
			for(i=0;i<rows;i++)				
			{
				gotoxy(x,y+i);				
				ColorCout(icon_plane2[i],plane.color);
			}
			break;				
	}
}
 
//更新两个飞机的坐标 
void plane_location_update(void)
{ 	
	for(int i=0;i<2;i++)
	{
		if(plane[i].keycmd!=none_cmd) 
		{
			int x,y;
 			x=plane[i].location.x;
 			y=plane[i].location.y;
 			switch(plane[i].keycmd)
			{
				case up_cmd:
					y--;				//字符上移一行，行值y减1
					if(y<t_b)			//限定y值最小值为0
					{
						y=t_b;
					}
					break;
				case down_cmd:
					y++;				//字符下移一行，行值y加1
					if(y>b_b)			//限定y高度 
					{
						y=b_b;
					}
					break;
				case left_cmd:
					x--;				//字符左移一列，列值x减1
					if(x<l_b)
					{
						x=l_b;			//限定x最小值为0; 
					}
					break;
				case right_cmd:
					x++;				//字符右移一列，列值x加1
					if(x>r_b)
					{
						x=r_b;			//限定x宽度
					}
					break;
				
			}
			plane[i].location.x=x;
 			plane[i].location.y=y;
 			plane[i].keycmd=none_cmd;	
		}
					
	} 		
}

//单个炮弹初始化函数 
Bomb init_bomb(Bomb bomb)
{
	bomb.location.x=rand()%r_b;	
	bomb.location.y=b_b+6;
	bomb.icon=icon_bomb;
	bomb.color=6;
	bomb.dam=1;
	bomb.hp=1;
	bomb.alive=false;
	bomb.rt=rand()%(eq_rt+1)+1;	
	return bomb;			
}

//所有炮弹初始化函数 
void init_bombs(void)
{
	game.bomb_move=false;
	
	for(int i=0;i<game.bombs_round;i++)
	{
		bomb[i]=init_bomb(bomb[i]);	
	}
}

//炮弹位置更新 线程 
void* thread_bomb(void* arg)
{
	while(1)
	{
		while(game.pause)
		{
			;
		}
		
		Sleep(game.bomb_interval);
		game.bomb_move=true;
		
		for(int i=0;i<game.bombs_round;i++)
		{			
			if(bomb[i].alive)
			{
				bomb[i].location.y++;
				if(bomb[i].location.y>b_b+5)
				{
					bomb[i].hp=0;									
				}
			
				for(int j=0;j<game.num_plane;j++)
				{
					if(plane[j].alive)
					{
						if(collide(plane[j],bomb[i])) 
						{
							bomb[i].hp=0;
							plane[j].hp-=bomb[i].dam;	
						}
					
						if(plane[j].hp<=0)
						{
							plane[j].alive=false;
							plane[j].life=plane[j].life-1;
							plane[j].keycmd=none_cmd;
							plane[j].location.x=0;
							plane[j].location.y=b_b+8;									
						}					
					}
					
				}				
							
				if(bomb[i].hp<=0)
				{
					bomb[i]=init_bomb(bomb[i]);				
				}			
			}
			else
			{
				bomb[i].rt--;
				if(bomb[i].rt<=0)
				{
					bomb[i].alive=true;
					bomb[i].location.y=0;
				}			
			}
						
		}		
		
	}
}
//炮弹位置更新 
void bomb_location_update()
{
	pthread_t tid; 
  	pthread_create(&tid, NULL, thread_bomb, NULL);
}


炮弹图标刷新函数
void show_bomb(Bomb bomb)		//预先定义字符定位显示函数，x是列坐标，y是行坐标，原点(x=0,y=0)位于屏幕左上角 
{
	int x,y;	
	x=bomb.location.x;
	y=bomb.location.y;
	hide();//隐藏光标
	gotoxy(x,y);
	ColorCout(bomb.icon,bomb.color);
		
} 

//发射子弹 
Bullet fire(Plane plane,Bullet bullet)
{
	game.bullet_move=true;
	bullet.location.x=plane.location.x+plane_width/2;	
	bullet.location.y=plane.location.y-1;
	bullet.alive=true;		
	return bullet;			
}

//单个子弹初始化函数
Bullet init_bullet(Bullet bullet)
{
	bullet.icon=icon_bullet;
	bullet.location.x=0;
	bullet.location.y=b_b+7;
	bullet.alive=false;
	bullet.color=4;
	bullet.dam=1;
	bullet.hp=1;	
	return bullet;			
}

//所有子弹初始化函数 
void init_bullets(void)
{
	game.bullet_move=false;	
	for(int i=0;i<eq_plane;i++)
	{
		for(int j=0;j<eq_bullets_round;j++)
		{
			bullet[i][j]=init_bullet(bullet[i][j]);	
		}	
	}
}

//单个飞机初始化函数
Plane init_plane(Plane plane)
{
	plane.alive=true;	
	plane.hp=3;	
	plane.keycmd=none_cmd;
	plane.location=plocation[plane.No];
	plane.color=plane.No+1;
	plane.icon=plane.No+1;		
	return plane;
}



//所有飞机初始化函数 
void init_planes(void)
{
	for(int i=0;i<game.num_plane;i++)//刷新飞机图标
	{			
		plane[i]=init_plane(plane[i]);
	}
}


//子弹位置更新 线程 
void* thread_bullet(void* arg)
{
	while(1)
	{
		while(game.pause)
		{
			;
		}
		Sleep(game.bomb_interval);
		
		for(int i=0;i<eq_plane;i++)
		{
			if(plane[i].fire)			//如果飞机开火，要搜寻一个子弹处于死亡状态的位置激活子弹 
				{					
					game.bullet_move=true;	
					for(int j=0;j<eq_bullets_round;j++)
					{
						if(!bullet[i][j].alive)
						{
							bullet[i][j]=fire(plane[i],bullet[i][j]);
							break;
						}	
					}
					
					
				}
			plane[i].fire=false;				
		}
		
		for(int i=0;i<eq_plane;i++)
		{
			for(int j=0;j<eq_bullets_round;j++)
			{				
				if(bullet[i][j].alive)
				{
					bullet[i][j].location.y--;
					if(bullet[i][j].location.y<0)
					{
						bullet[i][j].hp=0;									
					}
					
					
					for(int k=0;k<game.bombs_round;k++)//判断子弹是否击中炮弹 
					{			
						if(shoot(bullet[i][j],bomb[k]))
						{
							bomb[k].hp-=bullet[i][j].dam;
							bullet[i][j].hp-=bomb[k].dam;
						}
					}
					
					if(bullet[i][j].hp<=0)
					{
						//bullet[i][j].alive=false;
						bullet[i][j]=init_bullet(bullet[i][j]);									
					}				
					
								
				}
			}	
		}	
		
	}
}
//子弹位置更新 
void bullet_location_update()
{
	pthread_t tid; 
  	pthread_create(&tid, NULL, thread_bullet, NULL);
}


子弹图标刷新函数
void show_bullet(Bullet bullet)		//预先定义字符定位显示函数，x是列坐标，y是行坐标，原点(x=0,y=0)位于屏幕左上角 
{
	int x,y;	
	x=bullet.location.x;
	y=bullet.location.y;
	hide();//隐藏光标
	gotoxy(x,y);
	ColorCout(bullet.icon,bullet.color);		
} 

//********************************************************************************
 //以下函数为子弹被击落或撞落功能 
//********************************************************************************
 bool collide(Plane plane,Bomb bomb)
{
	bool cpb,cx0,cx1,cy0,cy1;
	cx0=bomb.location.x>=plane.location.x-1;
	cx1=bomb.location.x<=plane.location.x+plane_width;
	cy0=bomb.location.y>=plane.location.y;
	cy1=bomb.location.y<=plane.location.y+plane_height; 
	
	cpb=cx0 && cx1 && cy0 && cy1;
	return cpb;
}

 bool shoot(Bullet bullet,Bomb bomb)
{
	bool sbb,sx0,sx1,sy0,sy1;
	sx0=(bomb.location.x>=bullet.location.x-1);
	sx1=(bomb.location.x<=bullet.location.x+1);	
	sy0=(bomb.location.y>=bullet.location.y);
	sy1=(bomb.location.y<=bullet.location.y+1);	
	sbb=sx0 &&sx1&&sy0&&sy1;
	return sbb;
}

//********************************************************************************
 //以下三个函数为播放背景音乐功能 
//********************************************************************************
 
 //播放一遍背景音乐 
 void play_bgmusic() {  
 
	mciSendString(TEXT("open hero.mp3 alias s1"),NULL,0,NULL);
	mciSendString(TEXT("play s1"),NULL,0,NULL);
 
	Sleep(153*1000);//153*1000意思是153秒,是整首音乐的时长 
	mciSendString(TEXT("close S1"),NULL,0,NULL); 
  
}
 
//循环播放音乐线程函数 
void* thread_bgmusic(void* arg) //
{ 
  while(1)
  {  	
  	play_bgmusic();
  }
} 
 
//创建音乐播放线程,开始循环播放音乐 
void bgmusic()
{
	pthread_t tid; 
  	pthread_create(&tid, NULL, thread_bgmusic, NULL);
}

四、运行效果

（一）子弹与炮弹相撞

（二）炮弹与飞机相撞、飞机复活

 （未完待续）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/900781.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测（多指标，多图）

回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测（多指标，多图）

回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09; 目录 回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09;效果一览基本…
阅读更多...
【华为鸿蒙3.0/荣耀安卓12使用VMOS Pro的激活方式】

【华为鸿蒙3.0/荣耀安卓12使用VMOS Pro的激活方式】

关于华为鸿蒙3.0/荣耀安卓12如何解除进程限制&#xff0c;这里提供以下教程供小伙伴们参考。 需要准备&#xff1a;电脑一台&#xff0c;数据线一根。 第一步&#xff1a;打开手机USB调试模式。 确保USB数据线已连接手机和电脑&#xff0c;打开手机“开发者选项”&#xff0…
阅读更多...
Monitor.Analog产品老化试验软件概要设计

Monitor.Analog产品老化试验软件概要设计

Monitor.Analog产品老化试验软件概要设计&#xff1a; 1. 引言&#xff1a; 模拟量采集软件的目标是实现对模拟量信号的采集、处理和展示。该软件旨在提供一个用户友好的界面&#xff0c;允许用户配置采集参数、实时监测模拟量信号&#xff0c;并提供数据分析和导出功能。 2. 功…
阅读更多...
K210学习笔记——三角函数下的目标追踪

K210学习笔记——三角函数下的目标追踪

各位正在读文章的朋友们你们好&#xff0c;本人为非专业学生&#xff0c;如有不对的地方&#xff0c;期待您的指正。 目标追踪的意思是&#xff1a;识别到目标物体&#xff0c;通过舵机转动&#xff0c;朝向目标物体. 实验器材&#xff1a;二自由度舵机云台加两个SG90舵机&…
阅读更多...
预警：传统的QA岗位将被DevOps淘汰

预警：传统的QA岗位将被DevOps淘汰

导读在大多数机构或公司里&#xff0c;软件开发过程主要遵循一个或多个开发模型&#xff0c;例如瀑布模型或敏捷模型。在瀑布模型中&#xff0c;测试活动一般都在后期进行。软件开发完成后&#xff0c;缺陷被QA团队找出&#xff0c;然后再被修复。后两个活动不断循环和重复&…
阅读更多...
Python基础语法入门(第二十三天)——正则表达式

Python基础语法入门(第二十三天)——正则表达式

正则表达式是一种文本模式&#xff0c;用于匹配字符串&#xff0c;它是由字符和特殊字符组成的模式。正则表达式可以用于验证、搜索、替换和提取字符串。其能够应用于各种编程语言和文本处理工具中&#xff0c;如Python、Java、JavaScript等。 正则表达式在线测试工具&#xf…
阅读更多...
Spring源码编译-for mac

Spring源码编译-for mac

超详细的spring源码编译 记&#xff1a;编译成功时间&#xff1a;2023.08.19 环境准备&#xff1a; 1.idea 2023.1.1 Community Edition 2.jdk1.8 3.gradlegradle-5.6.4 4.spring源码(版本&#xff1a;spring-framework-v5.2.25.RELEASE) 一.spring源码下载 github 加速网站&…
阅读更多...
stm32单片机4个开关控制8个LED灯，4种不同模式参考源代码（附带PROTEUS电路图）

stm32单片机4个开关控制8个LED灯，4种不同模式参考源代码（附带PROTEUS电路图）

//main.c文件 /* USER CODE BEGIN Header */ /********************************************************************************* file : main.c* brief : Main program body************************************************************************…
阅读更多...
0101前期准备-大数据学习

0101前期准备-大数据学习

文章目录 1 前言2 配置VMware虚拟机2.1 设置主机名和固定IP2.2 本地系统与Linux系统配置主机名映射2.3 配置虚拟机之间用户的SSH免密互通2.4 安装JDK环境2.5 关闭防火墙和SELinux2.6 更新时区和同步时间2.7 保存虚拟机快照 结语 1 前言 我们从基础的hadoop开始学起&#xff0c;…
阅读更多...
Python上楼梯问题：递归解法探究（斐波那契变种）（记忆化递归）

Python上楼梯问题：递归解法探究（斐波那契变种）（记忆化递归）

文章目录 上楼梯问题&#xff1a;递归解法探究问题定义解决方案1. 递归2. 记忆化递归关于python memo{}默认参数和字典的语法语法功能版本信息注意事项 结论 上楼梯问题&#xff1a;递归解法探究 在这篇文章中&#xff0c;将对上楼梯问题进行深入探讨。上楼梯问题是一种常见的…
阅读更多...
2D应用开发是选择WebGL 还是选择Canvas？

2D应用开发是选择WebGL 还是选择Canvas？

推荐&#xff1a;使用 NSDT场景编辑器 助你快速搭建可二次编辑的3D应用场景 在介绍WebGL和Canvas的区别和联系之前&#xff0c;需要先了解它们各自的定义和特点。 WebGL是一种基于标准HTML5的技术&#xff0c;用于在Web浏览器中实时渲染3D图形。它是由Khronos Group开发的一套…
阅读更多...
C++系列-内存模型

C++系列-内存模型

内存模型 内存模型四个区代码区全局区栈区堆区内存开辟和释放在堆区开辟数组 内存模型四个区 不同区域存放的数据生命周期是不同的&#xff0c;更为灵活。 代码区&#xff1a;存放函数体的二进制代码&#xff0c;操作系统管理。全局区&#xff1a;存放全局变量&#xff0c;常…
阅读更多...
工厂模式的三种姿态？

工厂模式的三种姿态？

在软件工程中常见的设计模式——工厂模式。工厂模式是一种有力的工具&#xff0c;用于创建对象实例的方式&#xff0c;可以帮助我们更好地组织代码和降低耦合性。在本文中&#xff0c;我将为大家详细介绍工厂模式的三种姿态&#xff0c;同时通过举例和代码演示来帮助大家更好地…
阅读更多...
Docker环境安装elasticsearch和kibana

Docker环境安装elasticsearch和kibana

一、安装elasticsearch 创建es-network&#xff0c;让es、kibana在同一个网段&#xff1a; docker network create --driverbridge --subnet192.168.1.10/24 es-network运行elasticsearch docker run -d \ --name elasticsearch \ # 容器名 --hostname elasticsearch # 主机…
阅读更多...
【Redis】Redis中的布隆过滤器

【Redis】Redis中的布隆过滤器

【Redis】Redis中的布隆过滤器 前言 在实际开发中&#xff0c;会遇到很多要判断一个元素是否在某个集合中的业务场景&#xff0c;类似于垃圾邮件的识别&#xff0c;恶意IP地址的访问&#xff0c;缓存穿透等情况。类似于缓存穿透这种情况&#xff0c;有许多的解决方法&#xf…
阅读更多...
高效的WMS系统手持盘点方案

高效的WMS系统手持盘点方案

WMS系统手持盘点就是指利用WMS系统支持的手持式电子盘点设备进行库存盘点的方式。 具体来说: - 手持盘点设备是一种小型的电子设备,具有移动条形码扫描功能,可以实时与WMS系统联通。 - WMS系统利用手持设备,可以给仓储人员下发具体的盘点任务,例如需要盘点的货位、商品等信息…
阅读更多...
mybatis plus 配置自动设置创建时间和创建人id

mybatis plus 配置自动设置创建时间和创建人id

1.新建 MyMetaObjectHandler package com.ruoyi.framework.config;import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler; import com.ruoyi.common.bean.LocalUser; import com.ruoyi.coupon.domain.CouponUser; import org.apache.ibatis.reflection.MetaObjec…
阅读更多...
软件报错msvcr90.dll丢失的解决方法，亲测可以修复

软件报错msvcr90.dll丢失的解决方法，亲测可以修复

我曾经遇到过一个令人头疼的问题&#xff1a;msvcr90.dll丢失。这个问题导致了我的程序无法正常运行&#xff0c;让我感到非常苦恼。然而&#xff0c;在经过一番努力后&#xff0c;我终于成功地修复了这个问题&#xff0c;这让我感到非常欣慰和满足。 msvcr90.dll丢失的原因可能…
阅读更多...
python高级基础

python高级基础

文章目录 python高级基础闭包修饰器单例模式跟工厂模式工厂模式单例模式 多线程多进程创建websocket服务端手写客户端 python高级基础 闭包 简单解释一下闭包就是可以在内部访问外部函数的变量&#xff0c;因为如果声明全局变量&#xff0c;那在后面就有可能会修改 在闭包中的…
阅读更多...
深入探讨API接口测试：从基础到高级策略

深入探讨API接口测试：从基础到高级策略

引言&#xff1a;API测试的重要性 在当前的技术趋势中&#xff0c;API&#xff08;应用程序接口&#xff09;已经成为连接各种系统和服务的基石。API不仅仅是大型企业的领域&#xff0c;中小型公司和初创公司也越来越依赖API来拓展他们的业务功能和跨系统通信。正因如此&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023