一篇博客学会了坦克大战

最新推荐文章于 2024-01-10 21:55:14 发布
最新推荐文章于 2024-01-10 21:55:14 发布
阅读量399 收藏 18
点赞数 32
分类专栏： C++ 小游戏 文章标签： 游戏 游戏开发 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46376834/article/details/118651578
版权

坦克大战

实例

《坦克大战》是由日本南梦宫Namco游戏公司开发的一款平面射击游戏，于1985年发售。游戏以坦克战斗及保卫基地为主题，属于策略型联机类。
该游戏是FC平台上少有的内建关卡编辑器的几个游戏之一，玩家可自己创建独特的关卡，并通过获取一些道具使坦克和基地得到强化.

在这里插入图片描述
游戏的架构:
在这里插入图片描述

开始界面在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

游戏进行中
在这里插入图片描述

失败
在这里插入图片描述

胜利在这里插入图片描述

像素

像素是整个图像中不可分割的单位或者是元素，每个像素近似一个小方块，这些小方块都有一个明确的位置和被分配的色彩数值（显示不同的颜色）

在这里插入图片描述

原理:
在这里插入图片描述

分辨率

分辨率（屏幕分辨率）是屏幕图像的精密度，是指显示器所能显示的像素有多少，分辨率越大，单位面积内分布的像素点就越多，画面就越精细
如： 14英寸笔记本屏幕分辨率 1280 x 960 表示的意义是屏幕是由 1280 乘以 960 = 1228800 个像素点组成，其中宽占1280 个像素，高占960 像素

4:3 是最常见屏幕比例，从电视时代流传下来的古老标准。在近代宽屏幕兴起前，绝大部分的屏幕分辨率都是照着这个比例的。
常见手机屏幕分辨率
常见手机屏幕分辨率
VGA(640x480) - 「VGA」 其实本来不是个分辨率的规格，而是 IBM 计算机的一种显示标准。在规范里有 320x200 / 256 色、320x200 / 16 色、640x350 / 16 色、640x480 / 16 色等多种模式，甚至还有 80x25 和 40x25 等文字模式。只是最后因为官方支持的最高分辨率是 640x480，所以 VGA 就成为了 640x480 的代名词。VGA 的重要地位在于它是所有显卡都接受的基准分辨率，Windows 在加载显卡驱动程序之前（BIOS 之后）的画面，那个画面就是在 VGA 分辨率下的。
SVGA(800x600) - SVGA 的情况和 VGA 有点像，也是以一种「规格」的身份起家的，只是最后好像变成无论规格如何，所有比 VGA 强的显示器都自称自已是 Super VGA，或 SVGA。在分辨率上，SVGA 专指 800x600 的分辨率 – 即使当年标榜自已是 SVGA 的屏幕其实常常可到达 1024x768，或更高。
XGA(1024x768) - 到了 SVGA 的年代，IBM 已经失去了市场的独占性，PC界也正式进入了百家争鸣的时代。IBM 虽然定义出了XGA 的规格，但实际上它只是当年多种 Super VGA 规格中的一种。XGA 最后成为 1024x768 这个分辨率的代名词。
常见屏幕分辨率
常见屏幕分辨率
SXGA+(1400x1050) - SXGA+ 是大约 2003 年～2007 年间偶尔会在笔记本电脑上看到的分辨率。不过随着宽屏幕大行其道，这个分辨率很难看到了。
UXGA(1600x1200) - UXGA 又称为 UGA，分辨率刚好是SVGA 的四倍。UXGA 是许多 4:3 的 20" 和 21" 屏幕的析度，不过随着4:3 屏幕愈来愈少见，要买到这个分辨率的屏幕是愈来愈困难了。
QXGA(2048x1536) - QXGA 的分辨率是 XGA 的四倍，也是大部分 4:3屏幕支持的极限。
更高的 4:3 分辨率，比如 QUXGA，只是个理论上的名字。在真实世界没有采用这个分辨率的产品存在。

在这里插入图片描述

源码

#include <graphics.h>
#include <conio.h>
#include <Windows.h>
#include <time.h>

