坦克大战C++

最新推荐文章于 2024-04-15 17:41:09 发布
最新推荐文章于 2024-04-15 17:41:09 发布
阅读量745 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014116612/article/details/120325200
版权

| 主要分类7个部分GAME、Globanl、Map、Tanks、Bullet、源

  • 这个版本中遇到一个问题，在程序第一次运行的时候对地图进行保存，再次读取的时候无法读取到地形，但是debug找问题的时候却能够绘制地形。希望有大佬可以帮忙指正，
  • 项目写的比较乱有些东西没有封装好，希望可以有用得到的地方
    ·

源

源.cpp

源即主函数文件

#include <cstdlib>

#include "API.h"
#include "Game.h"
C_GameClass Game;
int main ()
{
	HideCursor();
	system("mode con cols=200 lines=55");
	//Games();
	
	//Game.Welcome();
	Game.Games();
	//Game.Welcome();
	//system("pause");
	
}

API

API.h

#pragma once
//清理光标
extern void HideCursor();

//字符类型输出到坐标
extern void WriteChar(int x, int y, const char* szBuf, int Color);

//整数类型输出到坐标
extern void WriteInt(int x, int y, int szBuf, int Color);
//主菜单获取鼠标输入
extern void SelectInt();

//关卡选择获取鼠标进行菜单选择输入
extern void LevelSet();
//胜利界面选择获取鼠标进行菜单选择输入
extern void WinsSet();
//死亡界面选择获取鼠标进行菜单选择输入
extern void OverSet();
//暂停页面选择
extern void PausedSet();
//绘制地图选择
extern void CustomMapSet();


//开场音乐
extern void WelcomeMusic();

//游戏结束音乐
extern void GameOverMusic();

//坦克死亡音乐
extern void TankOverMusic();

//坦克移动音乐
extern void TankMoveMusic();

//发射子弹音乐
extern void BulletMusic();

API.cpp

#include <conio.h>
#include <iostream>
#include <Windows.h>
#pragma comment(lib,"winmm.lib")
#include "Global.h"
#include "API.h"

#include "Game.h"

//清理光标
void HideCursor()
{
	CONSOLE_CURSOR_INFO cursor;
	cursor.bVisible = FALSE;
	cursor.dwSize = sizeof(cursor);
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorInfo(handle, &cursor);
}

//字符类型输出到坐标
void WriteChar(int x, int y, const char* szBuf, int Color)
{
	COORD pos = { x * 2,y };
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorPosition(hOut, pos);
	SetConsoleTextAttribute(hOut, Color);
	std::cout << szBuf;
}

//整数类型输出到坐标
void WriteInt(int x, int y, int szBuf, int Color)
{
	COORD pos = { x * 2,y };
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorPosition(hOut, pos);
	SetConsoleTextAttribute(hOut, Color);
	std::cout << szBuf;
}

//主菜单获取鼠标输入
void SelectInt()
{
	//1 获取控制台输入句柄
	HANDLE hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
	//2 循环获取控制台输入信息
	INPUT_RECORD ir = { 0 };
	DWORD dwMode = 0;
	//-----------------------------------------------------------
	GetConsoleMode(hConsoleInput, &dwMode);
	SetConsoleMode(hConsoleInput, dwMode | ENABLE_MOUSE_INPUT);
	//-----------------------------------------------------------
	DWORD dwRealCourt = 0;
	while (true)
	{

		MOUSE_EVENT_RECORD MouseEv = ir.Event.MouseEvent;
		ReadConsoleInput(
			hConsoleInput,//控制台输入数据
			&ir,          //获取到的控制台信息就传到这个结构体中
			1,            //缓冲区INPUT_RECORD的数量
			&dwRealCourt  //传出，读取完毕的时候，究竟读取了几个结构体信息
		);
		//是一个鼠标信息
		if (ir.EventType == MOUSE_EVENT)
		{
			//如果是鼠标信息，那么就是联合体中的这个字段起作用

			if (MouseEv.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED)
			{
				int x = MouseEv.dwMousePosition.X / 2;
				int y = MouseEv.dwMousePosition.Y;

				//开始游戏
				if (36 <= x && x <= 39 && y == 24)
				{
					nSelectIntInput = 开始游戏;
				}

				//选择关卡
				else if (36 <= x && x <= 39 && y == 26)
				{
					nSelectIntInput = 选择关卡;
				}

				//绘制地图
				else if (36 <= x && x <= 39 && y == 28)
				{
					nSelectIntInput = 绘制地图;
				}

				//读取游戏
				else if (36 <= x && x <= 39 && y == 30)
				{
					nSelectIntInput = 读取游戏;
				}
				//退出游戏
				else if (36 <= x && x <= 39 && y == 32)
				{
					nSelectIntInput = 退出游戏;
				}
				return;
			}
		}
	}
}

//关卡选择获取鼠标进行菜单选择输入
void LevelSet()
{
	//1 获取控制台输入句柄
	HANDLE hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
	//2 循环获取控制台输入信息
	INPUT_RECORD ir = { 0 };
	DWORD dwMode = 0;
	//-----------------------------------------------------------
	GetConsoleMode(hConsoleInput, &dwMode);
	SetConsoleMode(hConsoleInput, dwMode | ENABLE_MOUSE_INPUT);
	//-----------------------------------------------------------
	DWORD dwRealCourt = 0;
	while (true)
	{

		MOUSE_EVENT_RECORD MouseEv = ir.Event.MouseEvent;
		ReadConsoleInput(
			hConsoleInput,//控制台输入数据
			&ir,          //获取到的控制台信息就传到这个结构体中
			1,            //缓冲区INPUT_RECORD的数量
			&dwRealCourt  //传出，读取完毕的时候，究竟读取了几个结构体信息
		);
		//是一个鼠标信息
		if (ir.EventType == MOUSE_EVENT)
		{
			//如果是鼠标信息，那么就是联合体中的这个字段起作用

			if (MouseEv.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED)
			{
				int x = MouseEv.dwMousePosition.X / 2;
				int y = MouseEv.dwMousePosition.Y;
				if (36 <= x && x <= 38 && y == 26)
				{
					nSelectLevelInput = 关卡一;
				}
				else if (36 <= x && x <= 38 && y == 28)
				{
					nSelectLevelInput = 关卡二;
				}
				else if (36 <= x && x <= 41 && y == 30)
				{
					nSelectLevelInput = 退出关卡选择;
				}
				return;
			}
		}
	}
}

//胜利界面选择获取鼠标进行菜单选择输入
void WinsSet()
{
	//1 获取控制台输入句柄
	HANDLE hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
	//2 循环获取控制台输入信息
	INPUT_RECORD ir = { 0 };
	DWORD dwMode = 0;
	//-----------------------------------------------------------
	GetConsoleMode(hConsoleInput, &dwMode);
	SetConsoleMode(hConsoleInput, dwMode | ENABLE_MOUSE_INPUT);
	//-----------------------------------------------------------
	DWORD dwRealCourt = 0;
	while (true)
	{

		MOUSE_EVENT_RECORD MouseEv = ir.Event.MouseEvent;
		ReadConsoleInput(
			hConsoleInput,//控制台输入数据
			&ir,          //获取到的控制台信息就传到这个结构体中
			1,            //缓冲区INPUT_RECORD的数量
			&dwRealCourt  //传出，读取完毕的时候，究竟读取了几个结构体信息
		);
		//是一个鼠标信息
		if (ir.EventType == MOUSE_EVENT)
		{
			//如果是鼠标信息，那么就是联合体中的这个字段起作用

			if (MouseEv.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED)
			{
				int x = MouseEv.dwMousePosition.X / 2;
				int y = MouseEv.dwMousePosition.Y;
				if (30 <= x && x <= 32 && y == 40)
				{
					nSelectWinsInput = 下一关;
				}
				else if (45 <= x && x <= 46 && y == 40)
				{
					nSelectLevelInput = nSelectWinsInput = 退出;
					for (int y = 0; y < 边界Y; y++)
					{
						for (int x = 0; x < 边界X; x++)
						{
							Static_Map[y][x] = { 0 };
							Dynamic_Map[y][x] = { 0 };
						}
					}
				}
				return;
			}
		}
	}
}

//死亡界面选择获取鼠标进行菜单选择输入
void OverSet()
{
	//1 获取控制台输入句柄
	HANDLE hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
	//2 循环获取控制台输入信息
	INPUT_RECORD ir = { 0 };
	DWORD dwMode = 0;
	//-----------------------------------------------------------
	GetConsoleMode(hConsoleInput, &dwMode);
	SetConsoleMode(hConsoleInput, dwMode | ENABLE_MOUSE_INPUT);
	//-----------------------------------------------------------
	DWORD dwRealCourt = 0;
	while (true)
	{

		MOUSE_EVENT_RECORD MouseEv = ir.Event.MouseEvent;
		ReadConsoleInput(
			hConsoleInput,//控制台输入数据
			&ir,          //获取到的控制台信息就传到这个结构体中
			1,            //缓冲区INPUT_RECORD的数量
			&dwRealCourt  //传出，读取完毕的时候，究竟读取了几个结构体信息
		);
		//是一个鼠标信息
		if (ir.EventType == MOUSE_EVENT)
		{
			//如果是鼠标信息，那么就是联合体中的这个字段起作用

			if (MouseEv.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED)
			{
				int x = MouseEv.dwMousePosition.X / 2;
				int y = MouseEv.dwMousePosition.Y;
				if (30 <= x && x <= 33 && y == 40)
				{
					nSelectOverInput = 重新开始;
				}
				else if (45 <= x && x <= 46 && y == 40)
				{
					nSelectLevelInput = nSelectOverInput = 退出;
					for (int y = 0; y < 边界Y; y++)
					{
						for (int x = 0; x < 边界X; x++)
						{
							Static_Map[y][x] = { 0 };
							Dynamic_Map[y][x] = { 0 };
						}
					}
				}
				return;
			}
		}
	}
}

//暂停页面选择
void PausedSet()
{
	//1 获取控制台输入句柄
	HANDLE hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
	//2 循环获取控制台输入信息
	INPUT_RECORD ir = { 0 };
	DWORD dwMode = 0;
	//-----------------------------------------------------------
	GetConsoleMode(hConsoleInput, &dwMode);
	SetConsoleMode(hConsoleInput, dwMode | ENABLE_MOUSE_INPUT);
	//-----------------------------------------------------------
	DWORD dwRealCourt = 0;
	while (true)
	{

		MOUSE_EVENT_RECORD MouseEv = ir.Event.MouseEvent;
		ReadConsoleInput(
			hConsoleInput,//控制台输入数据
			&ir,          //获取到的控制台信息就传到这个结构体中
			1,            //缓冲区INPUT_RECORD的数量
			&dwRealCourt  //传出，读取完毕的时候，究竟读取了几个结构体信息
		);
		//是一个鼠标信息
		if (ir.EventType == MOUSE_EVENT)
		{
			//如果是鼠标信息，那么就是联合体中的这个字段起作用

			if (MouseEv.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED)
			{
				int x = MouseEv.dwMousePosition.X / 2;
				int y = MouseEv.dwMousePosition.Y;
				if (87 <= x && x <= 90 && y == 44)
				{
					nSelectGamePaused = 继续游戏;
				}
				else if (87 <= x && x <= 90 && y == 48)
				{
					nSelectLevelInput = nSelectGamePaused = 退出;
					for (int y = 0; y < 边界Y; y++)
					{
						for (int x = 0; x < 边界X; x++)
						{
							Static_Map[y][x] = { 0 };
							Dynamic_Map[y][x] = { 0 };
						}
					}
				}
				return;
			}
		}
	}
}

