管理模式+配置表（游戏管理、数据管理）：代码篇

最新推荐文章于 2024-02-04 12:40:48 发布
最新推荐文章于 2024-02-04 12:40:48 发布
阅读量919 收藏 1
点赞数
分类专栏： 其他重要知识点 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40968046/article/details/115128219
版权

stdafx.h（存放全局性的定义）

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <windows.h>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

#define KEY_DOWN(vk_code) (GetAsyncKeyState(vk_code)&0x8000?1:0)

enum  //枚举控制页面切换
{
	E_GAME_MENU,
	E_GAME_MAP,
	E_GAME_ROLESELECT
};

主函数：plane.cpp（程序入口）

// Plane.cpp : 定义控制台应用程序的入口点。
// 主函数的地方

#include "stdafx.h"
#include "GameMgr.h"
#include "ConfigMgr.h"
#include "time.h"

//数据管理者对象，数据一定要放在最前面
SConfigMgr g_ConfigMgr;
SGameMgr g_GameMgr;


int _tmain(int argc, _TCHAR* argv[])
{
	//游戏管理者初始化
	g_GameMgr.init();
	srand(time(nullptr));

	//刷新
	while (true)
	{
		//数据更新、渲染
		g_GameMgr.update();
		g_GameMgr.onRender();
		system("cls");
	}

	return 0;
}

DataStruct.h（配置表数据的声明）

#pragma once

//定义一个结构体设置四个节点的行列值（注意）
struct SVec2
{
	void set(int nInRow, int nInCol){
		nRow = nInRow;
		nCol = nInCol;
	}
	int nRow;
	int nCol;
	int nRowBk;
	int nColBk;
};

//定义地图数据的结构体
struct SLevelDt
{
	SLevelDt()
	{
		nID = 0;
		nMaxRow = 0;
		nMaxCol = 0;
		nBirthRow = 0;
		nBirthCol = 0;
	}
	int nID;
	string strName;
	int nMaxRow;
	int nMaxCol;
	int nBirthRow;
	int nBirthCol;
	int arrMap[20][15];
};

struct SLevelDtMgr
{
	//加载数据
	void LoadFile(string strPath);
	//通过id获取数据  传入id,返回一个结构体数据
	SLevelDt getDataById(int nId);
	//容器
	vector<SLevelDt> vecLevelDt;

	int getSize();
};

struct SRoleDt
{
	SRoleDt()
	{
		nId = 0;
	}
	int nId;
	int nAck;
	int nHp;
	int nMp;
	int nInterval;
	int nBulletId;
	string strName;
	string strPic;
};

struct SRoleDtMgr
{
	void LoadFile(string strPath);
	SRoleDt getDataById(int nId);
	vector<SRoleDt> vecRoleData;
	int getSize();
};

struct SBulletDt
{
	int nBulletId;
	int nBulletAck;
	string strBulletName;
	string strBulletPic;
};

struct SBulletDtMgr
{
	void LoadFile(string strPath);
	SBulletDt getDataById(int nId);
	vector<SBulletDt> vecBulletDt;
	int getSize();

};

struct SEnemyDt
{
	SEnemyDt()
	{
		nEnemyId = 0;
		nEnemyAck = 0;
		nEnemyHp = 0;
		nEnemyDef = 0;
		nBuletId = 0;
		nAckTime = 0;
		nMoveTime = 0;
	}
	int nEnemyId;
	int nEnemyAck;
	int nEnemyHp;
	int nEnemyDef;
	int nBuletId;
	int nAckTime;
	int nMoveTime;
	string strEnemyName;
	string strEnemyPic;
};

struct SEnemyDtMgr
{
	void LoadFile(string strPath);
	SEnemyDt getDataById(int nId);
	vector<SEnemyDt> vecEnemyDt;
	int getSize();
};

DataStruct.cpp（配置表数据的实现：获取配置表数据的过程）

#include "stdafx.h"
#include "DataStruct.h"

void SLevelDtMgr::LoadFile(string strPath)
{
	ifstream infile(strPath);
	int nCount = 0;
	infile >> nCount;

	for (int m = 0; m < nCount; m++)  //第一关、第二关...
	{
		SLevelDt data;
		infile >> data.strName >> data.nID >> data.nMaxRow >> data.nMaxCol >> data.nBirthRow >> data.nBirthCol;

		for (int i = 0; i < data.nMaxRow; i++)
		{
			for (int j = 0; j < data.nMaxCol; j++)
			{
				infile >> data.arrMap[i][j];
			}
		}
		vecLevelDt.push_back(data);  
	}
}

SLevelDt SLevelDtMgr::getDataById(int nId)
{
	for (int i = 0; i < vecLevelDt.size();i++)
	{
		if (vecLevelDt[i].nID = nId)
		{
			return vecLevelDt[i];
		}
	}
	SLevelDt data;
	return data;
}

int SLevelDtMgr::getSize()
{
	return vecLevelDt.size();
}