#pragma comment (lib, "Winmm.lib") //导入声音库
/*
#define UP 0
#define DOWN  1
#define LEFT 2
#define RIGHT 3
*/

#define SUCCESS 0
#define FAILURE 1

#define ENEMY_NUM 10

enum DIRECTION {
	UP,
	DOWN,
	LEFT,
	RIGHT
};


//坦克结构体
struct tank_s {
	int x;  //坦克在地图数组中所在列
	int y;  //坦克在地图数组中所在的行
	DIRECTION direction;  //坦克的方向，上、下、左、右
	int live;       //是否生存 1-活着  0-挂了
};

//子弹结构体
struct bullet_s {
	int pos_x;   //子弹在“戏台”上的横坐标
	int pos_y;   //子弹在“戏台”上的纵坐标
	DIRECTION  direction; //子弹方向
	int status;  //子弹是否存在
};


//定义地图数组
int map[26][26] = {
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1 },
	{ 2, 2, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 2, 2 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};


void menu();
void init_map();
void init_map_2(int* map, int rows, int cols);
int play();
int do_tank_walk(tank_s* tank, DIRECTION direction, IMAGE* img, int step);
void set_prop_map(int x, int y, int val);
int bullet_action(bullet_s* bullet, tank_s* enemy_tank);
void tank_walk(tank_s* tank, DIRECTION direction, IMAGE* img);
DIRECTION  enemy_direction(tank_s* tank, int x, int y);
void game_over(int result);

int main(void) {
	int result = SUCCESS;
	//搭建舞台
	initgraph(650, 650);// 初始化图形环境
	//AGAIN:
		//开始场景，显示菜单
	menu();

	//初始化地图
	//init_map_2(&map[0][0], 26, 26);
	init_map();

	//判断play 的结果，返回1说明我方失败，否则，我方胜利
	result = play();

	//显示游戏结果
	game_over(result);

	//是否继续游戏?
	/*
	int ret = MessageBox(NULL, TEXT("是否重新开始？"), TEXT("请选择"), MB_YESNO | MB_ICONQUESTION);
	if (ret == IDYES)
	{
		cleardevice();
		//重新导入地图,进入第二关，自己考虑怎么实现？
		goto AGAIN;
	}
	*/
	system("pause");
	closegraph();
	exit(0);
}

void game_over(int result) {
	IMAGE img;
	if (result == SUCCESS) {
		loadimage(&img, _T("success.jpg"), 500, 250);
		putimage(80, 200, &img);

	}
	else {
		loadimage(&img, _T("failure.jpg"), 500, 250);
		putimage(80, 200, &img);
	}
	_getch();
}

void menu() {
	//显示 logo
	IMAGE logo_img;//图像对象。
	loadimage(&logo_img, _T("logo.bmp"), 433, 147);//从文件中读取图像。
	putimage(110, 20, &logo_img);//绘制图像

	//实现导航按钮
	setlinecolor(WHITE);//设置当前画线颜色。
	setfillcolor(BLACK);//设置当前的填充颜色

	fillrectangle(230, 200, 310, 240);//画填充矩形（有边框）。
	settextstyle(25, 0, _T("宋体")); //设置当前字体样式
	outtextxy(240, 210, _T("说 明"));// 在指定位置输出字符串

	fillrectangle(350, 200, 430, 240);
	outtextxy(360, 210, _T("开 始"));

	MOUSEMSG mouse;
	IMAGE illustrate_img;
	loadimage(&illustrate_img, _T("illustrate.jpg"), 300, 300);



	while (1 == 1) {
		mouse = GetMouseMsg(); //获取一个鼠标消息。如果没有，就等待

		switch (mouse.uMsg) {// 当前鼠标消息
		case WM_MOUSEMOVE:
			if ((mouse.x > 230 && mouse.x < 310) && (mouse.y > 200 && mouse.y < 240)) {
				putimage(150, 250, &illustrate_img);//绘制图像
			}
			else {
				solidrectangle(150, 250, 450, 550);// 画填充矩形(无边框)
			}
			break;
		case WM_LBUTTONDOWN:
			if ((mouse.x > 350 && mouse.x < 430) && (mouse.y > 200 && mouse.y < 240)) {
				cleardevice();//清屏
				return;
			}
		}
	}
}