//绘制地图选择
void CustomMapSet()
{
	//1 获取控制台输入句柄
	HANDLE hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
	//2 循环获取控制台输入信息
	INPUT_RECORD ir = { 0 };
	DWORD dwMode = 0;
	//-----------------------------------------------------------
	GetConsoleMode(hConsoleInput, &dwMode);
	SetConsoleMode(hConsoleInput, dwMode | ENABLE_MOUSE_INPUT);
	//-----------------------------------------------------------
	DWORD dwRealCourt = 0;
	while (nSelectDrawMap != 继续游戏 && nSelectDrawMap != 退出)
	{

		MOUSE_EVENT_RECORD MouseEv = ir.Event.MouseEvent;
		ReadConsoleInput(
			hConsoleInput,//控制台输入数据
			&ir,          //获取到的控制台信息就传到这个结构体中
			1,            //缓冲区INPUT_RECORD的数量
			&dwRealCourt  //传出，读取完毕的时候，究竟读取了几个结构体信息
		);
		//是一个鼠标信息
		if (ir.EventType == MOUSE_EVENT)
		{
			//如果是鼠标信息，那么就是联合体中的这个字段起作用

			if (MouseEv.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED)
			{
				int x = MouseEv.dwMousePosition.X / 2;
				int y = MouseEv.dwMousePosition.Y;
				//铁墙;
				if (87 <= x && x <= 91 && y == 6)
				{
					nSelectDrawMap = 铁墙;
				}
				//砖墙
				if (87 <= x && x <= 91 && y == 10)
				{
					nSelectDrawMap = 砖墙;
				}
				//草地
				if (87 <= x && x <= 91 && y == 14)
				{
					nSelectDrawMap = 草地;
				}
				//水面
				if (87 <= x && x <= 91 && y == 18)
				{
					nSelectDrawMap = 水面;
				}
				//家
				if (87 <= x && x <= 91 && y == 22)
				{
					nSelectDrawMap = 家;
				}
				if (87 <= x && x <= 91 && y == 26)
				{
					nSelectDrawMap = 继续游戏;
				}
				if (88 <= x && x <= 89 && y == 30)
				{
					nSelectDrawMap = 退出;
					for (int y = 0; y < 边界Y; y++)
					{
						for (int x = 0; x < 边界X; x++)
						{
							Static_Map[y][x] = { 0 };
							Dynamic_Map[y][x] = { 0 };
						}
					}
				}
				
			}
			if (MouseEv.dwButtonState == RIGHTMOST_BUTTON_PRESSED)
			{
				int x = MouseEv.dwMousePosition.X / 2;
				int y = MouseEv.dwMousePosition.Y;
				map.Draw(x, y, nSelectDrawMap);
			}
		}
	}
}


//开场音乐
void WelcomeMusic()
{
	PlaySound(TEXT(开场音乐), NULL, SND_FILENAME | SND_ASYNC);
}

//游戏结束音乐
void GameOverMusic()
{
	PlaySound(TEXT(GameOver), NULL, SND_FILENAME | SND_ASYNC);
}
//坦克死亡音乐
void TankOverMusic()
{
	PlaySound(TEXT(坦克死亡), NULL, SND_FILENAME | SND_ASYNC);
}
//坦克移动音乐
void TankMoveMusic()
{
	PlaySound(TEXT(坦克移动), NULL, SND_FILENAME | SND_ASYNC | SND_NOSTOP);
}
//发射子弹音乐
void BulletMusic()
{
	PlaySound(TEXT(发射子弹), NULL, SND_FILENAME | SND_ASYNC | SND_NOSTOP);
}

Globanl

Globanl.h

#pragma once
//#define UP	  0
//#define DOWN  1
//#define LEFT  2
//#define RIGHT 3



//坦克子弹方向移动的枚举
enum 移动
{
	上 = 0,
	下 = 1,
	左 = 2,
	右 = 3
};

//坦克子弹阵营的枚举
enum 阵营
{
	我方 = 1,
	敌方 = 2,
};

//坦克子弹颜色枚举
enum 颜色
{
	黑色 = 0,
	深蓝色 = 1,
	深绿色 = 2,
	湖蓝 = 3,
	深红色 = 4,
	深紫色 = 5,
	暗黄色 = 6,
	白色 = 7,
	灰色 = 8,
	亮蓝色 = 9,
	亮绿色 = 10,
	浅蓝色 = 11,
	红色 = 12,
	紫色 = 13,
	黄色 = 14,
	亮白色 = 15,
	//线条绿色底色是粉色
	BUF绿色 = 'A',
	//线条绿色底色是红色
	BUF浅绿 = 'B',
	//线条蓝色底色是红色
	BUF蓝色 = 'C',
	//全身红
	BUF红色 = 'D',
};

//子弹有效无效枚举
enum 子弹
{
	无效 = 0,
	有效 = 1,
};

//地图属性枚举
enum 地图
{
空地 = 0,
砖墙 = 2,
水面 = 3,
		
坦克 = 4,
子弹 = 5,
		
草地 = 6,
家  =  8,
铁墙 = 9,
};

enum 界面选择
{
	开始游戏 = 1,
	选择关卡 = 2,
	绘制地图 = 3,
	读取游戏 = 4,
	退出游戏 = 5,
};

enum 关卡选择
{
	关卡一 = 1,
	关卡二 = 2,
	退出关卡选择 = 3,
	自定义地图 = 4,
};

enum 胜利失败选择
{
	下一关 = 1,
	重新开始 = 2,
	退出 = 11,
	继续游戏 = 15,
};

//主界面选择
extern int nSelectIntInput;
//关卡选择
extern int nSelectLevelInput;
//胜利界面的选择
extern int nSelectWinsInput;
//死亡界面的选择
extern int nSelectOverInput;
//暂停界面选择
extern int nSelectGamePaused;
//绘制地图界面选择
extern int nSelectDrawMap;
//地图边界Y轴
#define 边界Y 55
//地图边界X轴
#define 边界X 80


//静态地图
extern int Static_Map[边界Y][边界X];

//动态地图
extern int Dynamic_Map[边界Y][边界X];


//游戏分数
extern int GameScore;
//关卡分数
extern int LevelScore;
//当前地图
extern int TheMap;

#define 开场音乐 "./sound/开场音乐.wav"
#define GameOver "./sound/GameOver.wav"
#define GameWins "./sound/开场音乐.wav"
#define 坦克死亡 "./sound/坦克死亡.wav"
#define 坦克移动 "./sound/坦克移动.wav"

#define 发射子弹 "./sound/发射子弹.wav"


//#define save "./Save.txt"

Globanlcpp

#include "Global.h"


//静态地图初始化
int Static_Map[边界Y][边界X] = { 0 };
//动态地图初始化
int Dynamic_Map[边界Y][边界X] = { 0 };

//主界面选择初始化
int nSelectIntInput = 0;
//关卡选择初始化
int nSelectLevelInput = 0;
//胜利界面的选择初始化
int nSelectWinsInput = 0;
//死亡界面的选择初始化
int nSelectOverInput = 0;
//游戏暂停界面选择初始化
int nSelectGamePaused = 0;
//绘制地图界选择初始化
int nSelectDrawMap = 0;
//游戏分数初始化
int GameScore = 0;
//关卡分数
int LevelScore = 0;
//当前地图
int TheMap = 0;

Map

Map.h

#pragma once
#include "Global.h"

class C_MapClass
{
public:


	//地图属性的绘制
	void Draw(int x, int y, int draw);

	//地图一
	void Map_One();

	//地图二
	void Map_Two();

	//绘制保存的地图
	void Map_Save();

	//用来打印自定义地图
	void DrawMapSver();


};

Map.cpp

#include "Map.h"
#include <Windows.h>
#include "API.h"

//地图一
void C_MapClass::Map_One()
{
	//----------------------------------------------------//
	//                  边界
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				//设置为边界
				Draw(x, y, 铁墙);
			}
			else
			{
				Draw(x, y, 空地);
			}
		}
	}

	//----------------------------------------------------
	//                  铁墙
	//左侧
	for (int y = 16; y < 18; y++)
	{
		for (int x = 9; x < 16; x++)
		{
			Draw(x, y, 铁墙);
		}
	}
	for (int y = 18; y < 23; y++)
	{
		for (int x = 14; x < 16; x++)
		{
			Draw(x, y, 铁墙);
		}
	}
	//右侧
	for (int y = 16; y < 18; y++)
	{
		for (int x = 64; x < 70; x++)
		{
			Draw(x, y, 铁墙);
		}
	}
	for (int y = 18; y < 23; y++)
	{
		for (int x = 64; x < 71; x++)
		{
			Draw(x, y, 铁墙);
		}
	}
	//下方
	for (int y = 36; y < 41; y++)
	{
		for (int x = 31; x < 49; x++)
		{
			Draw(x, y, 铁墙);
		}
	}
	//----------------------------------------------------
	//                  砖墙
	for (int y = 1; y < 12; y++)
	{
		//X轴
		for (int x = 37; x < 44; x++)
		{
			Draw(x,  y,  砖墙);
		}
	}
	for (int y = 30; y < 36; y++)
	{
		//X轴
		for (int x = 1; x < 79; x++)
		{
			Draw(x, y, 砖墙);

		}
	}
	//----------------------------------------------------
	//水面
	for (int y = 12; y < 18; y++)
	{
		//X轴
		for (int x = 30; x < 51; x++)
		{
			Draw(x, y, 水面);
		}
	}
	for (int y = 18; y < 23; y++)
	{
		//X轴
		for (int x = 1; x < 14; x++)
		{
			Draw(x, y, 水面);
		}
	}
	for (int y = 18; y < 23; y++)
	{
		//X轴
		for (int x = 66; x < 79; x++)
		{
			Draw(x, y, 水面);

		}
	}
	//----------------------------------------------------
	//                  草地
	左侧
	for (int y = 23; y < 30; y++)
	{
		//X轴
		for (int x = 11; x < 30; x++)
		{
			Draw(x, y, 草地);

		}
	}
	for (int y = 12; y < 23; y++)
	{
		//X轴
		for (int x = 25; x < 30; x++)
		{
			Draw(x, y, 草地);

		}
	}
	//右侧
	for (int y = 23; y < 30; y++)
	{
		//X轴
		for (int x = 51; x < 69; x++)
		{
			Draw(x, y, 草地);

		}
	}
	for (int y = 12; y < 23; y++)
	{
		//X轴
		for (int x = 51; x < 56; x++)
		{
			Draw(x, y, 草地);

		}
	}
	//----------------------------------------------------
	//                   家
	for (int y = 51; y < 54; y++)
	{
		//X轴
		for (int x = 39; x < 42; x++)
		{
			Draw(x, y, 家);
		}
	}
	//家砖墙
	for (int y = 49; y < 51; y++)
	{
		//X轴
		for (int x = 37; x < 44; x++)
		{
			Draw(x, y, 砖墙);

		}
	}
	for (int y = 51; y < 54; y++)
	{
		//X轴
		for (int x = 37; x < 39; x++)
		{
			Draw(x, y, 砖墙);

		}
	}
	for (int y = 51; y < 54; y++)
	{
		//X轴
		for (int x = 42; x < 44; x++)
		{
			Draw(x, y, 砖墙);

		}
	}
	//----------------------------------------------------
}

//地图二
void C_MapClass::Map_Two()
{
	//----------------------------------------------------
	//                      边界
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				//设置为边界
				Draw(x, y, 铁墙);
			}
			else
			{
				Draw(x, y, 空地);
			}
		}
	}
	//----------------------------------------------------
	//                     铁墙
	for (int y = 24; y < 26; y++)
	{
		//X轴
		for (int x = 16; x < 31; x++)
		{
			Draw(x, y, 铁墙);
		}
	}
	//----------------------------------------------------
	//                      草地
	for (int y = 12; y < 27; y++)
	{
		//X轴
		for (int x = 50; x < 64; x++)
		{
			Draw(x, y, 草地);
		}
	}
	//----------------------------------------------------
	//                      砖墙
	for (int y = 1; y < 5; y++)
	{
		for (int x = 42; x < 55; x++)
		{
			Draw(x, y, 砖墙);
		}
	}
	for (int y = 5; y < 12; y++)
	{
		for (int x = 51; x < 55; x++)
		{
			Draw(x, y, 砖墙);
		}
	}
	for (int y = 24; y < 34; y++)
	{
		for (int x = 12; x < 16; x++)
		{
			Draw(x, y, 砖墙);
		}
	}
	for (int y = 19; y < 25; y++)
	{
		for (int x = 35; x < 50; x++)
		{
			Draw(x, y, 砖墙);
		}
	}
	for (int y = 10; y < 21; y++)
	{
		for (int x = 64; x < 68; x++)
		{
			Draw(x, y, 砖墙);
		}
	}
	for (int y = 10; y < 14; y++)
	{
		for (int x = 68; x < 79; x++)
		{
			Draw(x, y, 砖墙);
		}
	}
	//----------------------------------------------------
	//                      水面
	for (int y = 34; y < 38; y++)
	{
		for (int x = 1; x < 16; x++)
		{
			Draw(x, y, 水面);
		}
	}
	for (int y = 19; y < 24; y++)
	{
		for (int x = 12; x < 35; x++)
		{
			Draw(x, y, 水面);
		}
	}
	for (int y = 24; y < 40; y++)
	{
		for (int x = 31; x < 35; x++)
		{
			Draw(x, y, 水面);
		}
	}
	for (int y = 36; y < 40; y++)
	{
		for (int x = 26; x < 31; x++)
		{
			Draw(x, y, 水面);
		}
	}
	//----------------------------------------------------
	//                       家
	for (int y = 51; y < 54; y++)
	{
		//X轴
		for (int x = 39; x < 42; x++)
		{
			Draw(x, y, 家);
		}
	}
	//家砖墙
	for (int y = 49; y < 51; y++)
	{
		//X轴
		for (int x = 37; x < 44; x++)
		{
			Draw(x, y, 砖墙);
		}
	}
	for (int y = 51; y < 54; y++)
	{
		//X轴
		for (int x = 37; x < 39; x++)
		{
			Draw(x, y, 砖墙);

		}
	}
	for (int y = 51; y < 54; y++)
	{
		//X轴
		for (int x = 42; x < 44; x++)
		{
			Draw(x, y, 砖墙);

		}
	}
	//----------------------------------------------------
}