void SRoleDtMgr::LoadFile(string strPath)
{
	fstream infile(strPath);
	if (infile)
	{
		int nCount = 0;  
		infile >> nCount;  

		for (int i = 0; i < nCount; i++)
		{
			//定义一个临时结构体变量，存每一行的数据
			SRoleDt roleData;
			infile >> roleData.nId >> roleData.nAck >> roleData.nHp >> roleData.nMp 
				>> roleData.nInterval >> roleData.nBulletId >> roleData.strName >> roleData.strPic;

			vecRoleData.push_back(roleData);
		}
	}
	infile.close();
}

SRoleDt SRoleDtMgr::getDataById(int nId)
{
	for (int i = 0; i < vecRoleData.size(); i++)
	{
		if (vecRoleData[i].nId == nId)
		{
			return vecRoleData[i];
		}
	}
	SRoleDt data;
	return data;
}

int SRoleDtMgr::getSize()
{
	return vecRoleData.size();
}

void SBulletDtMgr::LoadFile(string strPath)
{
	ifstream infile(strPath);
	if (infile)
	{
		int nCount = 0;
		infile >> nCount;

		for (int i = 0; i < nCount; i++)
		{
			SBulletDt data;
			infile >> data.nBulletId >> data.nBulletAck >> data.strBulletName >> data.strBulletPic;
			vecBulletDt.push_back(data); //一次压入一行数据
		}
	}
	infile.close();
}

SBulletDt SBulletDtMgr::getDataById(int nId)
{
	for (int i = 0; i < vecBulletDt.size(); i++)
	{
		if (vecBulletDt[i].nBulletId == nId)
		{
			return vecBulletDt[i];
		}
	}
	SBulletDt data;
	return data;
}

int SBulletDtMgr::getSize()
{
	return vecBulletDt.size();
}


void SEnemyDtMgr::LoadFile(string strPath)
{
	ifstream infile(strPath);

	if (infile)
	{
		string str;
		getline(infile, str);

		int nCount = 0;
		infile >> nCount;

		for (int i = 0; i < nCount; i++)
		{
			SEnemyDt data;
			infile >> data.nEnemyId >> data.nEnemyAck >> data.nEnemyHp>> data.nEnemyDef >> data.nBuletId 
				>> data.nAckTime >> data.nMoveTime >> data.strEnemyName >> data.strEnemyPic;
			vecEnemyDt.push_back(data);
		}
	}
	infile.close();
}

SEnemyDt SEnemyDtMgr::getDataById(int nId)
{
	for (int i = 0; i < vecEnemyDt.size(); i++)
	{
		if (vecEnemyDt[i].nEnemyId == nId)
		{
			return vecEnemyDt[i];
		}
	}
	SEnemyDt data;
	return data;
}

int SEnemyDtMgr::getSize()
{
	return vecEnemyDt.size();
}

ConfigMgr.h（数据管理者）

#pragma once
#include "DataStruct.h"

struct SConfigMgr
{
	SConfigMgr();

	SLevelDtMgr levelDtMgr;
	SRoleDtMgr roleDtMgr;
	SBulletDtMgr bulletDtMgr;
	SEnemyDtMgr enemyDtMgr;

};

extern SConfigMgr g_ConfigMgr; //全局变量

ConfigMgr.cpp

#include "stdafx.h"
#include "ConfigMgr.h"

SConfigMgr::SConfigMgr()
{
	levelDtMgr.LoadFile("Configs/LevelDt.txt");
	roleDtMgr.LoadFile("Configs/RoleDt.txt");
	bulletDtMgr.LoadFile("Configs/BulletDt.txt");
	enemyDtMgr.LoadFile("Configs/EnemyDt.txt");
}

GameMgr.h（游戏管理者）

#pragma once
#include "Menu.h"
#include "GameMap.h"
#include "RoleSelect.h"

struct SGameMgr
{
	SGameMgr();

	//声明游戏管理者需要的函数
	void init();
	void update();
	void onRender();

	//切换界面
	int nState;

	SMenu menu;
	SGameMap gameMap;
	SRoleSelect roleSelect;
};

extern SGameMgr g_GameMgr;

GameMgr.cpp

#include "stdafx.h"
#include "GameMgr.h"

SGameMgr::SGameMgr()
{
}

void SGameMgr::init(){
	nState = E_GAME_MENU;
}


void SGameMgr::update()
{
	if (E_GAME_MENU == nState)
	{
		menu.update();
	}
	else if (E_GAME_MAP == nState)
	{
		gameMap.update();
	}
	else if (E_GAME_ROLESELECT == nState)
	{
		roleSelect.update();
	}
}


void SGameMgr::onRender()
{
	if (E_GAME_MENU == nState)
	{
		menu.onRender();
	}
	else if (E_GAME_MAP == nState)
	{
		gameMap.onRender();
	}
	else if (E_GAME_ROLESELECT == nState)
	{
		roleSelect.onRender();
	}
}

Menu.h（菜单界面）

#pragma once
#include "DataStruct.h"
struct SMenu
{
	SMenu();
	void update();
	void onRender();

	//菜单箭头
	int nMenuState;
	//设置默认角色
	SRoleDt curRoleDt;
};

Menu.cpp

#include "stdafx.h"
#include "Menu.h"
#include "GameMgr.h"
#include "ConfigMgr.h"

extern SGameMgr g_GameMgr;

enum
{
	E_MENU_START,
	E_MENU_ROLESELECT,
	E_MENU_SETTING,
	E_MENU_EXIT
};