/*
初始化地图，可消除墙为1，不可消除墙为 2，老鹰 (3 ,4)
*/
void init_map() {
	int i, j;
	IMAGE img_home, img_wall_1, img_wall_2;

	loadimage(&img_home, _T("home.jpg"), 50, 50);// 老鹰
	loadimage(&img_wall_1, _T("wall1.jpg"), 25, 25);//不可消除的墙
	loadimage(&img_wall_2, _T("wall2.jpg"), 25, 25);//可消除的墙

	for (i = 0; i < 26; i++) {
		for (j = 0; j < 26; j++) {
			if (map[i][j] == 1) {
				putimage(25 * j, 25 * i, &img_wall_2);
			}
			else if (map[i][j] == 2) {
				putimage(25 * j, 25 * i, &img_wall_1);
			}
			else if (map[i][j] == 3) {
				putimage(25 * j, 25 * i, &img_home);
				set_prop_map(j, i, 4);
			}
		}
	}
}


void set_prop_map(int x, int y, int val) {
	map[y][x] = val;
	map[y][x + 1] = val;
	map[y + 1][x] = val;
	map[y + 1][x + 1] = val;
}

/*********************************
*控制坦克按相应的方向前进一步
*返回值：失败 - 0   成功 -1
*********************************/
int do_tank_walk(tank_s* tank, DIRECTION direction, IMAGE* img, int step) {
	int new_x = tank->x;
	int new_y = tank->y;

	int old_prop = map[tank->y][tank->x];

	if (step == 1) {//坦克前进一步
		if (direction == UP) {
			new_y -= 1;
		}
		else if (direction == DOWN) {
			new_y += 1;
		}
		else if (direction == LEFT) {
			new_x -= 1;
		}
		else if (direction == RIGHT) {
			new_x += 1;
		}
		else {
			return 0; //无效的方向
		}

		set_prop_map(tank->x, tank->y, 0);
	}

	setfillcolor(BLACK);
	solidrectangle(tank->x * 25, tank->y * 25, tank->x * 25 + 50, tank->y * 25 + 50);

	if (step == 1) {
		set_prop_map(new_x, new_y, old_prop);
		tank->x = new_x;
		tank->y = new_y;
	}
	putimage(tank->x * 25, tank->y * 25, img);
	return 1;
}


/*************************************
 * 实现子弹运行和碰撞检测，并反馈游戏结果
 * 返回：1 -表示游戏失败  0 - 继续游戏
 **************************************/