//绘制保存地图功能
void C_MapClass::Map_Save()
{
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				//设置为边界
				Draw(x, y, 铁墙);
			}
			//铁墙
			if (Dynamic_Map[y][x] == 铁墙)
			{
				Draw(x, y, 铁墙);
			}
			//砖墙
			if (Dynamic_Map[y][x] == 砖墙)
			{
				Draw(x, y, 砖墙);
			}
			//水面
			if (Dynamic_Map[y][x] == 水面)
			{
				Draw(x, y, 水面);
			}
			//草地
			if (Dynamic_Map[y][x] == 草地)
			{
				Draw(x, y, 草地);
			}
			//家
			if (Dynamic_Map[y][x] == 家)
			{
				Draw(x, y, 家);
			}
		}
	}
}

//地图属性绘制
void C_MapClass::Draw (int x, int y ,int draw)
{
	switch (draw)
	{
	case 铁墙:
		WriteChar(x, y, "■", 亮白色 | BACKGROUND_INTENSITY);
		Static_Map[y][x] = 铁墙;
		Dynamic_Map[y][x] = 铁墙;
		break;
	case 砖墙:
		WriteChar(x, y, "■", FOREGROUND_RED | FOREGROUND_GREEN | BACKGROUND_INTENSITY);
		Static_Map[y][x] = 砖墙;
		Dynamic_Map[y][x] = 砖墙;
		break;
	case 水面:
		WriteChar(x, y, "≈", BACKGROUND_BLUE | BACKGROUND_INTENSITY);
		Static_Map[y][x] = 水面;
		Dynamic_Map[y][x] = 水面;
		break;
	case 草地:
		WriteChar(x, y, "屮", BACKGROUND_GREEN | BACKGROUND_INTENSITY);
		Static_Map[y][x] = 草地;
		Dynamic_Map[y][x] = 草地;
		break;
	case 家:
		WriteChar(x, y, "★", FOREGROUND_RED | BACKGROUND_INTENSITY);
		Static_Map[y][x] = 家;
		Dynamic_Map[y][x] = 家;
		break;
	case 空地:
		WriteChar(x, y, "  ",1);
		Static_Map[y][x] = 空地;
		Dynamic_Map[y][x] = 空地;
		break;
	default:
		break;
	}
}

//用来打印自定义地图
void C_MapClass::DrawMapSver()
{
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				//设置为边界
				Draw(x, y, 铁墙);
			}
			//铁墙
			if (Static_Map[y][x] == 铁墙)
			{
				Draw(x, y, 铁墙);
			}
			//砖墙
			if (Static_Map[y][x] == 砖墙)
			{
				Draw(x, y, 砖墙);
			}
			//水面
			if (Static_Map[y][x] == 水面)
			{
				Draw(x, y, 水面);
			}
			//草地
			if (Static_Map[y][x] == 草地)
			{
				Draw(x, y, 草地);
			}
			//家
			if (Static_Map[y][x] == 家)
			{
				Draw(x, y, 家);
			}
		}
	}
}

Game

Game.h

#pragma once
#include "Bullet.h"
#include "Map.h"
#include "Tanks.h"
extern void Games();
#define KEY_DOWN(key)((GetAsyncKeyState(key)& 0x8000)?(1):(0))
#define KEY_UP(key)((GetAsyncKeyState(key)& 0x8001)?(1):(0))


extern C_TanksClass tanke_one;
extern C_TanksClass tanke_two;
extern C_TanksClass tanke_enemy[3];
extern C_BulletClass Bullet;
extern C_MapClass map;
class C_GameClass
{
public:
	
	//死亡重置
	void TankDeathReset();
	//判断获取键盘输入并输入到缓冲区
	void GetOper();
	//敌方坦克随机移动开炮
	void AITank();
	// 敌方坦克初始化
	void EnemyInitialize();
	//玩家坦克子弹初始化
	void OurInitialize();
	//关卡一
	void Games_Cycle();
	//欢迎界面
	void Welcome();
	//主选择界面
	void SelectInterface();
	//开始游戏
	void StartGame();
	//选择关卡
	void SelectLevel();
	//暂停游戏
	void GamePaused();
	//关卡选择界面
	void LevelSelect();
	//胜利界面
	void GameWinsUI();
	//死亡界面
	void GameOverUI();
	//侧栏信息栏
	void MapNote();
	//游戏分数的UI
	void GameScoreUI();
	//总游戏
	void Games();
	//读取保存的游戏
	void Game_Out();
	//保存游戏
	void GameSave();
	//读取游戏
	void GameOut();
	//绘制地图功能
	void DrawMap();
private:

};

Game.cpp

#include "Game.h"

#include <conio.h>
#include <cstdio>
#include <ctime>

#include "API.h"
#include "Bullet.h"
#include "Global.h"
C_TanksClass tanke_one;
C_TanksClass tanke_two;
C_TanksClass tanke_enemy[3];
C_MapClass map;


//判断获取键盘输入并输入到缓冲区
void C_GameClass::GetOper()
{
	// 获取键盘输入控制坦克方向
	if (KEY_DOWN('W') && tanke_one.Life > 0) { TankMoveMusic();  tanke_one.InPut(上); }
	// 获取键盘输入控制坦克方向
	if (KEY_DOWN('S') && tanke_one.Life > 0) { TankMoveMusic(); tanke_one.InPut(下); }
	// 获取键盘输入控制坦克方向
	if (KEY_DOWN('A') && tanke_one.Life > 0) { TankMoveMusic(); tanke_one.InPut(左); }
	// 获取键盘输入控制坦克方向
	if (KEY_DOWN('D') && tanke_one.Life > 0) { TankMoveMusic(); tanke_one.InPut(右); }
	//发射子弹出现子弹（接收坦克的方向，x轴坐标，y轴坐标，是否发射按键接收）//黑色 = 0,淡蓝 = 1,淡绿 = 2,湖蓝 = 3,淡红 = 4,紫色 = 5,黄色 = 6,白色 = 7,灰色 = 8,蓝色 = 9,绿色 = 'A',淡浅绿 = 'B',红色 = 'C',淡紫 = 'D',
	if (KEY_UP('J') && Bullet.BulletInterval_one() && tanke_one.Life > 0) { BulletMusic(); Bullet.BulletFire(tanke_one.TanknDir(), tanke_one.TankPosX(), tanke_one.TankPosY(), 我方, tanke_one.TankColor, 有效, tanke_one.g_stcTank.nATK); }

	if (KEY_DOWN('P')) { GamePaused(); }

	// 获取键盘输入控制坦克方向
	if (KEY_DOWN(VK_UP) && tanke_two.Life > 0) { TankMoveMusic(); tanke_two.InPut(上); }
	// 获取键盘输入控制坦克方向
	if (KEY_DOWN(VK_DOWN) && tanke_two.Life > 0) { TankMoveMusic(); tanke_two.InPut(下); }
	// 获取键盘输入控制坦克方向
	if (KEY_DOWN(VK_LEFT) && tanke_two.Life > 0) { TankMoveMusic(); tanke_two.InPut(左); }
	// 获取键盘输入控制坦克方向
	if (KEY_DOWN(VK_RIGHT) && tanke_two.Life > 0) { TankMoveMusic(); tanke_two.InPut(右); }
	//发射子弹出现子弹（接收坦克的方向，x轴坐标，y轴坐标，是否发射按键接收）
	if (KEY_UP(VK_NUMPAD0) && Bullet.BulletInterval_two() && tanke_two.Life > 0) { BulletMusic(); Bullet.BulletFire(tanke_two.TanknDir(), tanke_two.TankPosX(), tanke_two.TankPosY(), 我方, tanke_two.TankColor, 有效, tanke_two.g_stcTank.nATK); }
}

//敌方坦克随机移动开炮
void C_GameClass::AITank()
{
	//所有敌方随机方向
	for (int i = 0; i < 3; i++)
	{
		//判断敌方坦克血量是否为零
		if (tanke_enemy[i].g_stcTank.nHP != 0)
		{
			//将坦克当前方向付给准备获取移动的变量
			int TanknMoveDir = tanke_enemy[i].TanknDir();
			//检测碰撞
			if (!tanke_enemy[i].TankJudge())
			{
				//碰到障碍物
				//随机方向
				int Random = rand() % 4;
				//进行移动
				tanke_enemy[i].InPut(Random);
			}
			else
			{
				//没有碰到障碍物
				//继续前进
				tanke_enemy[i].InPut(TanknMoveDir);
			}
			//有一半的几率发射子弹
			if (rand() % 2 == 1 && Bullet.BulletInterval_enemy(i))
			{
				Bullet.BulletFire(tanke_enemy[i].TanknDir(), tanke_enemy[i].TankPosX(), tanke_enemy[i].TankPosY(), 敌方, tanke_enemy[i].TankColor, 有效, tanke_enemy[i].g_stcTank.nATK);
			}
		}
		//坦克死亡重新生成PS:防BUG
		else
		{
			//初始化生成敌方坦克一
			if (i == 0)
			{
				tanke_enemy[0].TankInit(11, 11, 深蓝色, 敌方, 下, 100,25);

				
			}
			//初始化生成敌方坦克二
			else if (i == 1)
			{
				tanke_enemy[1].TankInit(14, 11, 深绿色, 敌方, 下, 100,25);

			}
			//初始化生成敌方坦克三
			else if (true)
			{

				tanke_enemy[2].TankInit(17, 11, 深紫色, 敌方, 下, 100,100);
			}
		}
	}
}

 //玩家坦克初始化
 void C_GameClass::OurInitialize()
 {
	 //玩家一坦克初始化
	 tanke_one.TankInit(25, 52, 浅蓝色, 我方, 上,100,25);

	 //玩家二坦克初始化
	 tanke_two.TankInit(55, 52, 黄色, 我方, 上,100, 25);
 }

 //敌方坦克初始化
 void C_GameClass::EnemyInitialize()
 {
	 //所有敌方初始化
	 tanke_enemy[0].TankInit(11,11, 深蓝色, 敌方, 下, 100, 25);
	 tanke_enemy[1].TankInit(14, 11, 深绿色, 敌方, 下, 100, 25);
	 tanke_enemy[2].TankInit(17, 11, BUF绿色, 敌方, 下, 100, 100);
 }

//所有死亡重置
void C_GameClass::TankDeathReset()
{
	//判断坦克是否死亡
	if (!tanke_one.Survive())
	{
		if (tanke_one.Life > 0)
		{
			TankOverMusic();
			//清除坦克当前位置
			tanke_one.TanksClear();
			tanke_one.Life -= 1;
			if (tanke_one.Life > 0)
			{
				//初始化坦克
				tanke_one.TankInit(25, 52, 浅蓝色, 我方, 上, 100, 25, tanke_one.Life);
				//绘制坦克
				tanke_one.TankDraw();
			}
		}
	}
	if (!tanke_two.Survive())
	{
		if (tanke_two.Life > 0)
		{
			TankOverMusic();
			//清除坦克当前位置
			tanke_two.TanksClear();
			tanke_two.Life -= 1;
			if (tanke_two.Life > 0)
			{
				//初始化坦克
				tanke_two.TankInit(55, 52, 黄色, 我方, 上, 100, 25, tanke_two.Life);
				//绘制坦克
				tanke_two.TankDraw();
			}
		}
	}
	if (!tanke_enemy[0].Survive())
	{
		tanke_enemy[0].TanksClear();
		tanke_enemy[0].TankInit(11, 11, 深蓝色, 敌方, 下, 100,25);
		tanke_enemy[0].TankDraw();
	}
	if (!tanke_enemy[1].Survive())
	{
		tanke_enemy[1].TanksClear();
		tanke_enemy[1].TankInit(14, 11, 深绿色, 敌方, 下, 100,25);
		tanke_enemy[1].TankDraw();
	}
	if (!tanke_enemy[2].Survive())
	{
		tanke_enemy[2].TanksClear();
		tanke_enemy[2].TankInit(17, 11, BUF绿色, 敌方, 下, 100,100);
		tanke_enemy[2].TankDraw();
	}
}