SMenu::SMenu()
{
}

void SMenu::update()
{
	if (KEY_DOWN(VK_UP))
	{
		nMenuState--;
		if (nMenuState < E_MENU_START)
		{
			nMenuState = E_MENU_EXIT;
		}
		
	}
	else if (KEY_DOWN(VK_DOWN))
	{
		nMenuState++;
		if (nMenuState > E_MENU_EXIT)
		{
			nMenuState = E_MENU_START;
		}
	}
	else if (KEY_DOWN(VK_RETURN))
	{
		if (E_MENU_START == nMenuState)
		{
			g_GameMgr.nState = E_GAME_MAP;

			//设置默认角色为2001 200 300 100 5 3001 战士 战
			curRoleDt = g_ConfigMgr.roleDtMgr.getDataById(2001);
			//初始化结构体数据
			g_GameMgr.gameMap.sPlayer.init(curRoleDt);
		}
		else if (E_MENU_ROLESELECT == nMenuState)
		{
			g_GameMgr.nState = E_GAME_ROLESELECT;
		}
	}
}

void SMenu::onRender()
{
	cout << "■■■■■■■■■■■■■■■■■■■■" << endl;
	cout << "■■■■■■■■■■■■■■■■■■■■" << endl;
	if (E_MENU_START == nMenuState)
	{
		cout << "■■■        ->游戏开始          ■■■" << endl;
		cout << "■■■          角色选择          ■■■" << endl;
		cout << "■■■          游戏设置          ■■■" << endl;
		cout << "■■■          游戏退出          ■■■" << endl;
	}
	else if (E_MENU_ROLESELECT == nMenuState)
	{
		cout << "■■■          游戏开始          ■■■" << endl;
		cout << "■■■        ->角色选择          ■■■" << endl;
		cout << "■■■          游戏设置          ■■■" << endl;
		cout << "■■■          游戏退出          ■■■" << endl;
	}
	else if (E_MENU_SETTING == nMenuState)
	{
		cout << "■■■          游戏开始          ■■■" << endl;
		cout << "■■■          角色选择          ■■■" << endl;
		cout << "■■■        ->游戏设置          ■■■" << endl;
		cout << "■■■          游戏退出          ■■■" << endl;
	}
	else{
		cout << "■■■          游戏开始          ■■■" << endl;
		cout << "■■■          角色选择          ■■■" << endl;
		cout << "■■■          游戏设置          ■■■" << endl;
		cout << "■■■        ->游戏退出          ■■■" << endl;
	}
	cout << "■■■■■■■■■■■■■■■■■■■■" << endl;
	cout << "■■■■■■■■■■■■■■■■■■■■" << endl;
}

GameMap.h（地图界面）

#pragma once
#include "Player.h"
#include "BulletMgr.h"
#include "EnemyMgr.h"
struct SGameMap
{
	SGameMap();

	void touchWall(); //玩家碰墙函数
	void hitEnemy();  //子弹打中敌人
	void hitPlayer();
	void collicPlayer();  //敌机碰撞玩家

	void update();
	void onRender();

	SLevelDt curLevelDt;  //设置初始关卡

	SPlayer sPlayer;
	SBulletMgr sBulletMgr;
	SEnemyMgr sEnemyMgr;
};

GameMap.cpp

#include "stdafx.h"
#include "GameMgr.h"
#include "DataStruct.h"
#include "ConfigMgr.h"

SGameMap::SGameMap()
{
	//默认初始关卡为1001
	curLevelDt = g_ConfigMgr.levelDtMgr.getDataById(1001);
	//玩家默认初始位置
	sPlayer.setPosition(curLevelDt.nBirthRow, curLevelDt.nBirthCol);
}


//撞墙
void SGameMap::touchWall()
{
	for (int i = 0; i < 4; i++)
	{
		if (1 == curLevelDt.arrMap[sPlayer.arrPos[i].nRow][sPlayer.arrPos[i].nCol])  //注意层级
		{
			sPlayer.revert();		
		}
	}
}