int bullet_action(bullet_s* bullet, tank_s* enemy_tank) {
	int x, y, x1, y1;  //子弹目前所在的二维数组中的坐标

	x = bullet->pos_x / 25;
	y = bullet->pos_y / 25;

	//1.擦除上一次绘制的子弹
	setfillcolor(BLACK);
	solidrectangle(bullet->pos_x, bullet->pos_y, bullet->pos_x + 3, bullet->pos_y + 3);

	//2.根据方向计算子弹在“戏台”上的坐标
	if (bullet->direction == UP) {
		bullet->pos_y -= 2;
		x1 = x + 1;
		y1 = y;
	}
	else if (bullet->direction == DOWN) {
		bullet->pos_y += 2;
		x1 = x + 1;
		y1 = y;
	}
	else if (bullet->direction == LEFT) {
		bullet->pos_x -= 2;
		x1 = x;
		y1 = y + 1;

	}
	else if (bullet->direction == RIGHT) {
		bullet->pos_x += 2;
		x1 = x;
		y1 = y + 1;
	}
	else {
		return 0;
	}

	if (bullet->pos_x < 0 || bullet->pos_x>650 || bullet->pos_y < 0 || bullet->pos_y>650) {
		bullet->status = 0;
		return 0;
	}

	//碰撞检测
	if (map[y][x] == 4 || map[y1][x1] == 4) {//击中老鹰
		return 1;
	}

	if (map[y][x] == 200 || map[y1][x1] == 200) {//击中我方坦克
		return 1;
	}

	if ((map[y][x] >= 100 && map[y][x] <= 109) || (map[y1][x1] >= 100 && map[y1][x1] <= 109)) {
		tank_s* tank = NULL;
		bullet->status = 0;

		if (map[y][x] >= 100 && map[y][x] <= 109) {
			tank = enemy_tank + (map[y][x] - 100);
		}
		else tank = enemy_tank + (map[y1][x1] - 100);

		tank->live = 0;
		set_prop_map(tank->x, tank->y, 0);
		setfillcolor(BLACK);
		solidrectangle(tank->x * 25, tank->y * 25, tank->x * 25 + 50, tank->y * 25 + 50);

	}



	if (map[y][x] == 1) {//子弹击中可消除的墙
		map[y][x] = 0;
		bullet->status = 0;
		setfillcolor(BLACK);
		solidrectangle(x * 25, y * 25, x * 25 + 25, y * 25 + 25);
	}
	else if (map[y][x] == 2) {
		bullet->status = 0;
	}

	if (map[y1][x1] == 1) {//子弹击中可消除的墙
		map[y1][x1] = 0;
		bullet->status = 0;
		setfillcolor(BLACK);
		solidrectangle(x1 * 25, y1 * 25, x1 * 25 + 25, y1 * 25 + 25);
	}
	else if (map[y1][x1] == 2) {
		bullet->status = 0;
	}


	//3.重新绘制子弹
	if (bullet->status == 1) {
		setfillcolor(WHITE);
		solidrectangle(bullet->pos_x, bullet->pos_y, bullet->pos_x + 3, bullet->pos_y + 3);
	}
	return 0;
}


void tank_walk(tank_s* tank, DIRECTION direction, IMAGE* img) {
	switch (direction) {
	case LEFT:  //左
		if (tank->direction == LEFT && (tank->x - 1) >= 0 && map[tank->y][tank->x - 1] == 0 && map[tank->y + 1][tank->x - 1] == 0) {//左边是空地
			do_tank_walk(tank, LEFT, img, 1);
		}
		else if (tank->direction != LEFT) {
			tank->direction = LEFT;
			do_tank_walk(tank, LEFT, img, 0);
		}
		break;
	case UP:  //上
		if (tank->direction == UP && (tank->y - 1) >= 0 && map[tank->y - 1][tank->x] == 0 && map[tank->y - 1][tank->x + 1] == 0) {//上边是空地
			do_tank_walk(tank, UP, img, 1);
		}
		else if (tank->direction != UP) {
			tank->direction = UP;
			do_tank_walk(tank, UP, img, 0);
		}
		break;
	case DOWN:  //下
		if (tank->direction == DOWN && (tank->y + 2) <= 25 && map[tank->y + 2][tank->x] == 0 && map[tank->y + 2][tank->x + 1] == 0) {//下边是空地
			do_tank_walk(tank, DOWN, img, 1);
		}
		else if (tank->direction != DOWN) {
			tank->direction = DOWN;
			do_tank_walk(tank, DOWN, img, 0);
		}
		break;
	case RIGHT:  //右
		if (tank->direction == RIGHT && (tank->x + 2) <= 25 && map[tank->y][tank->x + 2] == 0 && map[tank->y + 1][tank->x + 2] == 0) {//右边是空地
			do_tank_walk(tank, RIGHT, img, 1);
		}
		else if (tank->direction != RIGHT) {
			tank->direction = RIGHT;
			do_tank_walk(tank, RIGHT, img, 0);
		}
		break;
	}

}

/******************************************
*根据目标位置，调整敌方坦克的方向
*
******************************************/