//关卡循环
void C_GameClass::Games_Cycle()
{
	//画地图一
	if (TheMap == 关卡一)
	{
		map.Map_One();
	}
	if (TheMap == 关卡二)
	{
		map.Map_Two();
	}
	//侧栏信息栏目
	MapNote();
	Bullet = { NULL };

	Bullet.nBulletOver = 1;
	//判断是否下一关对需要通关的分数初始化
	if (nSelectWinsInput != 下一关 || nSelectOverInput == 重新开始)
	{
		LevelScore = 0;
		if (nSelectOverInput == 重新开始)
		{
			nSelectOverInput = 0;
			GameScore = 0;
		}
	}
	nSelectGamePaused = 0;
	//需要通关分数
	LevelScore += 10;
	//玩家坦克子弹初始化
	OurInitialize();
	//敌方坦克子弹初始化
	EnemyInitialize();
	//绘制坦克
	tanke_one.TankDraw();
	tanke_two.TankDraw();
	for (int i = 0; i < 3; i++)
	{
		tanke_enemy[i].TankDraw();
	}
	while ((((GameScore != LevelScore) && (tanke_one.Life > 0 || tanke_two.Life > 0))&&(Bullet.nBulletOver != 0))&& nSelectGamePaused != 退出)
	{
		//检测坦克是否移动开炮
		GetOper();
		//子弹移动绘制等
		Bullet.BulletMove(0);
		//坦克死亡重制
		TankDeathReset();
		//检测敌方坦克移动开炮
		AITank();
		//子弹移动绘制等
		Bullet.BulletMove(0);
		
		//分数UI
		GameScoreUI();
		Sleep(10);
	}
	//判断当前分数是否满足关卡通关分数
	if (GameScore == LevelScore)
	{
		while (nSelectWinsInput != 退出)
		{
			system("cls");
			//胜利界面选择控制变量
			nSelectWinsInput = 0;
			//打印胜利界面
			GameWinsUI();
			//胜利界面选择获取鼠标进行菜单选择输入
			WinsSet();
			//清屏
			system("cls");
			//判断是否下一关
			if (nSelectWinsInput == 下一关)
			{
				if (TheMap == 关卡一)
				{
					TheMap = 关卡二;
					Games_Cycle();
					
				}
				if (TheMap == 关卡二)
				{
					TheMap = 关卡一;
					Games_Cycle();
				}
			}
		}
	}
	if (tanke_one.Life <= 0 && tanke_two.Life <= 0 || Bullet.nBulletOver == 0)
	{
		while (nSelectOverInput != 退出)
		{
			system("cls");
			//失败界面选择控制变量
			nSelectOverInput = 0;
			//打印失败界面
			GameOverUI();
			//失败界面选择获取鼠标进行菜单选择输入
			OverSet();
			//清屏
			system("cls");
			//判断是否重新开始
			if (nSelectOverInput == 重新开始)
			{
				Games_Cycle();
			}
		}
	}
}

//欢迎界面
void C_GameClass::Welcome()
{
	WelcomeMusic();
	//边框
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				WriteChar(x, y, "■", 15 | BACKGROUND_INTENSITY);
			}
		}
	}
	WriteChar(11, 20, "                                             ■                                                      ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 21, "                                             ■                          ■     ■                   ■    ■    ■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 22, "    ■        ■■■■■                     ■                          ■     ■                   ■    ■    ■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 23, "    ■        ■      ■               ■■■■■■■              ■    ■     ■                   ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 24, "    ■        ■      ■                     ■                    ■    ■     ■                   ■    ■    ■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 25, "    ■        ■      ■                     ■                    ■    ■     ■                   ■    ■    ■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 26, "    ■        ■■■  ■                 ■■■■■                ■    ■     ■                   ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 27, "  ■■■      ■      ■                 ■      ■            ■■■■■■■■■■■■                  ■  ■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 28, "    ■        ■      ■                 ■      ■                ■    ■     ■                     ■■  ■■           ", rand() % 16 | rand() % 16);
	WriteChar(11, 29, "    ■        ■      ■                 ■■■■■                ■    ■     ■                   ■  ■  ■  ■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 30, "    ■        ■      ■                   ■  ■                  ■    ■     ■                 ■    ■  ■    ■       ", rand() % 16 | rand() % 16);
	WriteChar(11, 31, "    ■        ■■■■■                  ■   ■                  ■    ■■■■■              ■     ■   ■     ■■    ", rand() % 16 | rand() % 16);
	WriteChar(11, 32, "    ■■                                 ■    ■   ■             ■                                  ■    ■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 33, "    ■                                  ■     ■   ■             ■                                 ■     ■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 34, "  ■        ■■■■■■■            ■       ■■■■            ■■■■■■■■■■              ■      ■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 35, "                                    ■                                                                       ■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 36, "                                                                                                             ■             ", rand() % 16 | rand() % 16);
	//WriteChar(85, 20, "■开始游戏", 15);
	
	_getch();
}

//主选择界面
void C_GameClass::SelectInterface()
{
	//边框
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				WriteChar(x, y, "■", 15 | BACKGROUND_INTENSITY);
			}
		}
	}
	WriteChar(36, 24, "开始游戏", rand() % 16 );
			   
	WriteChar(36, 26, "选择关卡", rand() % 16 );
			   
	WriteChar(36, 28, "绘制地图", rand() % 16 );
			   
	WriteChar(36, 30, "读取游戏", rand() % 16 );
			   
	WriteChar(36, 32, "退出游戏", rand() % 16 );
}

//开始游戏
void C_GameClass::StartGame()
{
	//游戏一
	TheMap = 关卡一;
	Games_Cycle();
	

}

//选择关卡
void C_GameClass::SelectLevel ()
{
	//选关卡的变量重置
	nSelectLevelInput = 无效;
	while (nSelectLevelInput != 退出关卡选择)
	{
		
		//清屏
		system("cls");
		//绘制选关卡界面
		LevelSelect();
		//关卡选择获取鼠标进行菜单选择输入
		LevelSet();
		//清屏
		system("cls");
		if (nSelectLevelInput == 关卡一)
		{
			TheMap = 关卡一;
			Games_Cycle();
		}
		if (nSelectLevelInput == 关卡二)
		{
			TheMap = 关卡二;
			Games_Cycle();
		}
	}
	
}

//绘制地图功能
void C_GameClass::DrawMap()
{

	if (nSelectOverInput != 重新开始)
	{
		TheMap = 自定义地图;
		nSelectDrawMap = 0;
		//边框
		for (int y = 0; y < 边界Y; y++)
		{
			//X轴
			for (int x = 0; x < 边界X; x++)
			{
				//判断是否为边界的位置
				if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
				{
					map.Draw(x, y, 铁墙);

				}
			}
		}
		WriteChar(82, 1, " ﹎﹎﹎﹎﹎控制台按键﹎﹎﹎﹎﹎", 黄色);
		WriteChar(82, 2, "┆                             ┆", 黄色);
		WriteChar(82, 3, "┆                             ┆", 黄色);
		WriteChar(82, 4, "┆                             ┆", 黄色);
		WriteChar(82, 5, "┆                             ┆", 黄色);
		WriteChar(82, 6, "┆         铁墙【  】          ┆", 黄色);
		WriteChar(82, 7, "┆                             ┆", 黄色);
		WriteChar(82, 8, "┆                             ┆", 黄色);
		WriteChar(82, 9, "┆                             ┆", 黄色);
		WriteChar(82, 10, "┆         砖墙【  】          ┆", 黄色);
		WriteChar(82, 11, "┆                             ┆", 黄色);
		WriteChar(82, 12, "┆                             ┆", 黄色);
		WriteChar(82, 13, "┆                             ┆", 黄色);
		WriteChar(82, 14, "┆         草地【  】          ┆", 黄色);
		WriteChar(82, 15, "┆                             ┆", 黄色);
		WriteChar(82, 16, "┆                             ┆", 黄色);
		WriteChar(82, 17, "┆                             ┆", 黄色);
		WriteChar(82, 18, "┆         水面【  】          ┆", 黄色);
		WriteChar(82, 19, "┆                             ┆", 黄色);
		WriteChar(82, 20, "┆                             ┆", 黄色);
		WriteChar(82, 21, "┆                             ┆", 黄色);
		WriteChar(82, 22, "┆          家 【  】          ┆", 黄色);
		WriteChar(82, 23, "┆                             ┆", 黄色);
		WriteChar(82, 24, "┆                             ┆", 黄色);
		WriteChar(82, 25, "┆                             ┆", 黄色);
		WriteChar(82, 26, "┆          开始游戏           ┆", 黄色);
		WriteChar(82, 27, "┆                             ┆", 黄色);
		WriteChar(82, 28, "┆                             ┆", 黄色);
		WriteChar(82, 29, "┆                             ┆", 黄色);
		WriteChar(82, 30, "┆            退出             ┆", 黄色);
		WriteChar(82, 31, "┆                             ┆", 黄色);
		WriteChar(82, 32, "┆                             ┆", 黄色);
		WriteChar(82, 33, " ﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊", 黄色);
		WriteChar(90, 6, "■", 亮白色 | BACKGROUND_INTENSITY);
		WriteChar(90, 10, "■", FOREGROUND_RED | FOREGROUND_GREEN | BACKGROUND_INTENSITY);
		WriteChar(90, 14, "屮", BACKGROUND_GREEN | BACKGROUND_INTENSITY);
		WriteChar(90, 18, "≈", BACKGROUND_BLUE | BACKGROUND_INTENSITY);
		WriteChar(90, 22, "★", FOREGROUND_RED | BACKGROUND_INTENSITY);
		CustomMapSet();
	}
	if (nSelectDrawMap != 退出)
	{
		//初始化子弹
		Bullet = { NULL };
		//初始化游戏分数
		GameScore = 0;
		//初始化游戏死亡界面的选择变量
		nSelectOverInput = 0;
		//初始化自定义关卡的分数
		LevelScore = 999999;
		//初始化子弹没有打到家
		Bullet.nBulletOver = 1;
		//初始化绘制地图的选择变量
		nSelectDrawMap = 0;
		//初始化暂停界面的选择
		nSelectGamePaused = 0;
		//打印自定义的地图
		map.DrawMapSver();
		//玩家坦克子弹初始化
		OurInitialize();
		//敌方坦克子弹初始化
		EnemyInitialize();
		//侧栏信息栏目
		MapNote();
		//绘制坦克
		tanke_one.TankDraw();
		tanke_two.TankDraw();
		for (int i = 0; i < 3; i++)
		{
			tanke_enemy[i].TankDraw();
		}
		//绘制子弹
		//for (int nCount = 1; nCount <= Bullet.nBulletNumber; nCount++)
		//{
		//	Bullet.BulletDraw(nCount, Bullet.g_stcBullet[nCount].nDir);
		//}

		while ((((GameScore != LevelScore) && (tanke_one.Life > 0 || tanke_two.Life > 0)) && (Bullet.nBulletOver != 0)) && nSelectGamePaused != 退出)
		{
			//检测坦克是否移动开炮
			GetOper();
			//子弹移动绘制等
			Bullet.BulletMove(0);
			//坦克死亡重制
			TankDeathReset();
			//检测敌方坦克移动开炮
			AITank();
			//子弹移动绘制等
			Bullet.BulletMove(0);

			//分数UI
			GameScoreUI();
			Sleep(10);
		}
		//判断当前分数是否满足关卡通关分数
		if (false)
		{
			while (nSelectWinsInput != 退出)
			{
				system("cls");
				//胜利界面选择控制变量
				nSelectWinsInput = 0;
				//打印胜利界面
				GameWinsUI();
				//胜利界面选择获取鼠标进行菜单选择输入
				WinsSet();
				//清屏
				system("cls");
				//判断是否下一关
				if (nSelectWinsInput == 下一关)
				{
					//Games_Cycle();
				}
			}
		}
		if (tanke_one.Life <= 0 && tanke_two.Life <= 0 || Bullet.nBulletOver == 0)
		{
			while (nSelectOverInput != 退出)
			{
				system("cls");
				//失败界面选择控制变量
				nSelectOverInput = 0;
				//打印失败界面
				GameOverUI();
				//失败界面选择获取鼠标进行菜单选择输入
				OverSet();
				//清屏
				system("cls");
				//判断是否重新开始
				if (nSelectOverInput == 重新开始)
				{
					DrawMap();
				}
			}

		}
	}
}