void SGameMap::hitEnemy()
{
	//for (int k = 0; k < sBulletMgr.vecBullet.size(); k++)  //子弹层
	//{
	//	for (int i = 0; i < sEnemyMgr.vecEnemy.size(); i++) //敌机层
	//	{
	//		//判断子弹是否被移除
	//		bool bRemove = false;
	//		for (int j = 0; j < 4; j++) //节点层
	//		{
	//			int nEnemyRow = g_GameMgr.gameMap.sEnemyMgr.vecEnemy[i].arrPos[j].nRow;
	//			int nEnemyCol = g_GameMgr.gameMap.sEnemyMgr.vecEnemy[i].arrPos[j].nCol;

	//			//要记得对子弹进行判定，如果子弹是玩家的，打到敌人敌人才会消失
	//			if (sBulletMgr.vecBullet[k].isPlayer && sBulletMgr.vecBullet[k].nBulletRow == nEnemyRow && sBulletMgr.vecBullet[k].nBulletCol == nEnemyCol)
	//			{
	//				sBulletMgr.vecBullet.erase(sBulletMgr.vecBullet.begin() + k);
	//				sEnemyMgr.vecEnemy.erase(sEnemyMgr.vecEnemy.begin() + i);
	//				bRemove = true;
	//				break;
	//			}
	//		}
	//		if (bRemove)
	//		{
	//			break; 
	//		}
	//	}
	//}

	for (int i = sBulletMgr.vecBullet.size() - 1; i >= 0; i--)  //子弹层
	{
		for (int j = 0; j < sEnemyMgr.vecEnemy.size(); j++) //敌机层
		{
			//判断子弹的行列处是否存在敌机，若存在，返回敌机对象
			SEnemy enemy = sEnemyMgr.isEnemyExist(sBulletMgr.vecBullet[i].nBulletRow, sBulletMgr.vecBullet[i].nBulletCol);

			//如果敌机存在 且 子弹是玩家的
			if (enemy.nEnemyId >= 4001 && sBulletMgr.vecBullet[i].isPlayer)
			{
				//注意：这边不能拿enemy进行扣血处理(因为该enemy只是enemyMgr.VecData[j]的副本)
				//enemy.nEnemyHp -= sBulletMgr.vecBullet[i].nBulletAck;

				//将当前的第j个敌机进行扣血处理，血量= 血量 - 子弹攻击力
				sEnemyMgr.vecEnemy[j].nEnemyHp -= sBulletMgr.vecBullet[i].nBulletAck;
				if (sEnemyMgr.vecEnemy[j].nEnemyHp <= 0)  //血量为0
				{
					sEnemyMgr.vecEnemy.erase(sEnemyMgr.vecEnemy.begin() + j); //移除敌机
				}
				//移除子弹
				sBulletMgr.vecBullet.erase(sBulletMgr.vecBullet.begin() + i);
				break;
			}
		}
	}


}


void SGameMap::hitPlayer()
{
	for (int i = sBulletMgr.vecBullet.size() - 1; i >= 0; i--)
	{
		for (int j = 0; j < 4; j++)
		{
			int nBulletRow = sBulletMgr.vecBullet[i].nBulletRow; //子弹的行
			int nBulletCol = sBulletMgr.vecBullet[i].nBulletCol;

			int nPlayerRow = sPlayer.arrPos[j].nRow; //玩家的行
			int nPlayerCol = sPlayer.arrPos[j].nCol;

			if (nBulletRow == nPlayerRow && nBulletCol == nPlayerCol && sBulletMgr.vecBullet[i].isPlayer == false)
			{
				sPlayer.nHp -= sBulletMgr.vecBullet[i].nBulletAck;

				if (sPlayer.nHp <= 0)
				{
					g_GameMgr.nState = E_GAME_MENU;
				}
			}
		}
	}
}


void SGameMap::collicPlayer()
{
	for (int k = 0; k < 4; k++)
	{
		for (int i = 0; i < sEnemyMgr.vecEnemy.size(); i++)
		{
			for (int j = 0; j < 4; j++)
			{
				int nRow = g_GameMgr.gameMap.sEnemyMgr.vecEnemy[i].arrPos[j].nRow;
				int nCol = g_GameMgr.gameMap.sEnemyMgr.vecEnemy[i].arrPos[j].nCol;

				if (sPlayer.arrPos[k].nRow == nRow && sPlayer.arrPos[k].nCol == nCol)
				{
					cout << "游戏结束";
				}
			}
		}
	}
}

void SGameMap::update()
{
	if (KEY_DOWN(VK_SPACE))
	{
		g_GameMgr.nState = E_GAME_MENU;
	}

	sBulletMgr.update();
	sPlayer.update();
	sEnemyMgr.update();

	touchWall();
	hitEnemy();
	hitPlayer();
	collicPlayer();
}


void SGameMap::onRender()
{
	cout << curLevelDt.strName << endl;

	for (int i = 0; i < curLevelDt.nMaxRow; i++)
	{
		for (int j = 0; j < curLevelDt.nMaxCol; j++)
		{
			SBullet bullet = sBulletMgr.isBulletExist(i, j);
			SEnemy enemy = sEnemyMgr.isEnemyExist(i, j);

			if (1 == curLevelDt.arrMap[i][j])
			{
				cout << "■";
			}
			else if (sPlayer.isPlayerExist(i,j))
			{
				sPlayer.onRender();
			}
			else if (bullet.nBulletId >= 3001)
			{
				bullet.onRender();
			}
			else if (enemy.nEnemyId >= 4001)
			{
				enemy.onRender();
			}
			else{
				cout << "  ";
			}
		}
		cout << endl;
	}
}

RoleSelect.h（角色选择界面）

#pragma once
#include "stdafx.h"

struct SRoleSelect
{
	SRoleSelect();

	void update();
	void onRender();

	int nRoleState;
};

RoleSelect.cpp

#include "stdafx.h"
#include "RoleSelect.h"
#include "GameMgr.h"
#include "DataStruct.h"
#include "ConfigMgr.h"

SRoleSelect::SRoleSelect()
{
	nRoleState = 0;
}