DIRECTION  enemy_direction(tank_s* tank, int x, int y) {
	int r = rand() % 100;

	if (tank->x > x) { //目标在左边
		if (tank->y > y) {//目标在左上方
			if (r <= 50) return UP;
			else return LEFT;
		}
		else {         //目标在左下方
			if (r <= 50) return DOWN;
			else return LEFT;
		}

	}
	else {//目标在右边
		if (tank->y > y) {//目标在右上方
			if (r <= 50) return UP;
			else return RIGHT;
		}
		else {         //目标在右下方
			if (r <= 50) return DOWN;
			else return RIGHT;
		}

	}

}

void tank_fire(tank_s* tank, bullet_s* bullet, int need_sound) {
	if (bullet->status == 0) {
		if (need_sound) PlaySound(_T("paoji.wav"), NULL, SND_FILENAME | SND_ASYNC);
		if (tank->direction == UP) {
			bullet->pos_x = tank->x * 25 + 23;
			bullet->pos_y = tank->y * 25 - 3;
		}
		else if (tank->direction == LEFT) {
			bullet->pos_x = tank->x * 25 - 3;
			bullet->pos_y = tank->y * 25 + 23;
		}
		else if (tank->direction == DOWN) {
			bullet->pos_x = tank->x * 25 + 23;
			bullet->pos_y = tank->y * 25 + 50;
		}
		else if (tank->direction == RIGHT) {
			bullet->pos_x = tank->x * 25 + 50;
			bullet->pos_y = tank->y * 25 + 23;
		}

		bullet->direction = tank->direction;
		bullet->status = 1;
	}

}