//读取保存的游戏
void C_GameClass::Game_Out()
{
	//读取保存的地图
	map.Map_Save();
	//侧栏信息栏目
	MapNote();
	nSelectGamePaused = 0;
	//绘制坦克
	tanke_one.TankDraw();
	tanke_two.TankDraw();
	for (int i = 0; i < 3; i++)
	{
		tanke_enemy[i].TankDraw();
	}
	for (int nCount = 1; nCount <= Bullet.nBulletNumber; nCount++)
	{
		Bullet.BulletDraw(nCount, Bullet.g_stcBullet[nCount].nDir);
	}

	while ((((GameScore != LevelScore) && (tanke_one.Life > 0 || tanke_two.Life > 0)) && (Bullet.nBulletOver != 0)) && nSelectGamePaused != 退出)
	{
		//检测坦克是否移动开炮
		GetOper();
		//子弹移动绘制等
		Bullet.BulletMove(0);
		//坦克死亡重制
		TankDeathReset();
		//检测敌方坦克移动开炮
		AITank();
		//子弹移动绘制等
		Bullet.BulletMove(0);

		//分数UI
		GameScoreUI();
		Sleep(10);
	}
	//判断当前分数是否满足关卡通关分数
	if (GameScore == LevelScore)
	{
		while (nSelectWinsInput != 退出)
		{
			system("cls");
			//胜利界面选择控制变量
			nSelectWinsInput = 0;
			//打印胜利界面
			GameWinsUI();
			//胜利界面选择获取鼠标进行菜单选择输入
			WinsSet();
			//清屏
			system("cls");
			//判断是否下一关
			if (nSelectWinsInput == 下一关)
			{
				Games_Cycle();
			}
		}
	}
	if (tanke_one.Life <= 0 && tanke_two.Life <= 0 || Bullet.nBulletOver == 0)
	{
		while (nSelectOverInput != 退出)
		{
			system("cls");
			//失败界面选择控制变量
			nSelectOverInput = 0;
			//打印失败界面
			GameOverUI();
			//失败界面选择获取鼠标进行菜单选择输入
			OverSet();
			//清屏
			system("cls");
			//判断是否重新开始
			if (nSelectOverInput == 重新开始)
			{
				//判断是否是自定义地图
				if (TheMap = 自定义地图)
				{
					DrawMap();
				}
				else
				{
					Games_Cycle();
				}
			}
		}

	}
}

//暂停游戏
void C_GameClass::GamePaused()
{
	GameSave();
	nSelectGamePaused = 0;
	WriteChar(82, 41, " ﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎",   黄色);
	WriteChar(82, 42, "┆                             ┆", 黄色);
	WriteChar(82, 43, "┆                             ┆", 黄色);
	WriteChar(82, 44, "┆          继续游戏           ┆", 黄色);
	WriteChar(82, 45, "┆                             ┆", 黄色);
	WriteChar(82, 46, "┆                             ┆", 黄色);
	WriteChar(82, 47, "┆                             ┆", 黄色);
	WriteChar(82, 48, "┆          退出游戏           ┆", 黄色);
	WriteChar(82, 49, "┆                             ┆", 黄色);
	WriteChar(82, 50, "┆                             ┆", 黄色);
	WriteChar(82, 51, " ﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊",   黄色);
	while (nSelectGamePaused != 退出  && nSelectGamePaused != 继续游戏)
	{
		PausedSet();
	}
	if (nSelectGamePaused == 继续游戏)
	{
		WriteChar(82, 41, " ﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎", 黄色);
		WriteChar(82, 42, "┆                             ┆", 黄色);
		WriteChar(82, 43, "┆                             ┆", 黄色);
		WriteChar(82, 44, "┆                             ┆", 黄色);
		WriteChar(82, 45, "┆                             ┆", 黄色);
		WriteChar(82, 46, "┆                             ┆", 黄色);
		WriteChar(82, 47, "┆                             ┆", 黄色);
		WriteChar(82, 48, "┆                             ┆", 黄色);
		WriteChar(82, 49, "┆                             ┆", 黄色);
		WriteChar(82, 50, "┆                             ┆", 黄色);
		WriteChar(82, 51, " ﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊", 黄色);

		WriteChar(83, 44, " ● 坦克 P 1", 浅蓝色);
		WriteChar(83, 48, " ● 坦克 P 2", 黄色);
	}
}

//关卡选择界面
void C_GameClass::LevelSelect()
{
	//边框
	for (int y = 0; y < 边界Y; y++)
		{
			//X轴
			for (int x = 0; x < 边界X; x++)
			{
				//判断是否为边界的位置
				if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
				{
					WriteChar(x, y, "■", 15 | BACKGROUND_INTENSITY);
				}
			}
		}
	WriteChar(36, 26, "关卡一", rand() % 16);

	WriteChar(36, 28, "关卡二", rand() % 16);

	WriteChar(36, 30, "退出关卡选择", rand() % 16);
	
}