void SRoleSelect::update()
{

	//键盘控制
	if (KEY_DOWN(VK_UP))
	{
		nRoleState--;
		if (nRoleState < 0)
		{
			nRoleState = g_ConfigMgr.roleDtMgr.getSize() - 1;  
			//vecData.size() - 1 代表最后一行
		}

	}
	else if (KEY_DOWN(VK_DOWN))
	{
		nRoleState++;
		if (nRoleState > g_ConfigMgr.roleDtMgr.getSize() -1)
		{
			nRoleState = 0;
		}
	}
	else if (KEY_DOWN(VK_RETURN))
	{
			g_GameMgr.nState = E_GAME_MAP;	
			SRoleDt data = g_ConfigMgr.roleDtMgr.getDataById(2001 + nRoleState);
			g_GameMgr.gameMap.sPlayer.init(data);
	}
}

void SRoleSelect::onRender()
{
	//遍历输出每一行的数据
	for (int i = 0; i < g_ConfigMgr.roleDtMgr.getSize(); i++)
	{
		if (nRoleState == i)
		{
			cout << "->";
		}
		else
		{
			cout << "  ";
		}

		SRoleDt roleData = g_ConfigMgr.roleDtMgr.getDataById(2001 + i);
		cout << roleData.nId << "\t" << roleData.nAck << "\t" << roleData.nHp << "\t" << roleData.nMp << "\t" <<roleData.nInterval<<"\t"
			<< roleData.nBulletId << "\t" << roleData.strName << "\t" << roleData.strPic;
		cout << endl;
		
	}
}

Player.h（玩家）

#pragma once
#include "RoleSelect.h"
#include "DataStruct.h"

struct SPlayer
{
	SPlayer();

	//把传入的两个值赋给四个节点（注意）
	void setPosition(int nInRow, int nInCol){
		arrPos[0].set(nInRow, nInCol);
		arrPos[1].set(nInRow, nInCol - 1);
		arrPos[2].set(nInRow, nInCol + 1);
		arrPos[3].set(nInRow - 1, nInCol);
	}

	void backup();
	void revert();

	void update();
	void onRender();

	//实例化四个节点
	SVec2 arrPos[4];

	int nTime; //玩家子弹帧数

	int nId;
	int nAck;
	int nHp;
	int nMp;
	int nInterval;
	int nBulletId;
	string strName;
	string strPic;

	void init(SRoleDt roleDt); 
	bool isPlayerExist(int nInRow, int nInCol);
};

Player.cpp

#include "stdafx.h"
#include "Player.h"
#include "GameMap.h"
#include "GameMgr.h"

SPlayer::SPlayer()
{
}

void SPlayer::backup()
{
	for (int i = 0; i < 4; i++)
	{
		arrPos[i].nRowBk = arrPos[i].nRow;
		arrPos[i].nColBk = arrPos[i].nCol;
	}
}

void SPlayer::revert()
{
	for (int i = 0; i < 4; i++)
	{
		arrPos[i].nRow = arrPos[i].nRowBk;
		arrPos[i].nCol = arrPos[i].nColBk;
	}
}

void SPlayer::update()
{
	//记得先备份坐标
	backup();

	if (KEY_DOWN(VK_LEFT))
	{
		for (int i = 0; i < 4; i++)
		{
			arrPos[i].nCol--;
		}
	}
	else if (KEY_DOWN(VK_RIGHT))
	{
		for (int i = 0; i < 4; i++)
		{
			arrPos[i].nCol++;
		}
	}

	//玩家子弹帧数随角色变化（注意：nInterval的数据来自配置表）
	nTime++;
	if (nTime >= nInterval)
	{
		nTime = 0; //归零

		//调用子弹生成函数
		g_GameMgr.gameMap.sBulletMgr.addBullet(nBulletId, arrPos[3].nRow, arrPos[3].nCol,true);
	}

}

void SPlayer::onRender()
{
	cout << strPic;
}


//用于接收角色选择后的角色数据
void SPlayer::init(SRoleDt roleDt)
{
	nId = roleDt.nId;
	nAck = roleDt.nAck;
	nHp = roleDt.nHp;
	nMp = roleDt.nMp;
	nInterval = roleDt.nInterval;
	nBulletId = roleDt.nBulletId;
	strName = roleDt.strName;
	strPic = roleDt.strPic;
}

bool SPlayer::isPlayerExist(int nInRow, int nInCol)
{
	for (int k = 0; k < 4; k++)
	{
		if (arrPos[k].nRow == nInRow && arrPos[k].nCol == nInCol)
		{
			return true;
			break;
		}
	}
	return false;
}

Bullet.h（子弹）

#pragma once
#include "DataStruct.h"

struct SBullet
{
	SBullet();

	int nBulletRow;
	int nBulletCol;	

	int nBulletId;
	int nBulletAck;
	string strBulletName;
	string strBulletPic;

	void init(SBulletDt data);  //数据传进来初始化
	void onRender();

	bool isPlayer;  //定义一个bool变量，用于标记子弹是玩家的还是敌机的
};

Bullet.cpp

#include "stdafx.h"
#include "Bullet.h"

SBullet::SBullet()
{
	nBulletId = 0;
	isPlayer = true; //默认为敌机子弹
}

void SBullet::init(SBulletDt bullet)
{
	nBulletId = bullet.nBulletId;
	nBulletAck = bullet.nBulletAck;
	strBulletName = bullet.strBulletName;
	strBulletPic = bullet.strBulletPic;
}