/*****************************
*实现游戏场景
******************************/
int play() {

	tank_s my_tank;  //我方坦克
	bullet_s my_bullet;//我方坦克发射的子弹

	tank_s enemy_tank[ENEMY_NUM]; //敌方坦克
	bullet_s enemy_bullet[ENEMY_NUM];//敌方坦克发射的子弹

	IMAGE my_tank_img[4];
	IMAGE enemy_tank_img[4];
	int key;
	int times = 1;//记录当前程序的休眠次数，没次10ms
	int enemy_total = 0;

	//初始化随机数种子
	srand(time(NULL));

	//加载我方坦克的图片
	loadimage(&my_tank_img[UP], _T("tank_up.jpg"), 50, 50);
	loadimage(&my_tank_img[DOWN], _T("tank_down.jpg"), 50, 50);
	loadimage(&my_tank_img[LEFT], _T("tank_left.jpg"), 50, 50);
	loadimage(&my_tank_img[RIGHT], _T("tank_right.jpg"), 50, 50);

	//加载敌方坦克的图片
	loadimage(&enemy_tank_img[UP], _T("enemy_tank_up.jpg"), 50, 50);
	loadimage(&enemy_tank_img[DOWN], _T("enemy_tank_down.jpg"), 50, 50);
	loadimage(&enemy_tank_img[LEFT], _T("enemy_tank_left.jpg"), 50, 50);
	loadimage(&enemy_tank_img[RIGHT], _T("enemy_tank_right.jpg"), 50, 50);

	my_bullet.status = 0; //子弹目前尚不存在

	//设定我方坦克的出场的位置
	my_tank.x = 8;
	my_tank.y = 24;
	my_tank.live = 1;
	my_tank.direction = UP;
	set_prop_map(my_tank.x, my_tank.y, 200);

	//设置敌方坦克出场的位置
	for (int i = 0; i < ENEMY_NUM; i++) {
		if (i % 3 == 0) {
			enemy_tank[i].x = 0;
		}
		else if (i % 3 == 1) {
			enemy_tank[i].x = 12;
		}
		else if (i % 3 == 2) {
			enemy_tank[i].x = 24;
		}
		enemy_tank[i].direction = DOWN;
		enemy_tank[i].y = 0;
		enemy_tank[i].live = 1;
		//set_prop_map(enemy_tank[i].x, enemy_tank[i].y, 100+i);
		enemy_bullet[i].status = 0;

	}
	//音乐响起来
	mciSendString(_T("open background.wav alias a1 wait"), NULL, 0, NULL);
	mciSendString(_T("play a1"), 0, 0, 0);

	//前3辆坦克闪亮登场
	do_tank_walk(&enemy_tank[0], DOWN, &enemy_tank_img[DOWN], 0);
	set_prop_map(enemy_tank[0].x, enemy_tank[0].y, 100);
	do_tank_walk(&enemy_tank[1], DOWN, &enemy_tank_img[DOWN], 0);
	set_prop_map(enemy_tank[1].x, enemy_tank[1].y, 101);
	do_tank_walk(&enemy_tank[2], DOWN, &enemy_tank_img[DOWN], 0);
	set_prop_map(enemy_tank[2].x, enemy_tank[2].y, 102);
	enemy_total = 3;

	putimage(my_tank.x * 25, my_tank.y * 25, &my_tank_img[my_tank.direction]);

	while (1) {
		if (times > 0 && times % 1000 == 0 && enemy_total < ENEMY_NUM) {
			//判断出场的二维数组的位置是否已经有坦克存在，自行实现
			set_prop_map(enemy_tank[enemy_total].x, enemy_tank[enemy_total].y, 100 + enemy_total);
			enemy_total++;
		}
		if (times % 200 == 0) {//2ms 调整敌方坦克的方向
			for (int i = 0; i < enemy_total; i++) {
				if (enemy_tank[i].live == 0) continue;
				if (i % 2 == 0) {//攻击我方老巢
					DIRECTION d = enemy_direction(&enemy_tank[i], 12, 24);
					tank_walk(&enemy_tank[i], d, &enemy_tank_img[d]);
				}
				else {//攻击我方坦克
					DIRECTION d = enemy_direction(&enemy_tank[i], my_tank.x, my_tank.y);
					tank_walk(&enemy_tank[i], d, &enemy_tank_img[d]);
				}

				tank_fire(&enemy_tank[i], &enemy_bullet[i], 0);
			}
		}
		else if (times % 50 == 0) {//0.5ms移动敌方还生存的坦克
			for (int i = 0; i < enemy_total; i++) {
				if (enemy_tank[i].live) {
					tank_walk(&enemy_tank[i], enemy_tank[i].direction, &enemy_tank_img[enemy_tank[i].direction]);
				}
			}

		}

		if (_kbhit()) {
			key = _getch();

			switch (key) {
			case 'a':  //左
				tank_walk(&my_tank, LEFT, &my_tank_img[LEFT]);
				break;
			case 'w':  //上
				tank_walk(&my_tank, UP, &my_tank_img[UP]);
				break;
			case 's':  //下
				tank_walk(&my_tank, DOWN, &my_tank_img[DOWN]);
				break;
			case 'd':  //右
				tank_walk(&my_tank, RIGHT, &my_tank_img[RIGHT]);
				break;
			case 'j':  //开火
				tank_fire(&my_tank, &my_bullet, 1);
				break;
			case 'p':  //暂停
				system("pause");
				break;
			default:   //其他键盘输入无须处理
				break;
			}
		}
		if (my_bullet.status == 1) {
			if (bullet_action(&my_bullet, enemy_tank)) return FAILURE;//我方子弹运动效果
		}
		for (int i = 0; i < ENEMY_NUM; i++) {//敌方子弹运动效果
			if (enemy_bullet[i].status == 1) {
				if (bullet_action(&enemy_bullet[i], enemy_tank)) return FAILURE;
			}
		}
		//判断敌方坦克是否全部被消灭
		int isWin = 1;
		for (int i = 0; i < ENEMY_NUM; i++) {
			if (enemy_tank[i].live == 1) isWin = 0;
		}

		if (isWin) return SUCCESS;

		Sleep(10);
		times++;
	}
}
Respect@
关注
  • 32
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
Unity零基础到入门 ☀️| Unity从青铜 到 王者！只差这篇让你学会Unity中最重要的部分——脚本组件✨
努力前行，总会成为自己心中的那道光
05-27 9万+
从 倔强青铜 到 荣耀王者！只差这篇让你学会Unity中最重要的部分——脚本组件✨。本篇内容对Unity脚本做了一个超级详细的介绍，从开发工具到具体实例，API等都有介绍。
正找工作的同学看过来——Java项目经验篇
xinshiedu的博客
06-21 2万+
学习Java就是用来做项目的!Java的主要应用领域就是企业级的项目开发!要想从事企业级的项目开发，你必须掌握如下要点，正在找工作的同学自行阅读哦! 　 　　1、掌握项目开发的基本步骤 　　2、具备极强的面向对象的分析与设计技巧 　　3、掌握用例驱动、以架构为核心的主流开发方法 　　没有人愿意自己一辈子就满足于掌握了一些代码实现的技巧，别人告诉你要实现什么，你就用代码堆砌来实现别人的要求!你必须学...
使用Unity开发坦克大战游戏（一）
fanc的博客
12-25 5809
导入Unity素材包 场景的搭建与素材处理 场景搭建 将摄像头的大小设置为8.5，摄像机离游戏的距离，不能够是负数，摄像头距离可以一点一点调试。数值策划师会预先设置好。 屏幕的背景设置为黑色 游戏显示窗口为5:4，长宽比为5：4，这样能够适配不同的屏幕，减少显示上的问题 素材处理 图片和图集的区别： 对于素材中的图片，需要将texture type调整为sprite 对于图片集，需要将spr...
unity3D实现人机坦克对战
Y2807593076的博客
01-10 1264
在学习了一个学期的unity3D游戏设计课程后，已初步掌握了unity3D游戏设计的设计流程、具体游戏实现以及相关的游戏建模。在学习的过程中，我们已经掌握了MVC模型以及带有Action的模型，它们都是进行游戏设计与实现过程中常见的游戏设计模型。其中，利用该模型，我也完成了相应的游戏实例，比如魔鬼与牧师游戏的MVC版本以及动作分离版本，还有打飞碟和射击游戏的实现。在这一个过程中，加深了我对游戏模型的认识。
用python设计一个管理系统思路_Python大佬一个月打造的Python系统学习流程图！
weixin_39638012的博客
12-08 1120
对于刚开始接触Python的小伙伴来说，没有思路方法，不知道从何开始学习，把软件环境安装好后就不知所措了！接下来我给大家分享下多位大牛倾力打造的python系统学习流程，一个月才设计完的！Python础部分：老话说的好，“万丈高楼平地起！”不管你做什么都一样，何况编程；或许初学的时候很是枯燥乏味，但是都是你之后的项目、案例的核心！好了，大道理就不多说了，先上基础部分展示给大家。一、初识Python...
我可以java你吗_我可以永久退出IT编程界，如果这篇文章 不能让你学会java
weixin_42398151的博客
02-27 76
我可以永久退出IT编程界，如果这篇文章 不能让你学会java.我们先赌为快。IT行业飞速发展，除了水涨船高的薪资水平，还有不断推陈出新的编程技术。不同的技术，应用在不同的领域。但对于小白来说，想要投身这个行业，我该从何学起?那些应用领域是未来的大趋势?而我未来的学习方向又有哪些呢?学编程，用java确实是一个相当不错的选择。不过，面对Java网上有纷杂的资料，一些程序员却不知道该怎么选择。学习Ja...
我们一起来学Shell - 初识shell
以梦为马|越骑越傻
06-25 882
文章目录Shell 的分类`bash``csh``ksh``tcsh``sh``nologin``zsh`Shell 能做什么bash 环境变量文件`/etc/profile``/etc/bashrc``~/.profile``~/.bash_login``~/.bash_profile``~/.bashrc``~/.bash_logout`bash 环境变量加载login shell与non-login shelllogin shellnon-login shellbash 特性命令和文件自动补齐命令历史
一个程序员的自述
CodeMan_X的博客
09-30 550
瞎说
人工智能基础（高中版）教材补充和资源分享之一 无限光明的未来、过去和现在
热门推荐
zhangrelay的专栏
06-15 3万+
这些天，抽空读了一下人工智能基础（高中版），觉得作为高中科普教材，还是非常不错的，五星好评推荐。 下面会针对每一章的内容，依据兴趣等补充一些资料。 2019年05月更新链接（人工智能开放课程，点击红旗就是中文版）：https://github.com/Yorko/mlcourse.ai 大纲 这是medium.com上发布的文章列表，habr.com和jqr.com。图标是可点击...
SCRATCH版坦克大战
11-09
用SCRATCH开发的坦克大战游戏，复刻童年经典，带有地图编辑器功能，可自由设计地图
Python坦克大战源代码坦克大战.zip
12-29
【Python坦克大战源代码坦克大战.zip】是一个包含Python语言实现的坦克大战小游戏的源代码集合。这个项目旨在提供一个互动的、基于文本的娱乐体验，让玩家能够享受经典的坦克战斗游戏，同时学习和理解Python编程的...
C++坦克大战完整代码.zip
07-19
坦克大战是一款经典的双人对战小游戏，深受程序员和游戏爱好者的喜爱。本文将围绕使用C++编程语言实现的坦克大战游戏进行深入解析，帮助读者理解游戏背后的编程思想和技术。 首先，核心代码文件"坦克大战.cpp"包含...
C++ 控制台版本坦克大战游戏
最新发布
05-31
C++ 控制台版坦克大战游戏是一款基于C++编程语言开发的经典射击游戏。 通过键盘控制坦克移动攻击，躲避敌方坦克的攻击，同时消灭它们以完成关卡任务，支持地图编辑。 适用人群 这款游戏适用于对C++编程和游戏开发感...
Python游戏坦克大战.zip
04-26
《Python游戏坦克大战》是一款利用Python编程语言开发的复古风格射击游戏，深受编程爱好者和游戏迷们的喜爱。在这个项目中，我们将深入探讨Python在游戏开发中的应用，以及如何利用Python来实现坦克大战的核心功能。...
非静态成员引用必须与特定对象相对
m0_46376834的博客
08-28 4714
总结来说，非静态成员引用必须与特定对象相对应，每个对象都有自己的一份非静态成员数据。这样设计可以实现对象之间的数据隔离和独立性。函数时，我们需要通过特定的对象来访问非静态成员。因此，输出结果会根据对象的不同而不同。在上述示例中，我们定义了一个名为。的类，并声明了一个非静态成员变量。函数中，我们创建了两个。
C++语言字符串转换为16进制
m0_46376834的博客
08-28 4448
，然后逐个字符遍历输入的字符串，并将其转换为对应的十六进制表示，最后将结果转换为字符串并返回。来构建一个字符串流。通过设置流的格式为十六进制（函数接受一个字符串作为参数，并使用。
protected（保护）访问权限,派生和继承的各种方式,什么时候使用继承和派生,子类对父类成员的访问权限
m0_46376834的博客
05-22 4397
访问权限protected（保护）访问权限派生和继承的各种方式什么时候使用继承和派生子类对父类成员的访问权限 protected（保护）访问权限 为什么要使用protected访问权限？ 子类的成员函数中，不能直接访问父类的private成员，已经这些成员已经被继承下来了，但是却不能访问。 只有通过父类的public函数来间接访问，不是很方便。 比如，刚才Demo中Father类中的name和age成员。 解决方案： 把name和age定义为protected访问访问权限。 效果： Son类的成员函数中，可
二叉树:计算度为0的结点
m0_46376834的博客
05-27 3079
/* 计算度为0的结点*/ void CountNode1(BiTree T){ if(T == NULL) //跳出递归条件 return; if(T->left == NULL&&T->right == NULL)//关系运算优先级== 大于逻辑运算&& count0++; CountNode1(T->right);//可以与下式调换位置 CountNode1(T->left); } ...
用love2d写一篇坦克大战
06-09
好的，以下是一个简单的坦克大战游戏示例，使用 Love2D 进行编写： ```lua -- 坦克大战游戏 -- 定义游戏窗口大小 WINDOW_WIDTH = 640 WINDOW_HEIGHT = 480 -- 定义坦克大小 TANK_WIDTH = 32 TANK_HEIGHT = 32 --...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Respect@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值