//胜利界面
void C_GameClass::GameWinsUI()
{
	WelcomeMusic();
	//边框
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				WriteChar(x, y, "■", 15 | BACKGROUND_INTENSITY);
			}
		}
	}
	WriteChar(11, 10, "    ■■■■■■                  ■■                      ■               ■             ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 11, "  ■           ■                ■  ■                    ■■             ■■            ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 12, " ■                             ■    ■                  ■  ■           ■  ■           ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 13, "■                             ■      ■                ■    ■         ■    ■          ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 14, "■                            ■        ■              ■      ■       ■      ■         ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 15, "■                           ■■■■■■■            ■        ■     ■        ■        ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 16, "■          ■■■■        ■            ■          ■          ■   ■          ■       ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 17, " ■            ■ ■       ■              ■        ■            ■■             ■      ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 18, "  ■          ■  ■      ■                ■       ■             ■              ■      ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 19, "   ■■■■■■          ■                  ■     ■              ■               ■     ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 20, "                                                                                                                   ", rand() % 16 | rand() % 16);
	WriteChar(11, 21, "       ■           ■           ■         ■■■            ■            ■■            ■■■■■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 22, "       ■           ■           ■           ■              ■           ■ ■          ■         ■            ", rand() % 16 | rand() % 16);
	WriteChar(11, 23, "       ■          ■■          ■           ■              ■         ■   ■         ■                        ", rand() % 16 | rand() % 16);
	WriteChar(11, 24, "        ■        ■  ■        ■            ■              ■       ■     ■          ■                       ", rand() % 16 | rand() % 16);
	WriteChar(11, 25, "         ■      ■    ■      ■             ■              ■      ■      ■            ■■■■               ", rand() % 16 | rand() % 16);
	WriteChar(11, 26, "          ■    ■      ■    ■              ■              ■     ■       ■                    ■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 27, "           ■  ■        ■  ■               ■              ■   ■         ■                     ■            ", rand() % 16 | rand() % 16);
	WriteChar(11, 28, "            ■■          ■■                ■              ■ ■           ■         ■         ■             ", rand() % 16 | rand() % 16);
	WriteChar(11, 29, "             ■            ■               ■■■            ■■            ■          ■■■■■               ", rand() % 16 | rand() % 16);

	WriteChar(30, 40, "下一关", rand() % 16 | rand() % 16);
	WriteChar(45, 40, "退出", rand() % 16 | rand() % 16);
}

//死亡界面
void C_GameClass::GameOverUI()
{
	GameOverMusic();
	//边框
	for (int y = 0; y < 边界Y; y++)
	{
		//X轴
		for (int x = 0; x < 边界X; x++)
		{
			//判断是否为边界的位置
			if (y == 0 || x == 0 || x == 边界X - 1 || y == 边界Y - 1)
			{
				WriteChar(x, y, "■", 15 | BACKGROUND_INTENSITY);
			}
		}
	}
	WriteChar(11, 10, "    ■■■■■■                  ■■                      ■               ■             ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 11, "  ■           ■                ■  ■                    ■■             ■■            ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 12, " ■                             ■    ■                  ■  ■           ■  ■           ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 13, "■                             ■      ■                ■    ■         ■    ■          ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 14, "■                            ■        ■              ■      ■       ■      ■         ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 15, "■                           ■■■■■■■            ■        ■     ■        ■        ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 16, "■          ■■■■        ■            ■          ■          ■   ■          ■       ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 17, " ■            ■ ■       ■              ■        ■            ■■             ■      ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 18, "  ■          ■  ■      ■                ■       ■             ■              ■      ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 19, "   ■■■■■■          ■                  ■     ■              ■               ■     ■■■■■■■         ", rand() % 16 | rand() % 16);
	WriteChar(11, 20, "                                                                                                                   ", rand() % 16 | rand() % 16);
	WriteChar(11, 21, "                   ■■■■■        ■              ■     ■■■■■■■      ■■■■■■                       ", rand() % 16 | rand() % 16);
	WriteChar(11, 22, "                 ■          ■       ■            ■      ■                  ■         ■                      ", rand() % 16 | rand() % 16);
	WriteChar(11, 23, "               ■              ■      ■          ■       ■                  ■           ■                    ", rand() % 16 | rand() % 16);
	WriteChar(11, 24, "               ■              ■       ■        ■        ■                  ■         ■                      ", rand() % 16 | rand() % 16);
	WriteChar(11, 25, "               ■              ■        ■      ■         ■■■■■■■      ■■■■■■                       ", rand() % 16 | rand() % 16);
	WriteChar(11, 26, "               ■              ■         ■    ■          ■                  ■        ■                       ", rand() % 16 | rand() % 16);
	WriteChar(11, 27, "               ■              ■          ■  ■           ■                  ■         ■                      ", rand() % 16 | rand() % 16);
	WriteChar(11, 28, "                 ■          ■             ■■            ■                  ■          ■                     ", rand() % 16 | rand() % 16);
	WriteChar(11, 29, "                   ■■■■■                ■             ■■■■■■■      ■           ■                    ", rand() % 16 | rand() % 16);


	WriteChar(30, 40, "重新开始", rand() % 16 | rand() % 16);
	WriteChar(45, 40, "退出", rand() % 16 | rand() % 16);
}

//绘制地图侧栏的备注信息
void C_GameClass::MapNote()
{
	WriteChar(82,1,  " ﹎﹎﹎﹎﹎控制台按键﹎﹎﹎﹎﹎",   黄色);
	WriteChar(82,2,  "┆                             ┆", 黄色);
	WriteChar(82,3,  "┆                             ┆", 黄色);
	WriteChar(82,4,  "┆    玩家1                    ┆", 黄色);
	WriteChar(82,5,  "┆                             ┆", 黄色);
	WriteChar(82,6,  "┆ 【W】：向上                 ┆", 黄色);
	WriteChar(82,7,  "┆                             ┆", 黄色);
	WriteChar(82,8,  "┆ 【S】：向下                 ┆", 黄色);
	WriteChar(82,9,  "┆                             ┆", 黄色);
	WriteChar(82,10, "┆ 【A】：向左                 ┆", 黄色);
	WriteChar(82,11, "┆                             ┆", 黄色);
	WriteChar(82,12, "┆ 【D】：向右                 ┆", 黄色);
	WriteChar(82,13, "┆                             ┆", 黄色);
	WriteChar(82,14, "┆ 【J】：射击                 ┆", 黄色);
	WriteChar(82,15, "┆                             ┆", 黄色);
	WriteChar(82,16, "┆                             ┆", 黄色);
	WriteChar(82,17, "┆    玩家2                    ┆", 黄色);
	WriteChar(82,18, "┆                             ┆", 黄色);
	WriteChar(82,19, "┆ 【↑】：向上                ┆", 黄色);
	WriteChar(82,20, "┆                             ┆", 黄色);
	WriteChar(82,21, "┆ 【↓】：向下                ┆", 黄色);
	WriteChar(82,22, "┆                             ┆", 黄色);
	WriteChar(82,23, "┆ 【←】：向左                ┆", 黄色);
	WriteChar(82,24, "┆                             ┆", 黄色);
	WriteChar(82,25, "┆ 【→】：向右                ┆", 黄色);
	WriteChar(82,26, "┆                             ┆", 黄色);
	WriteChar(82,27, "┆ 【0】：射击                 ┆", 黄色);
	WriteChar(82,28, "┆                             ┆", 黄色);
	WriteChar(82,29, "┆                             ┆", 黄色);
	WriteChar(82,30, "┆ 【P】：保存游戏并退出       ┆", 黄色);
	WriteChar(82,31, "┆                             ┆", 黄色);
	WriteChar(82,32, "┆                             ┆", 黄色);
	WriteChar(82,33, " ﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊",   黄色);
	WriteChar(82,34, " ﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎",   黄色);
	WriteChar(82,35, "┆                             ┆", 黄色);
	WriteChar(82,36, "┆                             ┆", 黄色);
	WriteChar(82,37, "┆  ☆分 数☆                  ┆", 黄色);
	WriteChar(82,38, "┆                             ┆", 黄色);
	WriteChar(82,39, "┆                             ┆", 黄色);
	WriteChar(82,40, " ﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊",   黄色);
	WriteChar(82,41, " ﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎",   黄色);
	WriteChar(82,42, "┆                             ┆", 黄色);
	WriteChar(82,43, "┆                             ┆", 黄色);
	WriteChar(82,44, "┆                             ┆", 黄色);
	WriteChar(82,45, "┆                             ┆", 黄色);
	WriteChar(82,46, "┆                             ┆", 黄色);
	WriteChar(82,47, "┆                             ┆", 黄色);
	WriteChar(82,48, "┆                             ┆", 黄色);
	WriteChar(82,49, "┆                             ┆", 黄色);
	WriteChar(82,50, "┆                             ┆", 黄色);
	WriteChar(82,51, " ﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊",   黄色);
	
	WriteChar(83, 44, " ● 坦克 P 1", 浅蓝色);
	WriteChar(83, 48, " ● 坦克 P 2", 黄色);

}

//游戏分数的UI
void C_GameClass::GameScoreUI()
{
	//WriteChar(88, 37, "分数：", rand() % 16 | rand() % 16);
	WriteInt(90, 37, GameScore, rand() % 16 | rand() % 16);
}

//保存游戏
void C_GameClass::GameSave()
{
	FILE* pFile = NULL;
	fopen_s(&pFile, "./Save.txt", "w");
	//坦克
	fwrite(&tanke_one, sizeof(C_TanksClass), 1, pFile);			
	fwrite(&tanke_two, sizeof(C_TanksClass), 1, pFile);			
	fwrite(&tanke_enemy[0], sizeof(C_TanksClass), 1, pFile);
	fwrite(&tanke_enemy[1], sizeof(C_TanksClass), 1, pFile);
	fwrite(&tanke_enemy[2], sizeof(C_TanksClass), 1, pFile);

	//子弹
	fwrite(&Bullet, sizeof(C_BulletClass), 1, pFile);

	//游戏分数
	fwrite(&GameScore, sizeof(int), 1, pFile);
	//通关分数
	fwrite(&LevelScore, sizeof(int), 1, pFile);

	//当前地图
	fwrite(&TheMap, sizeof(int), 1, pFile);

	//静态地图
	for (int x = 0; x < 边界Y; x++)
	{
		fwrite(Static_Map[x], sizeof(int), 80, pFile);		//地图内容
	}
	//动态地图
	for (int x = 0; x < 边界Y; x++)
	{
		fwrite(Dynamic_Map[x], sizeof(int), 80, pFile);		//地图内容
	}
	fclose(pFile);
}

//读取游戏
void C_GameClass::GameOut()
{
	FILE* pFile = NULL;
	fopen_s(&pFile, "./Save.txt", "r");
	//坦克
	fread(&tanke_one, sizeof(C_TanksClass), 1, pFile);
	fread(&tanke_two, sizeof(C_TanksClass), 1, pFile);
	fread(&tanke_enemy[0], sizeof(C_TanksClass), 1, pFile);
	fread(&tanke_enemy[1], sizeof(C_TanksClass), 1, pFile);
	fread(&tanke_enemy[2], sizeof(C_TanksClass), 1, pFile);

	//子弹
	fread(&Bullet, sizeof(C_BulletClass), 1, pFile);

	//游戏分数
	fread(&GameScore, sizeof(int), 1, pFile);
	//通关分数
	fread(&LevelScore, sizeof(int), 1, pFile);
	//当前地图
	fread(&TheMap, sizeof(int), 1, pFile);

	//静态地图
	for (int x = 0; x < 边界Y; x++)
	{
		fread(Static_Map[x], sizeof(int), 80, pFile);		//地图内容
	}
	//动态地图
	for (int x = 0; x < 边界Y; x++)
	{
		fread(Dynamic_Map[x], sizeof(int), 80, pFile);		//地图内容
	}
	fclose(pFile);
}



//游戏主函数
void C_GameClass::Games()
{
	//欢迎界面
	Welcome();

	while (nSelectIntInput != 退出游戏)
	{
		//初始化主页面选择
		nSelectIntInput = 0;
		//初始化关卡选择
		TheMap = 0;
		//清屏
		system("cls");
		//打印主选择界面
		SelectInterface();
		//获取鼠标进行菜单选择输入
		SelectInt();
		//对获取输入进行判断
		switch (nSelectIntInput)
		{
			//新游戏------------------------------------------完成
		case 开始游戏:
			system("cls");
			//开始游戏
			StartGame();
			break;
			//选择游戏关卡-----------------------------------完成
		case 选择关卡:
			system("cls");
			//选择关卡
			SelectLevel();
			break;
			//绘制地图---------------------------------------
		case 绘制地图:
			system("cls");
			DrawMap();
			//GameOverUI();
			break;
			//读取游戏---------------------------------------完成
		case 读取游戏:
			system("cls");
			//读取游戏
			GameOut();
			Game_Out();
			break;
		default:
			system("cls");
			break;
		}
	}
}

Tanks

Tanks.h

#pragma once
#include <ctime>
#include <Windows.h>

class C_TanksClass/*:virtual public C_BulletClass*/
{
public:
	//用来存储坦克相关的结构体
	typedef struct _TANKINFO
	{
		//存储坐标
		COORD pos;
		//存储方向
		int nDir;
		//血量
		int nHP = 100;
		//攻击力量
		int nATK = 25;
		//等级
		int nLevel = 2;
		//速度
		int nSpeed;
		//移动过的时间
		int nClock;
		//随机移动步数
		int nOper[10];
		//敌我坦克识别
		int nTanksiDentify = 0;

	}TANKINFO;
	TANKINFO g_stcTank;

	//定义坦克上下左右的形状
	int Tanks[4][3][3] =
	{
		{
			{0,1,0},
			{1,1,1},
			{1,0,1}
		},
		{
			{1,0,1},
			{1,1,1},
			{0,1,0}
		},
		{
			{0,1,1},
			{1,1,0},
			{0,1,1}
		},
		{
			{1,1,0},
			{0,1,1},
			{1,1,0}
		}
	};

	//坦克初始化
	void TankInit(int X, int Y, int Color, int iDentify, int Dir, int Hp, int nATK, int nLife = 3);

	//检测坦克存活
	bool Survive();

	//坦克颜色
	int TankColor = 0;

	//记录坦克移动时间
	clock_t m_TankEnd;
	//控制坦克两次移动间隔是否移动
	bool TankInterval();

	//获取键盘输入控制坦克方向
	void InPut(int Input);

	//绘制坦克
	void TankDraw();

	//清理坦克
	void TanksClear();

	//用于存储从键盘获取的坦克方向
	char cTankInput;

	//用于返回子弹方向的接口
	int TanknDir();

	int nTanknDir = 0;

	//用于返回子弹出现位置的X轴接口
	int TankPosX();

	int nTankPosX = 0;

	//用于返回子弹出现位置的Y轴接口
	int TankPosY();

	int nTankPosY = 0;

	//用于返回键盘接收到的信息
	char cInput();

	//碰撞判定
	bool TankJudge();

	//我方游戏坦克命数
	int Life = 1;
private:

};

Tanks.cpp

#include "Tanks.h"

#include <ctime>

#include "API.h"
#include "Game.h"
#include "Global.h"
#include "Map.h"





//用于存储从键盘获取初始化坦克方向
//char cTankInput = 0;

//坦克初始化（X坐标，Y坐标，颜色，阵营，方向，血量）
void C_TanksClass::TankInit (int X, int Y, int Color, int iDentify, int Dir, int Hp, int nATK, int nLife)
{
	//初始化X坐标
	g_stcTank.pos.X = X;
	//初始化Y坐标
	g_stcTank.pos.Y = Y;
	//初始化颜色
	TankColor = Color;
	//初始化阵营
	g_stcTank.nTanksiDentify = iDentify;
	//初始化方向
	g_stcTank.nDir = Dir;
	//初始化血量
	g_stcTank.nHP = Hp;
	//初始化攻击力
	g_stcTank.nATK = nATK;
	//初始化命数
	Life = nLife;
}

//坦克移动时间间隔判断
bool C_TanksClass::TankInterval()
{
	//控制坦克两次移动间隔是否移动（当前时间 - 曾经移动过的时间 < 80）
	if (clock() - m_TankEnd < 80)
	{
		//不可移动
		return false;
	}
	else
	{
		//可以移动，并将现在时间赋值到曾经移动过的时间
		m_TankEnd = clock();
		return true;
	}
};

//获取键盘输入控制坦克方向（方向）
void C_TanksClass::InPut(int Input)
{
	判断俩子弹发射间隔是否发射
	if (TankInterval())
	{
		//清理坦克（走之前先将当前坐标坦克清理）
		TanksClear();
		//通过接受键盘输入判断坦克方向
		switch (Input)
		{
		case 上:
			//判断之前输入的方向与现在输入的方向是否相同，
			if (g_stcTank.nDir != 上)
			{
				//不相同将方向转为输入的方向
				g_stcTank.nDir = 上;
			}
			else
			{
				//相同，向同方向移动坐标（移动前进行碰撞检测）
				if (TankJudge())
				{
					//如果碰撞则不进行移动
					g_stcTank.pos.Y--;
				}


			}
			break;
		case 下:
			if (g_stcTank.nDir != 下)
			{
				g_stcTank.nDir = 下;

			}
			else
			{
				if (TankJudge())
				{
					g_stcTank.pos.Y++;
				}
			}
			break;
		case 左:
			if (g_stcTank.nDir != 左)
			{
				g_stcTank.nDir = 左;
			}
			else
			{
				if (TankJudge())
				{
					g_stcTank.pos.X--;
				}


			}
			break;
		case 右:
			if (g_stcTank.nDir != 右)
			{
				g_stcTank.nDir = 右;
			}
			else
			{
				if (TankJudge())
				{
					g_stcTank.pos.X++;
				}


			}
			break;
		default:
			break;
		}
		//判断坦克是否死亡
		//PS：因为这里需要移动才会进入到这里所以这里可有可无已在外部实现
		if (Survive())
		{
			//没有死亡绘制坦克
			TankDraw();
		}
		else
		{
			//死亡清除坦克
			TanksClear();
		}
	}
}

//碰撞判定
bool C_TanksClass::TankJudge()
{
	//根据坦克的方向进行判定坦克前面三个点（方向）
	switch (g_stcTank.nDir)
	{
	case 上:
		//如果不是空地不是草地那么不能走
		if (Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X] != 空地 && Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X] != 草地/* && Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X + 1] != 空地 && Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X + 1] != 草地/* && Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X + 1] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X - 1] != 空地 && Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X - 1] != 草地/* && Dynamic_Map[g_stcTank.pos.Y - 2][g_stcTank.pos.X - 1] != 子弹*/)
		{
			return false;
		}
		break;
	case 下:
		if (Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X] != 空地 && Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X] != 草地/* && Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X + 1] != 空地 && Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X + 1] != 草地/* && Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X + 1] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X - 1] != 空地 && Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X - 1] != 草地/* && Dynamic_Map[g_stcTank.pos.Y + 2][g_stcTank.pos.X - 1] != 子弹*/)
		{
			return false;
		}
		break;
	case 左:
		if (Dynamic_Map[g_stcTank.pos.Y][g_stcTank.pos.X - 2] != 空地 && Dynamic_Map[g_stcTank.pos.Y][g_stcTank.pos.X - 2] != 草地/* && Dynamic_Map[g_stcTank.pos.Y][g_stcTank.pos.X - 2] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y + 1][g_stcTank.pos.X - 2] != 空地 && Dynamic_Map[g_stcTank.pos.Y + 1][g_stcTank.pos.X - 2] != 草地 /*&& Dynamic_Map[g_stcTank.pos.Y + 1][g_stcTank.pos.X - 2] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y - 1][g_stcTank.pos.X - 2] != 空地 && Dynamic_Map[g_stcTank.pos.Y - 1][g_stcTank.pos.X - 2] != 草地/* && Dynamic_Map[g_stcTank.pos.Y - 1][g_stcTank.pos.X - 2] != 子弹*/)
		{
			return false;
		}
		break;
	case 右:
		if (Dynamic_Map[g_stcTank.pos.Y][g_stcTank.pos.X + 2] != 空地 && Dynamic_Map[g_stcTank.pos.Y][g_stcTank.pos.X + 2] != 草地 /*&& Dynamic_Map[g_stcTank.pos.Y][g_stcTank.pos.X + 2] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y + 1][g_stcTank.pos.X + 2] != 空地 && Dynamic_Map[g_stcTank.pos.Y + 1][g_stcTank.pos.X + 2] != 草地/* && Dynamic_Map[g_stcTank.pos.Y + 1][g_stcTank.pos.X + 2] != 子弹*/
			|| Dynamic_Map[g_stcTank.pos.Y - 1][g_stcTank.pos.X + 2] != 空地 && Dynamic_Map[g_stcTank.pos.Y - 1][g_stcTank.pos.X + 2] != 草地 /*&& Dynamic_Map[g_stcTank.pos.Y - 1][g_stcTank.pos.X + 2] != 子弹*/)
		{
			return false;
		}
		break;
	default:
		return true;
		break;
	}
}