void SBullet::onRender()
{
	cout << strBulletPic;
}

BulletMgr.h（子弹管理者）

#pragma once
#include "Bullet.h"
#include "DataStruct.h"

struct SBulletMgr
{
	SBulletMgr();

	void addBullet(int nId, int nInRow, int nInCol, bool isPlayer);  //在添加子弹时给一个区别子弹的ID
	void removeBullet();
	void move();//子弹运动
	void update();

	SBullet isBulletExist(int nInRow, int nInCol); //渲染子弹

	vector<SBullet> vecBullet;
};

BulletMgr.cpp

#include "stdafx.h"
#include "BulletMgr.h"
#include "GameMgr.h"
#include "ConfigMgr.h"

SBulletMgr::SBulletMgr()
{
	
}

void SBulletMgr::addBullet(int nId,int nInRow, int nInCol,bool isInPlayer) //子弹的ID从玩家的配置表拿
{
	//根据子弹ID取子弹
	//因为子弹数据都在vecBulletDt中 
	SBullet bullet;
	//通过id拿到子弹数据
	SBulletDt bulletDt = g_ConfigMgr.bulletDtMgr.getDataById(nId);
	bullet.init(bulletDt);
	bullet.nBulletRow = nInRow;
	bullet.nBulletCol = nInCol;
	//设置子弹的标志位
	bullet.isPlayer = isInPlayer;
	vecBullet.push_back(bullet);
}
	

void SBulletMgr::removeBullet()
{
	//为了防止容器越界，从后往前遍历
	for (int i = vecBullet.size() - 1; i >= 0; i--)  
	{
		if (vecBullet[i].nBulletRow <= 0)  //子弹飞出地图
		{
			vecBullet.erase(vecBullet.begin() + i); 
		}
	}
}

//子弹管理者中的move管理子弹的运动方向
void SBulletMgr::move()
{
	for (int i = 0; i < vecBullet.size(); i++)
	{
		//根据标记位isBullet对容器中每个子弹的运动方向进行判定
		if (vecBullet[i].isPlayer)  //玩家的子弹
		{
			vecBullet[i].nBulletRow--;
		}
		else
		{
			vecBullet[i].nBulletRow++;
		}
	}	
}


void SBulletMgr::update()
{
	move();
	removeBullet();
}

SBullet SBulletMgr::isBulletExist(int nInRow, int nInCol)
{
	for (int i = 0; i < vecBullet.size(); i++)
	{
		if (vecBullet[i].nBulletRow == nInRow && vecBullet[i].nBulletCol == nInCol)
		{
			return vecBullet[i];
		}
	}
	SBullet bullet;
	return bullet;
}

Enemy.h（敌人）

#pragma once
#include "DataStruct.h"
struct SEnemy
{
	SEnemy();

	//实例化节点
	SVec2 arrPos[4];

	int nEnemyId;
	int nEnemyAck;
	int nEnemyHp;
	int nEnemyDef;
	int nBulletId;
	int nAckTime;//子弹发射帧数
	int nMoveTime;//敌机运动速度
	string strEnemyName;
	string strEnemyPic;

	int moveTime;
	int ackTime;

	void setPos(int nInRow, int nInCol);
	//初始化要传入一个结构体变量
	void init(SEnemyDt enemy);
	bool isExist(int nInRow,int nInCol);
	void onRender();
	void update();
	void move();//敌机运动
	void createBullet(); //子弹发射

	//bool isBullet();  应该定义在bullet.h中，因为这是子弹本身的
};

Enemy.cpp

#include "stdafx.h"
#include "Enemy.h"
#include "EnemyMgr.h"
#include "GameMgr.h"

SEnemy::SEnemy()
{
	moveTime = 0;
	ackTime = 0;
}

void SEnemy::setPos(int nInRow, int nInCol)
{
	arrPos[0].set(nInRow, nInCol);
	arrPos[1].set(nInRow, nInCol-1);
	arrPos[2].set(nInRow, nInCol+1);
	arrPos[3].set(nInRow+1, nInCol);
}

void SEnemy::init(SEnemyDt enemy)
{
	nEnemyId = enemy.nEnemyId;
	nEnemyAck = enemy.nEnemyAck;
	nEnemyHp = enemy.nEnemyHp;
	nEnemyDef = enemy.nEnemyDef;
	nBulletId = enemy.nBuletId;
	nAckTime = enemy.nAckTime;
	nMoveTime = enemy.nMoveTime;
	strEnemyName = enemy.strEnemyName;
	strEnemyPic = enemy.strEnemyPic;
}

bool SEnemy::isExist(int nInRow, int nInCol)
{
	for (int i = 0; i < 4; i++)
	{
		if (arrPos[i].nRow == nInRow && arrPos[i].nCol == nInCol )
		{
			return true;
		}
	}
	return false;
}

void SEnemy::onRender()
{
	cout << strEnemyPic;
}

void SEnemy::move()
{
	moveTime++;
	//根据帧数敌机运动
	if (moveTime >= nMoveTime)
	{
		moveTime = 0;
		for (int i = 0; i < 4; i++)
		{
			arrPos[i].nRow++;
		}
	}
}