//绘制坦克
void C_TanksClass::TankDraw()
{
		//通过循环对什么方向的坦克进行绘制
		for (int y = 0; y < 3; y++)
		{
			for (int x = 0; x < 3; x++)
			{
				//根据坦克方向绘制样子
				//g_stcTank.nDir记录方向
				if (Tanks[g_stcTank.nDir][y][x] != 0)
				{
					//静态地图这个位置是不是草地
					//g_stcTank.pos.X和g_stcTank.pos.Y记录中心坐标
					if (Static_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] == 草地)
					{
						//如果是草地直接绘制草地
						WriteChar(g_stcTank.pos.X - 1 + x, g_stcTank.pos.Y - 1 + y, "屮", BACKGROUND_GREEN | BACKGROUND_INTENSITY);
						//将坦克信息放到动态地图上
						Dynamic_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] = 坦克;
					}
					else
					{
						
						//否则绘制坦克
						//PS:其他的所有
						WriteChar(g_stcTank.pos.X - 1 + x, g_stcTank.pos.Y - 1 + y, "□", TankColor);
						//将坦克信息放到动态地图上
						Dynamic_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] = 坦克;
					}
				}
			}
		}
}

//清理坦克
void C_TanksClass::TanksClear()
{
	/*int nDir = g_stcTank.nDir;*/
	//与绘制坦克一样
	for (int y = 0; y < 3; y++)
	{
		for (int x = 0; x < 3; x++)
		{
			//根据坦克方向判断要擦除的位置
			if (Tanks[g_stcTank.nDir][y][x] != 0)
			{
				//判断静态地图这个位置是不是草地
				if (Static_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] == 草地)
				{
					//是草地输出草地到屏幕
					WriteChar(g_stcTank.pos.X - 1 + x, g_stcTank.pos.Y - 1 + y, "屮", BACKGROUND_GREEN | BACKGROUND_INTENSITY);
					//将动态地图设为草地
					Dynamic_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] = Static_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x];
				}
				//判断静态地图这个位置是不是水面
				if (Static_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] == 水面)
				{
					//是水面输出水面到屏幕
					WriteChar(g_stcTank.pos.X - 1 + x, g_stcTank.pos.Y - 1 + y, "≈", BACKGROUND_BLUE | BACKGROUND_INTENSITY);
					//将动态地图设为水面
					Dynamic_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] = Static_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x];
				}
				//判断动态地图这个位置是不是坦克
				if (Dynamic_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] == 坦克)
				{
					// 是坦克输出空地到屏幕
					WriteChar(g_stcTank.pos.X - 1 + x, g_stcTank.pos.Y - 1 + y, "  ", 1);
					//将动态地图设为空地
					Dynamic_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] = 空地;
				}
				//g_stcTank.nTanksrMark = 空地;
				//g_Map[g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x] = maps.nLevelMap[1][g_stcTank.pos.Y - 1 + y][g_stcTank.pos.X - 1 + x];
			}	
		}
	}
}

//检测坦克存活
bool C_TanksClass::Survive ()
{
	//如果血量小于等于100
	if (g_stcTank.nHP <= 0)
	{
		//死亡
		return false;
	}
	else
	{
		//存活
		return true;
	}
}


//用于返回坦克方向的接口
int C_TanksClass::TanknDir()
{
	return g_stcTank.nDir;

}

//用于返回坦克的X轴接口
int C_TanksClass::TankPosX()
{
	return g_stcTank.pos.X;
}
//用于返回坦克的Y轴接口

int C_TanksClass::TankPosY()
{
	return g_stcTank.pos.Y;
}

//用于返回键盘接收到的信息
char C_TanksClass::cInput()
{
	return cTankInput;
}

Bullet

Bullet.h

#pragma once
#include <ctime>
#include <Windows.h>

#include "Global.h"


//子弹类
class C_BulletClass
{
public:
	typedef struct _BULLETINFO
	{
		//存储坐标
		COORD pos;
		//存储方向
		int nDir;
		//血量
		int nHP;
		//攻击力量
		int nATK = 25;
		//等级
		int nLevel = 1;
		//速度
		int nSpeed;
		//移动过的时间
		int nLastClock;

		//子弹颜色
		int nColor;

		//子弹存活标识
		int nBullerExist = 无效;
		
		//阵营敌我坦克识别
		int nCampiDentify = 0;

	}BULLETINFO;
	//子弹结构体 对象【数量】
	BULLETINFO g_stcBullet[100];


	//char cBulletInput = NULL;


	
	//记录子弹数量
	int nBulletNumber = NULL;

	//记录子弹发射时间
	clock_t m_oneBulletEnd;
	clock_t m_twoBulletEnd;
	clock_t m_enemyBulletEnd[3];

	//控制两子弹发射间隔是否发射
	bool BulletInterval_one();
	bool BulletInterval_two();
	bool BulletInterval_enemy(int i);

	//接收发射数据获取坦克坐标发射子弹
	void BulletFire(int nDir, int nPosX, int nPosY, int nCamp, int nColor, int Exist, int nATK);
	//移动子弹
	void BulletMove(int BulletErase);
	//子弹碰撞检测
	void BulletCollide(int nNumber, int nDir);
	//回收失效子弹
	void BulletReclaim();
	//绘制子弹
	void BulletDraw(int nNumber, int nDir);
	//擦除子弹
	void BulletClear(int nNumber);
	
	//检测子弹与坦克扣血
	void Tank_HP_Red(int nNumber, int X, int Y);

	//当所有子弹打到家返回0
	int nBulletOver = 1;

	//子弹失效
	int BulletOver();
	
	//子弹方向的接口
	int BulletPosX();
	int nBulletPosX = 0;
	//子弹方向的接口
	int BulletPosY();
	int nBulletPosY = 0;
};

Bullet.cpp

这里面有很多冗余代码
子弹和坦克的检查没必要写一个switch
只需要一个if判断即可

if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			//子弹置为无效
			g_stcBullet[nNumber].nBullerExist = 无效;
			//对坦克进行扣血
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y);
			//返回调用函数废弃
		}

下面是代码

#include "Bullet.h"
#include <ctime>

#include "API.h"
#include "Game.h"
#include "Global.h"
#include "Tanks.h"

//再声明子弹对象
C_BulletClass Bullet;


//玩家一两子弹发射间隔
bool C_BulletClass::BulletInterval_one()
{
	//控制两子弹发射间隔是否发射（当前时间 - 上次发射的时间 < 400)
	if ( clock()-m_oneBulletEnd < 400)
	{
		//不能发射
		return false;
	}
	else
	{
		//可以发射
		//将当前时间存储到上次发射的时间变量中
		m_oneBulletEnd = clock();
		return true;
	}
};

//玩家二两子弹发射间隔
bool C_BulletClass::BulletInterval_two()
{
	//控制两子弹发射间隔是否发射
	if (clock() - m_twoBulletEnd < 400)
	{
		return false;
	}
	else
	{
		m_twoBulletEnd = clock();
		return true;
	}
};

//人机两子弹发射间隔
bool C_BulletClass::BulletInterval_enemy(int i)
{
	//控制两子弹发射间隔是否发射
	if (clock() - m_enemyBulletEnd[i] < 400)
	{
		return false;
	}
	else
	{
		m_enemyBulletEnd[i] = clock();
		return true;
	}
};
//发射子弹出现子弹，子弹初始化（接收坦克的方向，x轴坐标，y轴坐标，阵营标识，颜色）
void C_BulletClass::BulletFire(int nDir, int nPosX, int nPosY,int nCamp, int nColor ,int Exist,int nATK)
{
	
	//
	//子弹数量自增
	nBulletNumber++;
	//子弹初始速度
	g_stcBullet[nBulletNumber].nSpeed = 60;
	//子弹当前移动时间
	g_stcBullet[nBulletNumber].nLastClock = clock();
	//子弹的方向
	g_stcBullet[nBulletNumber].nDir = nDir;
	//子弹的阵营
	g_stcBullet[nBulletNumber].nCampiDentify = nCamp;
	//子弹的颜色
	g_stcBullet[nBulletNumber].nColor = nColor;
	//子弹是否有效
	g_stcBullet[nBulletNumber].nBullerExist = 有效;
	//子弹威力
	g_stcBullet[nBulletNumber].nATK = nATK;
	//根据方向判断
	switch (nDir)
	{
	case 上:
		//子弹是否存活
		if (g_stcBullet[nBulletNumber].nBullerExist != 0)
		//接收X轴坐标
		g_stcBullet[nBulletNumber].pos.X = nPosX;
		//接收Y轴坐标
		g_stcBullet[nBulletNumber].pos.Y = nPosY - 2;
		//进行子弹碰撞检测
		BulletCollide(nBulletNumber, nDir);
		
		break;
	case 下:
		g_stcBullet[nBulletNumber].pos.X = nPosX;
		g_stcBullet[nBulletNumber].pos.Y = nPosY + 2;
		BulletCollide(nBulletNumber, nDir);
		break;
	case 左:
		g_stcBullet[nBulletNumber].pos.X = nPosX - 2;
		g_stcBullet[nBulletNumber].pos.Y = nPosY;
		BulletCollide(nBulletNumber, nDir);
		break;
	case 右:
		g_stcBullet[nBulletNumber].pos.X = nPosX + 2;
		g_stcBullet[nBulletNumber].pos.Y = nPosY;
		BulletCollide(nBulletNumber, nDir);
		break;
	default:
		break;
	}

}

//子弹移动
void C_BulletClass::BulletMove(int BulletErase)
{
	//对所有子弹进行循环从第一颗开始
	for (int nCount = 1; nCount <= nBulletNumber; nCount++)
	{
		//子弹擦除
		BulletClear(nCount);
		//控制子弹移动速度 当前时间-上次移动的时间 > 速度
		if (clock() - g_stcBullet[nCount].nLastClock > g_stcBullet[nCount].nSpeed)
		{
			//当前子弹接收当前移动的时间信息
			g_stcBullet[nCount].nLastClock = clock();
			//根据当前子弹方向判断
			switch (g_stcBullet[nCount].nDir)
			{
			case 上:
				//当前子弹移动
				g_stcBullet[nCount].pos.Y--;
				break;
			case 下:
				g_stcBullet[nCount].pos.Y++;
				break;
			case 左:
				g_stcBullet[nCount].pos.X--;
				break;
			case 右:
				g_stcBullet[nCount].pos.X++;
				break;
			default:
				break;
			}
		}
		//子弹绘制
		BulletDraw(nCount, g_stcBullet[nCount].nDir);
		//回收失效子弹
		BulletReclaim();
	}
}

//回收失效子弹
void C_BulletClass::BulletReclaim()
{
	//对所有子弹进行循环
	for (int nCount = 1;nCount>0 &&nCount <= nBulletNumber; nCount++)
	{
		//查看当前子弹是否无效
		if (g_stcBullet[nCount].nBullerExist == 无效)
		{
			//将子弹后面所有数组前移
			for (int x = nCount; x <= nBulletNumber; x++)
			{
				g_stcBullet[x] = g_stcBullet[x + 1];
			}
			
			//子弹数量减一
			nBulletNumber--;
			//从当前子弹位置继续
			nCount--;
		}
	}
}