void SEnemy::createBullet()
{
	ackTime++;
	//根据帧数创建敌机子弹
	if (ackTime > nAckTime)
	{
		ackTime = 0;
		g_GameMgr.gameMap.sBulletMgr.addBullet(nBulletId, arrPos[3].nRow, arrPos[3].nCol, false);
	}
}

void SEnemy::update()
{
	createBullet();
	move();
}

EnemyMgr.h（敌人管理者）

#pragma once
#include "Enemy.h"
struct SEnemyMgr
{
	SEnemyMgr();

	int nCreateTime;
	//容器(敌机)，创建敌人，数据更新，敌人运动，帧数，判断是否存在
	vector<SEnemy> vecEnemy;

	void createEnemy();
	void update();
	SEnemy isEnemyExist(int nInRow,int nInCol);
};

EnemyMgr.cpp

#include "stdafx.h"
#include "EnemyMgr.h"
#include "ConfigMgr.h"
#include "DataStruct.h"

SEnemyMgr::SEnemyMgr()
{
	nCreateTime = 0;
}

void SEnemyMgr::createEnemy()
{
	//随机敌人的Id
	int nId = rand() % 4 + 4001;
	//根据Id拿敌人数据
	SEnemyDt enemyDt = g_ConfigMgr.enemyDtMgr.getDataById(nId);
	//实例化敌人
	SEnemy enemy;
	//对拿到的数据进行初始化
	enemy.init(enemyDt);
	//设置行列(随机列)
	enemy.setPos(1, rand() % 11 + 2);

	vecEnemy.push_back(enemy);
}

void SEnemyMgr::update()
{
	//每10帧创建一个敌机
	nCreateTime++;
	if (nCreateTime > 20 )
	{
		nCreateTime = 0;
		createEnemy();
	}

	//不同敌机速度不同
	for (int i = 0; i < vecEnemy.size(); i++)
	{
		vecEnemy[i].update();
	}
}

//判断某处是否存在飞机
SEnemy SEnemyMgr::isEnemyExist(int nInRow, int nInCol)
{
	for (int i = 0; i < vecEnemy.size();i++)
	{
		if (vecEnemy[i].isExist(nInRow,nInCol))
		{
			return vecEnemy[i];
		}
	}
	SEnemy enemy;
	return enemy;
}
pistach
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
h5小游戏管理平台系统网站源码 v0.0.1
01-01
h5小游戏管理平台是一款h5小游戏管理后台系统网站源码，方便商家活动操作运作，通过线上游戏互动促进线下消费的平台系统
cocos2d-x实战项目【飞机大战】-- 配置子弹数据
weixin_40968046的博客
07-08 184
json文件 [ { "id":3001, "img":"blueBall2.png" }, { "id":3002, "img":"greenBall.png" }, { "id":3003, "img":"helperBullet.png" }, { "id":3004, "img":"monsterBullet1.png" }, { "id":3005, "img":"orangeCircle.png" }, { "id":300
[附源码]JAVA+ssm基于Java网络游戏后台管理系统（程序+Lw)
海灵学姐
03-22 720
网络游戏后台管理系统基于Web服务模式，是一个适用于Internet环境下的模型结构。只要用户能连上Internet,便可以在不受时间、地点的限制来使用这个系统。网络游戏后台管理系统工作原理图，如图4-1所示：图4-1 系统工作原理图。
使用Excel制作游戏配置表并导出Json和C#代码到Unity中使用
m0_72922928的博客
11-10 976
使用excel2json导出json文件并导入unity，提高数据读取效率，并且修改excel中枚举值显示为对应的字符串，提高可读性
游戏内存读取工具_关于优化lua读取游戏配置表的一些看法
weixin_42314448的博客
01-29 1657
最近在做lua的内存优化，发现项目在读取配置表的时候占用了大约70MB的内存。而实际的protobuf的二进制文件总共大小才10MB左右，所以感觉可优化的空间还是蛮大的，就深入检查了问题所在。一般的项目配置表大致是这个样子,第一列一般是主键id,顺序的整形数字,一般从1开始。列是策划写的对应的内容名称。项目里使用的protobuf作为存储媒介,采用云风的lua protobuf工具转换成可以读取...
图书管理系统+Java源代码+SQL Server数据库文件
01-30
综上所述，这个“图书管理系统+Java源代码+SQL Server数据库文件”项目涵盖了从后端开发、数据库设计、前端界面到系统集成的多个方面，是学习和实践Java Web开发以及数据库管理的一个理想案例。通过深入研究这个系统...
javaWEB酒店管理系统源代码（完整版）
11-09
2. 数据库配置：创建MySQL数据库，导入系统提供的数据库脚本，初始化数据表结构。 3. 应用部署：将项目导出为WAR文件，放入服务器的webapps目录下，启动服务器即可运行。 4. 运行测试：通过浏览器访问服务器地址，...
ssm+jsp计算机毕业设计游戏管理平台463mk（程序+lw+源码+远程部署）
秋名计算机毕设程序源码
02-23 73
Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。2. 前端：L ayui+css+javascript+jQuery+ElemenUI+highcharts。SSM + mybatis + Maven + JSP 等等组成，B/S模式 + Maven管理等等。2. 使用IDEA/Eclipse/MyEclipse导入项目，修改配置，运行项目；
python游戏代码大全可复制,python基础游戏代码
2301_79533350的博客
12-23 7252
分享13个游戏源码，可以自己复现玩玩，研究下里面的编程逻辑，对学习编程（特别是初学者）应该会有很大帮助。
KVM web管理工具——WebVirtMgr（一）
weixin_33814685的博客
04-29 245
WebVirtMgr 介绍 WebVirtMgr采用几乎纯Python开发，其前端是基于Python的Django，后端是基于Libvirt的Python接口，将日常kvm的管理操作变的更加的可视化。 WebVirtMgr 特点 操作简单，易于使用 通过libvirt的API接口对kvm进行管理 提供对虚拟机生命周期管理 We...
游戏数值详细表
03-07
游戏数值详细设计表格，经典战法牧角色设计类型的游戏
用户表格创建游戏数据
08-02
怎麼使用UE4來實現游戏配置呢？ XML是我们常用的格式，但是对于虚幻4的导入，目前可以支持的Json,csv,自己写代码读取XML也咩有问题。
【协议分析】常用协议端口号
热门推荐
Walter的专栏
11-12 5万+
0      TCP  Reserved   0      UDP  Reserved   1      TCP tcpmux TCP Port Service Multiplexer Breach, SocketsDeTroie  1      UDP tcpmux TCP Port Service Multiplexer Sockets des Troie, SocketsDeTroie
Python游戏代码大全可复制,python游戏代码大全简单
最新发布
w666666Wwwwwww的博客
02-04 646
在程序中，我们要一直判断退出事件是否触发，然后做出相应，所以退出事件通常需要配合循环语句和条件语句使用。绘制多张图片时，先绘制的对象在下面，后绘制的对象在上面。如果坐标重合，后绘制的对象遮挡先绘制的对象。绘制多张图片时，先绘制的对象在下面，后绘制的对象在上面。如果坐标重合，后绘制的对象遮挡先绘制的对象。精确的检测某个键时，需要先判断事件的类型，按下还是抬起，然后再检测按下的键是什么。语句的条件，按下键盘后的程序作为条件语句的执行语句。语句的条件，抬起键盘后的程序作为条件语句的执行语句。
一个简单的游戏框架：配置表方案
胡胜同学
05-20 1万+
一个简单的游戏框架：配置表方案 代码：https://github.com/HushengStudent/myGameFramework 1、配置表格式 csv，逗号分隔，可以使用wps和Excel打开编辑，方便策划使用； 默认第一行为注释； 默认第二行为字段名+类型；二者以冒号隔开； 默认第一列为主键； 2、配置表导出方案 在编辑器下，读取配置表的内容，并把内容按规则转换成对应类...
《Python游戏趣味编程》标准IDE运行游戏代码的配置方法
weixin_49630241的博客
01-16 595
首先，用Pip安装pygame、pygame zero两个库：pip install pygamepip install pygame zero第2章在编程猫海龟编辑器下的代码如下：import pgzrun WIDTH = 800 HEIGHT = 600 x = WIDTH/2 y = HEIGHT/2 speed_x = 3 speed_y = 5 r = 30 def draw(): ...
Python游戏汇总：三十个pygame游戏代码【附源码免费分享】
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
06-12 2万+
哈喽哈喽！我是木木子！每日更新游戏不知不觉已经很多啦~Python兴趣始于游戏，所以更新的文章中基本上都是游戏代码居多。然后我疯狂的找各种小游戏、小脚本、小项目的教程源码什么的，然后自己进行学习、制作、修改等等。于是我就疯狂的找呀找呀学呀学呀，现在就有一大堆，哈哈哈，所以今天是准备稍稍的整理下，感觉比较乱。提示：爱学习哦，不要沉迷游戏，平时打发一下无聊时间最好啦往期更多文章欢迎阅读：1.成语接龙游戏项目。2.塔防游戏项目。3.记忆翻牌游戏项目。4.吃豆豆小游戏项目。5.外星人入侵游戏项目。6.数织游戏项目。
Config配置表
BBoyLXiang的博客
12-28 1134
新建文件夹StreamingAssets 在文件夹里新建一个名称为Config.txt的配置表 Config配置表 Config配置表代码 具体调用可查看本作者网络文章代码 using System.Collections; using System.Collections.Generic; using UnityEngine; using System.IO; using System; public class ConfigTest : MonoBehaviour { private str
配置表测试框架搭建-②数据读取篇
游戏测试-AJiian的博客
01-27 2621
文章目录前言技术栈配置Demo正文一、工作表数据读取二、工作表屏蔽三、筛选有效数据四、读取所有数据五、Lua数据处理结语 前言 这篇为游戏策划配置表测试系列的第二篇，主要讲的是根据项目的配置表格规范或格式来读取对应的数据，比如读取Excel文件的所有数据、读取当个工作表的数据、按行读取、按列读取、按字段读取，用不同的库读取速度也不一样，之前也写过一篇读取速度对比的文章，这里跳转，我这主要用的openpyxl，其它几个库使用上差别不大；另外一个会用到Lua库，因为配置表里的数据有些直接配置成Lua的tabl

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值