//子弹碰撞检测
void C_BulletClass::BulletCollide(int nNumber, int nDir)
{
	//判断子弹下一个位置是否是砖墙铁墙或者坦克如果是则子弹失效
	if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 砖墙 ||
		Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 铁墙 ||
		Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 坦克)
	{
		//子弹失效jjj
		g_stcBullet[nNumber].nBullerExist = 无效;
	}
	//砖墙检测
	if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 砖墙)
	{
		//绘制空地
		WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "  ", 黑色);
		//将动态地图设为空地
		Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 空地;
		//子弹失效
		g_stcBullet[nNumber].nBullerExist = 无效;
	}
	//与家的检测
	if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 家)
	{
		//绘制空地
		WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "  ", 黑色);
		//将动态地图设为空地
		Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 空地;
		//子弹失效
		g_stcBullet[nNumber].nBullerExist = 无效;
		//当子弹打到家返回0默认1
		nBulletOver = 0;
		//Bullet.nBulletOver = 0;
	}
	//子弹检测
	for (int nCount = 0; nCount < 100; ++nCount)
	{
		//对所有子弹进行循环，对当前子弹进行判断不等于当前子弹，
		if (nNumber != nCount)
		{
			//判断子弹的XY轴是否相等
			if (g_stcBullet[nNumber].pos.X == g_stcBullet[nCount].pos.X &&
				g_stcBullet[nNumber].pos.Y == g_stcBullet[nCount].pos.Y)
			{
				//置为无效
				g_stcBullet[nNumber].nBullerExist = 无效;
				//如果静态地图当前位置是砖墙或者空地，
				//PS:因为子弹走过的路动态图上都是子弹或者空地
				if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 砖墙 ||
					Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 空地)
				{
					//绘制空地
					WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "  ", 黑色);
					//输出到动态图上
					Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 空地;
				}
				//判断静态图上是否是水面
				if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 水面)
				{
					//绘制水面
					WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "≈", BACKGROUND_BLUE | BACKGROUND_INTENSITY);
					//将动态图设为水面
					Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X];
				}
				//判断静态图上是否是草地
				if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 草地)
				{
					//绘制草地
					WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "屮", BACKGROUND_GREEN | BACKGROUND_INTENSITY);
					//将动态图设为草地
					Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X];
				}
				else
				{
					//防止bug
					Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] =Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X];
				}
				//将子弹置为无效
				g_stcBullet[nCount].nBullerExist = 无效;

				//BulletClear(i);
			}
		}
			
	}

	//坦克检测（方向）
	switch (nDir)
	{
	case 上:
		//动态图的当前位置是否是坦克
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			//子弹置为无效
			g_stcBullet[nNumber].nBullerExist = 无效;
			//对坦克进行扣血
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y);
			
			//返回调用函数废弃
			
		}/*else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X - 1] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X - 1, g_stcBullet[nNumber].pos.Y);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X + 1] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X + 1, g_stcBullet[nNumber].pos.Y);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}*/
		break;
	case 下:
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y);
		}/*else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X - 1] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X - 1, g_stcBullet[nNumber].pos.Y);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X + 1] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X + 1, g_stcBullet[nNumber].pos.Y);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}*/
		break;
	case 左:
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y);
		}/*else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y - 1][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y - 1);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y + 1][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y + 1);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}*/
		break;
	case 右:
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y);
		}/*else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y - 1][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y - 1);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}else
		if (Dynamic_Map[g_stcBullet[nNumber].pos.Y + 1][g_stcBullet[nNumber].pos.X] == 坦克)
		{
			g_stcBullet[nNumber].nBullerExist = 无效;
			Tank_HP_Red(nNumber, g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y + 1);
			nBulletLapse = g_stcBullet[nNumber].nBullerExist;
			nBulletPosX = g_stcBullet[nNumber].pos.X;
			nBulletPosX = g_stcBullet[nNumber].pos.Y;
		}*/
		break;
	default:
		break;
	}
	
	//if (nBulletLapse == 无效)
	//{
	//	if (Dynamic_Map[nBulletPosY][nBulletPosX] == 子弹)
	//	{
	//		nBulletLapse = g_stcBullet[nNumber].nBullerExist = 0;
	//		nBulletPosX = g_stcBullet[nNumber].pos.X;
	//		nBulletPosX = g_stcBullet[nNumber].pos.Y;
	//		WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "  ", 黑色);
	//		Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 空地;
	//	}
	//}
}
//绘制子弹
void C_BulletClass::BulletDraw(int nNumber,int nDir)
{
	//判断子弹是否有效
	BulletCollide(nNumber, nDir);
	//检测子弹失效
	if (g_stcBullet[nNumber].nBullerExist == 有效)
	{
		//判断子弹要绘制的位置是否是草地
		if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 草地)
		{
			//绘制草地
			WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "屮", BACKGROUND_GREEN | BACKGROUND_INTENSITY);
			//动态图设为子弹
			Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 子弹;
		}
		//判断子弹要绘制的位置是否是水面
		else if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 水面)
		{
			//设为水面
			WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "●", g_stcBullet[nNumber].nColor);
			//动态图设为子弹
			Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 子弹;
		}
		//如果不是草地或者水面正常打印子弹
		else
		{
			//绘制子弹
			WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "●", g_stcBullet[nNumber].nColor);
			//动态图设为子弹
			Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 子弹;
		}
	}
	//g_stcBullet[x].nBullerMark = 子弹;
}

//擦除子弹
void C_BulletClass::BulletClear(int nNumber)
{
	//判断子弹是否有效
	//BulletCollide(x);
	//检测子弹是否失效
	if (g_stcBullet[nNumber].nBullerExist == 有效)
	{
		//判断准备擦除的位置是否原本是草地是则将位置擦除为草地
		if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 草地)
		{
			//绘制草地
			WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "屮", BACKGROUND_GREEN | BACKGROUND_INTENSITY);
			//动态图设为草地
			Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X];
			return;
		}
		//判断准备擦除的位置是否原本是水面是则将位置擦除为水面
		else if (Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 水面)
		{
			//绘制水面
			WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "≈", BACKGROUND_BLUE | BACKGROUND_INTENSITY);
			//动态图设为水面
			Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = Static_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X];
			return;
		}
		//准备擦除的位置原本是空地则擦除为空地
		else if (Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] == 子弹)
		{
			//绘制空地
			WriteChar(g_stcBullet[nNumber].pos.X, g_stcBullet[nNumber].pos.Y, "  ", 黑色);
			//动态图设为空地
			Dynamic_Map[g_stcBullet[nNumber].pos.Y][g_stcBullet[nNumber].pos.X] = 空地;
			return;
		}
		
	}


}

//判断坦克进行扣血
void C_BulletClass::Tank_HP_Red (int nNumber,int X, int Y)
{
	//玩家一
	//Y轴和X轴小于范围内
	if (Y <= tanke_one.g_stcTank.pos.Y + 2 && Y >= tanke_one.g_stcTank.pos.Y - 2 &&
		X <= tanke_one.g_stcTank.pos.X + 2 && X >= tanke_one.g_stcTank.pos.X - 2)
	{
		//判断是不是同一阵营
		if (g_stcBullet[nNumber].nCampiDentify != tanke_one.g_stcTank.nTanksiDentify)
		{
			//对坦克进行扣血
			tanke_one.g_stcTank.nHP -= g_stcBullet[nNumber].nATK;
			return;
		}
		
	}
	//玩家二
	if (Y <= tanke_two.g_stcTank.pos.Y + 2 && Y >= tanke_two.g_stcTank.pos.Y - 2 && 
		X <= tanke_two.g_stcTank.pos.X + 2 && X >= tanke_two.g_stcTank.pos.X - 2)
	{
		if (g_stcBullet[nNumber].nCampiDentify != tanke_two.g_stcTank.nTanksiDentify)
		{
			tanke_two.g_stcTank.nHP -= g_stcBullet[nNumber].nATK;
			
			return;
		}
	}
	//敌方所有坦克
	for (int i = 0; i < 3; i++)
	{
		if (Y <= tanke_enemy[i].g_stcTank.pos.Y + 2 && Y >= tanke_enemy[i].g_stcTank.pos.Y - 2 &&
			X <= tanke_enemy[i].g_stcTank.pos.X + 2 && X >= tanke_enemy[i].g_stcTank.pos.X - 2)
		{
			if (g_stcBullet[nNumber].nCampiDentify != tanke_enemy[i].g_stcTank.nTanksiDentify)
			{
				tanke_enemy[i].g_stcTank.nHP -= g_stcBullet[nNumber].nATK;
				//当敌方坦克扣血加分
				GameScore++;
				return;
			}
		}
	}
}

//子弹失效
int C_BulletClass::BulletOver()
{
	return nBulletOver;
}
//返回子弹X轴
int C_BulletClass::BulletPosX()
{
	return nBulletPosX;
}
//返回子弹Y轴
int C_BulletClass::BulletPosY()
{
	return nBulletPosY;
}
庞沐
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++坦克大战源代码
hdminn的博客
04-25 235
if(map[bullet[i].y] [bullet[i].x]==0 || map[bullet[i].y] [bullet[i].x]==5) //如果子弹坐标当前位置无障碍。该坦克为绿色,表明没有受到伤害。
CC++游戏项目完整教程：《坦克大战》
m0_67394360的博客
06-02 1500
接下来是初始化的函数waiyuan.cpp 再然后是效果函数xiaoguo.cpp 之后是关于子弹的函数zidan.cpp 接下来是我们子弹暴炸时的函数boom.cpp 最后就是我们运行的主函数了main.cpp 这样一个《坦克大战》就完成了。快去自己动手尝试一下叭！！！ 代码很长，希望看完了的同学可以获得自己想要的知识，也感谢大家的耐心观看，在这里想得到大家一波关注，后续UP主还会发布更多的项目源码以及学习资料，有什么问题可以回帖留言，我尽量回答。想要C/C++学习资料以及其他项目的源码的可以加
C++大作业坦克大战源码.zip
06-05
C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码。C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码C++大作业坦克大战源码
C++坦克大战源代码
强国豪,林中霖
08-16 1362
【代码】C++坦克大战源代码。
C++做坦克大作战
最新发布
songci2013的博客
04-15 104
【代码】C++做坦克大作战。
经典坦克大战——C++实现（附源码）
热门推荐
蛟~
04-03 1万+
这是效果截图： 部分源码： //坦克 class Tank{ public: int x, y; //中心坐标 int Direction; //方向 int Model; //模型 int Revival; //复活次数 int Num; //敌方坦克编号 bool Type; //我方坦克此参数为1 bool Exist; //存活为1，不存活为0 }AI_tank[6], my_tank; //子弹 class Bullet{
C++小游戏---坦克大战(二)（加入传送门）--附完整代码
weixin_60360239的博客
10-03 3937
上一篇坦克大战居然意外获得了一些关注，正好最近也完善了一些功能，同时也加入了一些自己想到的新元素，主要是关于穿越草地，加入传送门以及关卡模式的一些开发，所以就再发一篇补充来做个完结。
坦克大战C++源代码，可以直接用Funcode打开比编辑
07-28
【坦克大战C++源代码分析】 本项目是一个基于C++编程语言实现的坦克大战游戏，旨在帮助学生在程序设计实训中提升对C++语言的理解和应用能力，同时体验Funcode编辑器的便捷性。游戏的核心是模拟战斗场景，玩家通过...
坦克大战C++源代码
10-08
《坦克大战》是一款深受玩家喜爱的经典游戏，而其C++源代码对于想要学习游戏编程的初学者来说，无疑是一份宝贵的资源。通过分析和理解这份源代码，我们可以深入学习C++编程语言，以及掌握游戏开发的基本流程和技术。...
坦克大战——C++游戏代码
04-01
功能方面，游戏参考于80年代任天堂红白机(FC/FamilyComputer)上的游戏坦克大战(Battle City)，包括地图，游戏模式等等(当时的游戏直接烧在电路板上)。所以游戏平衡方面已经有了很好的参考，无需再花大量时间测试平衡...
TANKWAR2-:坦克大战C++版本
04-14
"坦克大战C++版本"是一个基于C++编程语言开发的经典游戏项目，旨在让玩家重温儿时的坦克战斗乐趣。在这个项目中，开发者运用了C++的强大功能和面向对象编程思想，构建了一个交互性强、可玩性高的游戏环境。下面将...
基于C++语言开发的坦克大战游戏源代码(含exe可执行文件)
09-22
基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C++语言开发的坦克大战游戏源代码(含exe可执行文件) 基于C+
C语言坦克大战源代码
04-08
这是一个可以运行的程序代码，是两方的坦克对雷作战的，地图精美，是我学完c语言后写的，给大家玩玩吧！
坦克大战游戏c++语言源代码
02-19
坦克大战源代码，用c++语言编写，模块清晰，代码质量高，代码量大，是学习c++语言的好材料
c++程序设计--坦克大战
07-20
本文档详细介绍了在funcode平台下坦克大战的编写过程，读者可根据此文档实现简单的坦克大战游戏
纯C++坦克大战代码
04-28
这是一个用C++编写的坦克大战代码，适合刚学完C++的学。
c++编写坦克大战（同年回忆）全网最全的讲解
m0_72703340的博客
08-03 535
需要熟练的掌握c语言，c++。熟练掌握各种数据类型和数据结构。拥有优秀的文档阅读能力（设计EasyX图形库的使用），拥有一个漂亮温柔的女朋友。
c++坦克大战
penghui_的博客
09-04 1711
#include <graphics.h> #include <conio.h> #include <Windows.h> #include <time.h>#include <stdio.h> #pragma comment (lib, “Winmm.lib”) //导入声音库 //#define KEY_DOWN(vk_code)(G...
tanks and temples 离线评估方法
01-03
"Tanks and Temples" 是一种离线评估方法，旨在评估摄像头和深度传感器等设备的性能，该方法可以用于各种应用领域，如自动驾驶汽车和增强现实技术。 在这种评估方法中，被评估的设备会被置于一个类似战车和寺庙的场景中，这个场景包含了各种挑战，比如光线变化、复杂的几何结构和动态物体。评估者可以通过记录设备在这个场景中的表现来评估它们的性能。 Tanks and Temples 方法的优势在于它可以提供更真实、更复杂的场景，从而更全面地评估设备的性能。通过在真实世界中模拟各种情况，评估者可以更好地了解设备在不同场景下的表现，并对其进行有效的优化。 与在线评估方法相比，Tanks and Temples 方法需要更多的实地操作和数据收集，但所得到的评估结果更加准确和可靠。这种离线评估方法可以帮助研究人员和工程师更好地改进他们的设备，并为未来的应用提供更加可靠的技术支持。 总的来说，Tanks and Temples 是一种非常有价值的离线评估方法，它可以为各种设备的性能评估提供更加真实和全面的数据，为技术的进步和应用的发展提供重要的支持。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值