C语言项目实战—坦克大战

最新推荐文章于 2024-04-25 10:39:33 发布

空弦的编程小屋

最新推荐文章于 2024-04-25 10:39:33 发布

阅读量2.8k

点赞数 5

分类专栏： C语言C++项目文章标签： c语言开发语言游戏 visual studio c++

本文链接：https://blog.csdn.net/kxtxdy/article/details/123423802

版权

C语言C++项目专栏收录该内容

15 篇文章 35 订阅

订阅专栏

闲暇时间写的一个坦克大战，有些功能还没完善，但是给新手参考学习还是不错的。先看看效果图：

看看各部分代码吧

一、场景管理

1、背景

#include "stdafx.h"



CBackGround::CBackGround(TSTRING name)
{
CPicture*_pPic= CResManager::GetInstance()->GetPicture(name);
	if (_pPic==nullptr)
	{
		assert (_T("pic is null"));
	}
	m_nShowWidth = _pPic->GetWidth();
	m_nShowHeight = _pPic->GetHeight();
	Texture = CResManager::GetInstance()->GetPicture(name)->GetTexture();
	m_sDesPos = { 0.0f,0.0f,0.0f };
}

CBackGround::~CBackGround()
{
}

void CBackGround::Render()
{
	m_pSprite->Begin(D3DXSPRITE_ALPHABLEND);

	if (m_sDesPos.y >= 0)
		m_pSprite->Draw(Texture, NULL, NULL, &D3DXVECTOR3(0, m_sDesPos.y - m_nShowHeight, 0), 0xffffffff);
	m_pSprite->Draw(Texture, NULL, NULL, &D3DXVECTOR3(0, m_sDesPos.y, 0), 0xffffffff);
	
	m_pSprite->End();
}

void CBackGround::Update()
{
	if (m_sDesPos.y < m_nWindowHeight)
		m_sDesPos.y += 1;
	else
		m_sDesPos.y = m_nWindowHeight-m_nShowHeight;
}

2、场景

#include "stdafx.h"



CScene::CScene()
{
}


CScene::~CScene()
{
}

3、开始场景

#include "stdafx.h"


CBeginScene::CBeginScene()
{
	background = new CBackGround(_T("ditu.png"));//开始页面的背景
	m_begin = new CUIButton(250,200,_T("OK.png"), _T("OK1.png"), _T("OK2.png"));//开始按键
	m_over = new CUIButton(250,260,_T("T.png"), _T("T1.png"), _T("T2.png"));//退出按键
}

CBeginScene::~CBeginScene()
{
	if (background)
		delete background;
	if (m_begin)
		delete m_begin;
	if (m_over)
		delete m_over;

}

void CBeginScene::Update()
{
	m_begin->Wndpfoc();//调消息处理函数
	m_over->Wndpfoc();//调消息处理函数
	if (m_begin->IsButtonDown())
	{
		CSceneManager::GetInstance()->SetCurSceneName(_T("gamescene"));//切换场景
		CSceneManager::GetInstance()->RemoveScene(_T("beginscene")); 
	}
	else if(m_over->IsButtonDown())
	{
		PostQuitMessage(0);    //退出游戏
	}
	
}


void CBeginScene::Render()
{	
	background->Render();
	m_begin->Draw();
	m_over->Draw();
}

void  CBeginScene::ClickButton()
{
	/*CSceneManager::GetInstance()->SetCurSceneName(_T("menuscene"));
	CSceneManager::GetInstance()->RemoveScene(_T("beginscene"));*/
}

4、游戏场景

4.1、地图

#include "stdafx.h"



Map::Map()
{
}


Map::~Map()
{
}

void Map::Init(TSTRING _name)
{
	m_Grass.Init(_T("map1.png"));//草
	m_Water.Init(_T("map2.png"));//水
	m_Brick.Init(_T("map3.png"));//砖
	m_Lron.Init(_T("map.png"));  //铁
	m_Boss.Init(_T("Dea1.png"));//Boss
	FILE* fp;
#ifdef UNICODE
	char*file = CUtility::CU_U2A(_name.c_str());       //从xml文件中读取图片内容
#else
	const char*file = fileName.c_str();
#endif
	fopen_s(&fp, file, "r");//找到文件名
	if (0 == fp)            //是否为空
		return;
	fscanf_s(fp, "(%d,%d)\r\n", &m_Xmap, &m_Ymap);//取出行列
	if (m_Xmap != 0 && m_Ymap != 0)               //判断行列不等于零
	{
		//开二维数组的堆
		m_map = new int*[m_Ymap];        //先new行数
		for (int i = 0; i < m_Ymap; ++i)//开始去循环去new 列数
		{
			m_map[i] = new int[m_Xmap];
		}
		//读取地图数据
		for (int i = 0; i < m_Ymap; ++i) //循环读取TXT数据
		{
			for (int j = 0; j < m_Xmap; ++j)
			{
				fscanf_s(fp, "%d,", &m_map[i][j]);
			}
			fscanf_s(fp, "\r\n");
		}
		fclose(fp);	//关闭文件
	}
}

void Map::Render()
{
	for (size_t i = 0; i < m_Ymap; i++)//循环行
	{
		for (size_t j = 0; j < m_Xmap; j++)//循环列
		{
			D3DXVECTOR3 _desPos = { FLOAT(j * 28), FLOAT(i * 28), 0 };//画的像素大小
			
			switch (m_map[i][j])
			{
			case Grass: //草的地图块
			{
				m_Grass.SetDesPos(_desPos);
				m_Grass.Render();
			}
			break;
			case water:
			{
				m_Water.SetDesPos(_desPos);
				m_Water.Render();
			}
			break;
			case Brick://砖的地图块
			{
				m_Brick.SetDesPos(_desPos);
				m_Brick.Render();
			}
			break;
			case Lron://铁的地图块
			{
				m_Lron.SetDesPos(_desPos);
				m_Lron.Render();
			}
			break;
			case Boss:
			{
				m_Boss.SetDesPos(_desPos);
				m_Boss.Render();
			}
			break;
			default:
				break;
			}
		}
	}
}

4.2、敌机

#include "stdafx.h"



CEnemy::CEnemy(TSTRING n_name,TSTRING _name, TSTRING _name1, TSTRING _name2, TSTRING _name3, FLOAT _x, FLOAT _y)
{
	m_nDir = DOWN;
	m_Tname = n_name;     //坦克路径
	m_Enmeyname = _name; //动画上
	m_Enmeyname1 = _name1;//动画下
	m_Enmeyname2 = _name2;//动画左
	m_Enmeyname3 = _name3;//动画右
	m_x = _x;  //初始位置
	m_y = _y; //初始位置
	SetDesPos({ m_x,m_y,0 });                //敌机初始位置
	m_speed = 3;                             //移动速度
	m_fbullte = false;                       //开始不发子弹
	vector<TSTRING>animationName;            //动画容器
	animationName.push_back(m_Enmeyname);    //往上动画
	animationName.push_back(m_Enmeyname1);   //往下动画
	animationName.push_back(m_Enmeyname2);   //往左动画
	animationName.push_back(m_Enmeyname3);   //往右动画
	Init(animationName);
	RECT _rec = CResManager::GetInstance()->GetAnimationFrame(m_Tname)->GetRect();
	SetShowWidth(_rec.right - _rec.left); //显示在屏幕上的宽
	SetShowHeight(_rec.bottom - _rec.top);//显示在屏幕上的高
	SetCenter({ 0.0f,0.0f,0 });//设置锚点
	SetCollideRect(_rec);
}


CEnemy::~CEnemy()
{
}

VOID CEnemy::PlayerDir()
{

	srand(time(0));
	int m_time = rand() % 4 + 1;
	switch (m_time)
	{
	case 1:
	{
		m_nDir = UP;
		bIsMoving = TRUE;
	}
	break;

	case  2:

	{
		m_nDir = DOWN;
		bIsMoving = TRUE;
	}
	break;
	case 3:
	{
		m_nDir = LEFT;
		bIsMoving = TRUE;
	}
	break;
	case 4:
	{
		m_nDir = RIGHT;

		bIsMoving = TRUE;
	}
	break;
	default:
		break;
	}
	
	


	
}

void CEnemy::Move()
{
	
		switch (m_nDir)
		{
			
		case UP:
		{
			if (m_curAnimation != m_Enmeyname)
			{
				SetCurAnimation(m_Enmeyname);
			}
			m_sSpeed = { 0,-1 * m_speed,0 };
			
		}
		break;
		case DOWN:
		{
			if (m_curAnimation != m_Enmeyname1)
			{
				SetCurAnimation(m_Enmeyname1);
			}
				m_sSpeed = { 0,m_speed,0 };        //移动速度;
		}
		break;
		case LEFT:
		{
			if (m_curAnimation != m_Enmeyname2)
			{
				SetCurAnimation(m_Enmeyname2);
			}
			
			m_sSpeed = { -1 * m_speed,0,0 };
		}
		break;
		case RIGHT:
		{
			if (m_curAnimation != m_Enmeyname3)
			{
				SetCurAnimation(m_Enmeyname3);
			}
			
				m_sSpeed = { m_speed, 0,0 };
		
		}
		break;
		/*default:
			break;*/
		}
		Collision();
	if (bIsMoving)
	{
		m_sDesPos += m_sSpeed;
		Update();
	}
	else if (m_nDir == NONE)
	{

		Update();
	}
}

VOID CEnemy::Collision()
{
	//临时变量
	int dir = m_nDir;           //方向
	int speed = m_speed;        //速度
	int playerX = m_sDesPos.x; //x坐标位置
	int playerY = m_sDesPos.y;//y坐标位置
	switch (m_nDir)
	{
	case UP:
		playerY -= speed;
		break;
	case DOWN:
		playerY += speed;
		break;
	case LEFT:
		playerX -= speed;
		break;
	case RIGHT:
		playerX += speed;
		break;
	}
	//当前位置加上移动向量
	//temp_pos += v;
	//用下一时刻位置图片所占的格子去判断碰撞
	//临时变量
	int playerWidth = GetShowWidth();   //玩家宽
	int playerHeight = GetShowHeight(); //玩家高
	int startRow = (playerY + 2) / 28;               //行的开始点
	int endRow = (playerY + playerHeight - 2) / 28;//行的结尾点
	int startCol = (playerX + 2) / 28;               //列的开始点
	int endCol = (playerX + playerWidth - 2) / 28;    //列的结尾点
	switch (m_nDir)
	{
	case  UP:
	{
		for (int i = startCol; i <= endCol; i++)
			if (m_map1->m_map[startRow][i] > Grass)
			{
				bIsMoving = false;
				break;
			}
		/*else
		{
		if (m_map1->m_map[(INT)playerY / 28 - 1][(INT)playerX / 28] == Grass)
		{
		if (m_map1->m_map[startRow][i] == Grass)
		{
		bIsMoving = false;
		break;
		}
		}
		}*/

	}
	break;
	case RIGHT:
	{

		for (int i = startRow; i <= endRow; i++)
			if (m_map1->m_map[i][endCol] > Grass)
			{
				bIsMoving = false;
				break;
			}
		/*else
		{
		if (m_map1->m_map[(INT)playerY / 28][(INT)playerX / 28 + 1] == Grass)
		{
		if (m_map1->m_map[startRow][i] == Grass)
		{
		bIsMoving = false;
		break;
		}
		}
		}
		*/
	}
	break;
	case DOWN:
	{

		for (int i = startCol; i <= endCol; i++)
			if (m_map1->m_map[endRow][i] > Grass)
			{
				bIsMoving = false;
				break;
			}
		/*else
		{
		if (m_map1->m_map[(INT)playerY / 28 - 1][(INT)playerX / 28] == Grass)
		{
		if (m_map1->m_map[startRow][i] == Grass)
		{
		bIsMoving = false;
		break;
		}
		}
		}*/

	}
	break;
	case LEFT:
	{

		for (int i = startRow; i <= endRow; i++)
			if (m_map1->m_map[i][startCol] > Grass)
			{
				bIsMoving = false;
				break;
			}
		/*else
		{
		if (m_map1->m_map[(INT)playerY / 28][(INT)playerX / 28-1] == Grass)
		{
		if (m_map1->m_map[startRow][i] == Grass)
		{
		bIsMoving = false;
		break;
		}
		}
		}*/

	}
	break;

	default:
		break;
	}
}

4.3、技能

#include "stdafx.h"



CProps::CProps()
{
	m_mTank.Init(_T("pro.png"));
	CResManager::GetInstance()->GetAnimation(_T("pro.png"))->m_fTime = 0.2;
	m_mLron.Init(_T("pro2.png"));
	CResManager::GetInstance()->GetAnimation(_T("pro2.png"))->m_fTime = 0.2;
	m_mzhadan.Init(_T("pro3.png"));
	CResManager::GetInstance()->GetAnimation(_T("pro3.png"))->m_fTime = 0.2;
	m_fTemp = 0;
	m_t = 0.1;
}


CProps::~CProps()
{
}

VOID CProps::RenderTAank(INT _x, INT _y)
{
	if (m_fTemp >= 2 || m_fTemp <= -2)
	{
		m_t *= -1;
	}
	m_fTemp = m_fTemp + m_t;
	m_mTank.SetDesPos({ (FLOAT)_x * 28,(FLOAT)_y * 28 + m_fTemp,0 });
	m_mTank.Update();
	m_mTank.UpdateMAatrix();
	m_mTank.Render();
}

VOID CProps::Renderzhadan(INT _x, INT _y)
{
	if (m_fTemp >= 2 || m_fTemp <= -2)
	{
		m_t *= -1;
	}
	m_fTemp = m_fTemp + m_t;
	m_mLron.SetDesPos({ (FLOAT)_x * 28,(FLOAT)_y * 28 + m_fTemp,0 });
	m_mLron.Update();
	m_mLron.UpdateMAatrix();
	m_mLron.Render();

}

VOID CProps::RenderLron(INT _x, INT _y)
{
	if (m_fTemp >= 2 || m_fTemp <= -2)
	{
		m_t *= -1;
	}
	m_fTemp = m_fTemp + m_t;
	m_mzhadan.SetDesPos({ (FLOAT)_x * 28,(FLOAT)_y * 28 + m_fTemp,0 });
	m_mzhadan.Update();
	m_mzhadan.UpdateMAatrix();
	m_mzhadan.Render();
}

4.4、玩家

#include "stdafx.h"



CPlayer::CPlayer(TSTRING n_name,TSTRING _name, TSTRING _name1, TSTRING _name2, TSTRING _name3)
{
	//bIsMoving = false;
	m_Pname = n_name;
	m_playname = _name;
	m_playname1 = _name1;
	m_playname2 = _name2;
	m_playname3 = _name3;
	SetDesPos({ 222,352,0 });              //玩家初始位置
	m_speed = 3;                           //移动速度
	m_fbullte = false;                     //开始不发子弹
	vector<TSTRING>animationName;          //动画容器
	animationName.push_back(m_playname);   //往上动画
	animationName.push_back(m_playname1);  //往下动画
	animationName.push_back(m_playname2);  //往左动画
	animationName.push_back(m_playname3);  //往右动画
	Init(animationName);
	RECT _rec = CResManager::GetInstance()->GetAnimationFrame(m_Pname)->GetRect();
	SetShowWidth(_rec.right - _rec.left); //显示在屏幕上的宽
	SetShowHeight(_rec.bottom - _rec.top);//显示在屏幕上的高
	SetCenter({ 0.0f,0.0f,0 });//设置锚点
	SetCollideRect(_rec);
	m_lsitButt.clear();

	m_nDir=UP;
}


CPlayer::~CPlayer()
{
	m_lsitButt.clear();
}





VOID CPlayer::Move()
{
	
		switch (m_nDir)
		{
		case UP:
		{
			if (m_curAnimation != m_playname)
			{
				SetCurAnimation(m_playname);//设置当前动画帧
			}
			
			m_sSpeed = { 0,-1 * m_speed,0 };
		
		}
		break;
		case DOWN:
		{
			if (m_curAnimation != m_playname1)
			{
				SetCurAnimation(m_playname1);
			}
			
			m_sSpeed = { 0, m_speed,0 };          //移动速度;
		
		
		}
		break;
		case LEFT:
		{
			if (m_curAnimation != m_playname2)
			{
				SetCurAnimation(m_playname2);
			}
			
			m_sSpeed = { -1 * m_speed,0,0 };
			
		}
		break;
		case RIGHT:
		{
			if (m_curAnimation != m_playname3)
			{
				SetCurAnimation(m_playname3);
			}
			m_sSpeed = { m_speed,0,0 };
			
		}
		break;
		}
		Collision();//碰撞矩形区域
	if (m_bIsMoving)
	{
		m_sDesPos += m_sSpeed;
		Update();
	}
	else if (m_nDir != NONE)
	{
		Update();

	}
}

VOID CPlayer::Collision()
{
	//临时变量
	int dir = m_nDir;           //方向
	int speed = m_speed;        //速度
	int playerX = m_sDesPos.x; //x坐标位置
	int playerY = m_sDesPos.y;//y坐标位置
	switch (m_nDir)
	{
	case UP:
		playerY -= speed;
		break;
	case DOWN:
		playerY += speed;
		break;
	case LEFT:
		playerX -= speed;
		break;
	case RIGHT:
		playerX += speed;
		break;
	}
	//当前位置加上移动向量
	//temp_pos += v;
	//用下一时刻位置图片所占的格子去判断碰撞
	//临时变量
	//RECT _rect = GetCollideRect();      //碰撞区域
	int playerWidth = GetShowWidth();   //玩家宽
	int playerHeight = GetShowHeight(); //玩家高
	int startRow = (playerY + 2) / 28;               //行的开始点
	int endRow = (playerY + playerHeight - 2) / 28; //行的结尾点
	int startCol = (playerX + 2) / 28;               //列的开始点
	int endCol = (playerX + playerWidth - 2) / 28;    //列的结尾点
	switch (m_nDir)
	{
	case  UP:
	{

		for (int i = startCol; i <= endCol; i++)
			if (m_map1->m_map[startRow][i] > Grass)
			{
				m_bIsMoving = false;
				break;
			}
		/*else
		{
			if (m_map1->m_map[(INT)playerY / 28 - 1][(INT)playerX / 28] == Grass)
			{
				if (m_map1->m_map[startRow][i] == Grass)
				{
					bIsMoving = false;
					break;
				}
			}
		}*/
		
	}
	break;
	case RIGHT:
	{

		for (int i = startRow; i <= endRow; i++)
			if (m_map1->m_map[i][endCol] > Grass)
			{
				m_bIsMoving = false;
				break;
			}
		/*else
		{
			if (m_map1->m_map[(INT)playerY / 28][(INT)playerX / 28 + 1] == Grass)
			{
				if (m_map1->m_map[startRow][i] == Grass)
				{
					bIsMoving = false;
					break;
				}
			}
		}
*/
	}
	break;
	case DOWN:
	{

		for (int i = startCol; i <= endCol; i++)
			if (m_map1->m_map[endRow][i] > Grass)
			{
				m_bIsMoving = false;
				break;
			}
		/*else
		{
			if (m_map1->m_map[(INT)playerY / 28 - 1][(INT)playerX / 28] == Grass)
			{
				if (m_map1->m_map[startRow][i] == Grass)
				{
					bIsMoving = false;
					break;
				}
			}
		}*/

	}
	break;
	case LEFT:
	{

		for (int i = startRow; i <= endRow; i++)
			if (m_map1->m_map[i][startCol] > Grass)
			{
				m_bIsMoving = false;
				break;
			}
		/*else
		{
			if (m_map1->m_map[(INT)playerY / 28][(INT)playerX / 28-1] == Grass)
			{
				if (m_map1->m_map[startRow][i] == Grass)
				{
					bIsMoving = false;
					break;
				}
			}
		}*/

	}
	break;
	
	
	}
	
}

VOID CPlayer::Bullet()
{
	return VOID();
}

void CPlayer::BulletRend()
{
	for (list<CBullet*>::iterator it = m_lsitButt.begin();
		it != m_lsitButt.end(); it++)
	{
		
		(*it)->Render();
	}
}

void CPlayer::Bulletmove()
{
	for (list<CBullet*>::iterator it = m_lsitButt.begin();
		it != m_lsitButt.end();)
	{
		(*it)->Update();
		if ((*it)->Collision())
		{
			it = m_lsitButt.erase(it);
			continue;
		}
		it++;
	}
}

VOID CPlayer::PlayerDir()
{
	if (g_DXInput.IsKeyHold(DIK_UP))
	{
		m_nDir = UP;
		m_dir = UP;
		m_bIsMoving = TRUE;
	}
	else if (g_DXInput.IsKeyHold(DIK_DOWN))
	{
		m_nDir = DOWN;
		m_dir = DOWN;
		m_bIsMoving = TRUE;
	}
	if (g_DXInput.IsKeyHold(DIK_LEFT))
	{
		m_nDir = LEFT;
		m_dir = LEFT;
		m_bIsMoving = TRUE;
	}
	else if (g_DXInput.IsKeyHold(DIK_RIGHT))
	{
		m_nDir = RIGHT;
		m_dir = RIGHT;
		m_bIsMoving = TRUE;
	}
	if (g_DXInput.IsKeyCurrentDown(DIK_SPACE))
	{
		CBullet*temp = new CBullet();
		temp->Init();
	
		temp->SetposX((m_sDesPos.x));
		temp->SetposY((m_sDesPos.y));
		if (m_dir != 0)
		{
			temp->SetDir(m_dir);
		}
		m_lsitButt.push_back(temp);
		m_fbullte = TRUE;
	}
	if (g_DXInput.IsKeyCurrentUp(DIK_UP))
	{
		m_nDir -= UP;
		m_bIsMoving = FALSE;
	}
	else if (g_DXInput.IsKeyCurrentUp(DIK_DOWN))
	{
		m_nDir -= DOWN;
		m_bIsMoving = FALSE;
	}
	if (g_DXInput.IsKeyCurrentUp(DIK_LEFT))
	{
		m_nDir -= LEFT;
		m_bIsMoving = FALSE;
	}
	else if (g_DXInput.IsKeyCurrentUp(DIK_RIGHT))
	{
		m_nDir -= RIGHT;
		m_bIsMoving = FALSE;
	}
	if (g_DXInput.IsKeyCurrentUp(DIK_SPACE))
	{
		m_fbullte = FALSE;
	}
}

4.5、子弹管理

#include "stdafx.h"



CBullet::CBullet()
{

	m_bIsVisible = false;
	
}


CBullet::~CBullet()
{
}

void CBullet::Init()
{
	m_nShowWidth = CResManager::GetInstance()->GetPicture(_T("bullet.png"))->GetWidth();   //子弹照片宽高
	m_nShowHeight = CResManager::GetInstance()->GetPicture(_T("bullet.png"))->GetHeight();
	Texture = CResManager::GetInstance()->GetPicture(_T("bullet.png"))->GetTexture();      //传入照片画
	m_mspeed = 4;                                                                          //子弹速度
	SetCenter({ 0.0f,0.0f,0 });//设置锚点                                                  //设置的锚点

}



void CBullet::Update()
{
	/*UpdateMAatrix();*/
	Move();
}

void CBullet::Render()
{
	
	m_pSprite->Begin(D3DXSPRITE_ALPHABLEND);
	m_pSprite->Draw(Texture, NULL, NULL, &m_pos, D3DCOLOR_ARGB(255, 255, 255,255));
	m_pSprite->End();
}

void CBullet::Move()
{
	switch (m_dir)
	{
	case  LEFT:
	{
		m_pos.x -= m_mspeed;
	}
	break;
	case RIGHT:
	{
		m_pos.x += m_mspeed;
	}
	break;
	case  UP:
	{
		m_pos.y -= m_mspeed;
	}
	break;
	case DOWN:
	{
		m_pos.y += m_mspeed;
	}
	break;
	default:
		break;
	}
}

bool CBullet::Collision()
{
	if (m_pos.x>=400||m_pos.x<=0||m_pos.y<=0||m_pos.y>=500)
	{
		return true;
	}
	return false;
}


int CBullet::GetTargetEnemyNumber(){return TargetEnemyNumber;}

void CBullet::SetTargetEnemyNumber(int a){ TargetEnemyNumber = a; }

#include "stdafx.h"



CBulletManager::CBulletManager()
{
	m_Fireframe = 0;
	//玩家子弹
	m_TankMax = 30;
	for (int i = 0; i < m_TankMax; i++)
	{
		CBullet* Tank = new CBullet();
		TankList.push_back(Tank);
	}
	//敌机子弹
	m_EnemyMax = 30;
	for (int i = 0; i < m_EnemyMax; i++)
	{
		CBullet* enemy = new CBullet();
		EnemyList.push_back(enemy);
	}

}


CBulletManager::~CBulletManager()
{
	//删除玩家子弹链
	for (int i = 0; i < m_TankMax; i++)
		delete TankList[i];
	//删除敌机子弹链
	for (int i = 0; i < m_EnemyMax; i++)
		delete EnemyList[i];
}

void CBulletManager::Update()
{
	if (CSceneManager::GetInstance()->GetCurSceneName() == _T("gamescene"))//   设置当前场景
	{
		CGameScene* scene = (CGameScene*)(CSceneManager::GetInstance()->GetCurScene());
		
	}
}

void CBulletManager::Render()
{

}

void CBulletManager::Fire(int, float, float)
{

}

#include "stdafx.h"


CGameScene::CGameScene()
{
	m_background = new CBackGround(_T("bei.png"));//背景
	m_background1 = new CBackGround(_T("test.png"));//显示框
	m_background1->SetDesPos(D3DXVECTOR3(560, 0, 0));
	m_map = new Map;
	m_map->Init(_T("data/map.txt")); //地图
	m_player = new CPlayer(_T("tan.png0"),_T("MyUP"), _T("Mydown"), _T("Myleft"), _T("Myright"));//动画
	m_player->SetMap1(m_map); //玩家
	m_Enemy = new CEnemy(_T("Tank.png0"),_T("EnemyUP"),_T("Enemydown"),_T("Enemyleft"),_T("Enemyright"),200.0f,30.0f);//传入动画
	m_Enemy->SetMap1(m_map);//敌方

	
	
	//plane = new CPlane;
	//plane->Init(_T("Plane"));
	m_test = new CSprite();
	//vector<TSTRING> tempAniVec;
	//tempAniVec.push_back(_T("PlayerUp"));
	//tempAniVec.push_back(_T("Att1"));
	//tempAniVec.push_back(_T("Att2"));
	//m_test->Init(tempAniVec);
	//enmeylist.Init();
}

CGameScene::~CGameScene()
{
	if (m_background)
		delete m_background;
	if (m_background1)
		delete m_background1;
	if (m_map)
		delete m_map;
	if (m_player)
		delete m_player;
	if (m_Enemy)
		delete m_Enemy;
	
}

//CPlane* CGameScene::GetPlane() { return plane; }

void CGameScene::Update()
{
	m_player->PlayerDir();
	m_player->Move();
	m_Enemy->PlayerDir();
	m_Enemy->Move();
	m_player->Bulletmove();
	
	
	//CEnemyManager::GetInstance()->Update();
	/*CBulletManager::GetInstance()->Update();
	CExplosionManager::GetInstance()->Update();
	CGoodsManager::GetInstance()->Update();*/
}

void CGameScene::Render()
{

	m_background->Render();//开始界面的背景
	m_background1->UpdateMAatrix();//更新矩形
	m_background1->Render();       //绘制矩形
	m_player->BulletRend();
	m_player->UpdateMAatrix();     //更新玩家的矩形区域
	m_player->Render();            //绘制玩家
	m_Enemy->UpdateMAatrix();      //更新矩阵
	m_Enemy->Render();             //绘制敌方
	m_map->Render();               //绘制地图

	
	/*m_test->Render();
	g_pLine->Begin();
	for (int i = 0; i < 600; i += 64)
	{
		D3DXVECTOR2 temp[2] = { D3DXVECTOR2(0,i) ,D3DXVECTOR2(800, i) };
		g_pLine->Draw(temp, 2, 0xffff0000);
		for (int j = 0; j < 800; j += 64)
		{
			D3DXVECTOR2 temp1[2] = { D3DXVECTOR2(j,0) ,D3DXVECTOR2(j, 600) };
			g_pLine->Draw(temp1, 2, 0xffff0000);
		}
	}
	g_pLine->End();
	plane->Render();*/
	
	//CBulletManager::GetInstance()->Render();
	//CEnemyManager::GetInstance()->Render();
	//plane->Render();
}

scene

#include "stdafx.h"



CSceneManager::CSceneManager()
{
	NeedInit = false;//开始时不需初始化
}


CSceneManager::~CSceneManager()
{
}

void CSceneManager::AddScene(TSTRING name, CScene* scene)
{
	map<TSTRING, CScene*>::iterator it = SceneList.find(name);
	if (it != SceneList.end())
	{

		return;
	}
		
	SceneList[name] = scene;
}
void CSceneManager::RemoveScene(TSTRING name)
{
	map<TSTRING, CScene*>::iterator it = SceneList.find(name);
	if (it != SceneList.end())
	{
		return;
	}
	delete it->second;
	SceneList.erase(it);

}
CScene* CSceneManager::GetCurScene()
{
	map<TSTRING, CScene*>::iterator it = SceneList.find(CurSceneName);
	return it->second;
}

void CSceneManager::SetCurSceneName(TSTRING name)
{
	CurSceneName = name;
}

TSTRING CSceneManager::GetCurSceneName()
{
	return CurSceneName;
}

二、工具：utility

#include "stdafx.h"
#include "Utility.h"

CUtility::CUtility()
{
}


CUtility::~CUtility()
{
}

wchar_t* CUtility::CU_A2U(const char* c)
{
	wchar_t* m_wchar = NULL;
	int len = MultiByteToWideChar(CP_ACP, 0, c, strlen(c), NULL, 0);
	m_wchar = new wchar_t[len + 1];
	MultiByteToWideChar(CP_ACP, 0, c, strlen(c), m_wchar, len);
	m_wchar[len] = '\0';
	return m_wchar;
}

char* CUtility::CU_U2A(const wchar_t* wc)
{
	char *m_char = NULL;
	int len = WideCharToMultiByte(CP_ACP, 0, wc, wcslen(wc), NULL, 0, NULL, NULL);
	m_char = new char[len + 1];
	WideCharToMultiByte(CP_ACP, 0, wc, wcslen(wc), m_char, len, NULL, NULL);
	m_char[len] = '\0';
	return m_char;
}

bool CUtility::CollisionDetection(float x1, float y1, float w1, float h1, float x2, float y2, float w2, float h2)
{
	if (x1 + w1 < x2 || x2 + w2 < x1 || y1 + h1 < y2 || y2 + h2 < y1)
		return false;
	else
		return true;
}

三、精灵

#include "stdafx.h"

CSprite::CSprite()
{
	LPDIRECT3DDEVICE9 pDevice = nullptr;
	pDevice = (LPDIRECT3DDEVICE9)CGameManager::GetInstance()->GetDevice();
	D3DXCreateSprite(pDevice, &m_pSprite);
	
	m_nCurFrame=0;
	m_nCount = 0;
	m_sDesPos = { 0,0,0 };
	m_sSpeed = { 0,0,0 };
	m_sWorldPos = { 0,0,0 };
	m_nLayer = 0;
	m_nShowWidth=100;
	m_nShowHeight=100;
	m_nTransparency = 0xFF;
	m_nRGBColor = 0x00FFFFFF;
	m_center = { 0,0,0 };
	m_xScale = 1;
	m_yScale = 1;
	m_angle = 0;
	m_nAnimationSpeedCount = 0;
	m_curAnimation = _T("");
	m_bIsVisible = true;
	m_bIsActive = true;
	m_bMonoPlayStart = false;
	m_bMonoPlayFinish = false;
	m_nWindowWidth = 800;
	m_nWindowHeight = 600;
	D3DXMatrixIdentity(&matMatrix);

}

void CSprite::Render()
{
	if (m_bIsVisible==true)
	{
		ShowFrame(m_curAnimation);
	}
	
}

void CSprite::Update()
{
	m_pAnimation[m_curAnimation]->Update();
	
	//m_nCurFrame++;
	//if (m_nCurFrame >=m_pAnimation[m_curAnimation]->GetCountFrame())
	//{
	//	m_nCurFrame = 0;
	//}
	更新矩阵
	//UpdateMAatrix();
}

void CSprite::ShowFrame(TSTRING animationName)
{
	//根据世界坐标，确定屏幕显示位置
	/*if (m_pMapPtr != nullptr)
	{
		m_sDesPos.x = m_sWorldPos.x + m_pMapPtr->GetRelativePosToScreen().x;
		m_sDesPos.y = m_sWorldPos.y + m_pMapPtr->GetRelativePosToScreen().y;
	}*/
	
	//更新矩阵
	//UpdateMAatrix();

	确定显示图片大小
	/*m_nShowWidth = m_pAnimation[animationName]->GetWidth(m_nCurFrame);
	m_nShowHeight = m_pAnimation[animationName]->GetHeight(m_nCurFrame);
	int srcPosX = m_pAnimation[animationName]->GetOffSetX(m_nCurFrame);
	int srcPosY = m_pAnimation[animationName]->GetOffSetY(m_nCurFrame);
	RECT rect = { srcPosX, srcPosY, srcPosX + m_nShowWidth, srcPosY + m_nShowHeight };*/

	//开始绘制
	m_pSprite->Begin(D3DXSPRITE_ALPHABLEND);

	//播放当前帧
	RECT rct = m_pAnimation[animationName]->GetCurFrame()->GetRect();//动画矩形区域
	m_pSprite->Draw(m_pAnimation[animationName]->GetCurFrame()->GetTexture(), &rct, &m_center,0,  0xffffffff);
	

	m_pSprite->End();
	
}

void CSprite::LoopPlayAnimation(TSTRING animationName,int speed)
{

	if (m_bIsVisible == true)
	{
		m_nAnimationSpeedCount++;
		if (m_nAnimationSpeedCount%speed == 0)
		{
			m_nCurFrame++;
			if (m_nCurFrame >= m_pAnimation[animationName]->Frame)
			{
				m_nCurFrame = 0;
			}
			m_nAnimationSpeedCount = 0;
		}
		ShowFrame(animationName);
	}
}

void CSprite::ResetMonoPlay()
{
	m_bMonoPlayStart = false;
	m_bMonoPlayFinish = false;
}

void CSprite::PlayAnimation(TSTRING animationName)
{
	if (m_bIsVisible == true)
	{
		if (m_bMonoPlayStart == false)
		{
			m_nCurFrame = 0;
			m_bMonoPlayStart = true;
			m_bMonoPlayFinish = false;
		}
		if (m_bMonoPlayStart == true && m_bMonoPlayFinish == false)
		{
			m_nCurFrame++;
			if (m_nCurFrame >= m_pAnimation[animationName]->Frame)
			{
				m_bMonoPlayFinish = true;
				m_nCurFrame = m_pAnimation[animationName]->Frame - 1;
			}
		}
		ShowFrame(animationName);
	}
}

void CSprite::Init(TSTRING animationName)
{
	m_pAnimation[animationName]= CResManager::GetInstance()->GetAnimation(animationName);
	m_curAnimation = animationName;
	m_pAnimation[animationName]->PlayAnimation();
	/*m_nShowHeight = m_pAnimation[animationName]->GetHeight();
	m_nShowWidth = m_pAnimation[animationName]->GetWidth();
	m_sCollideRect = { 0,0,m_nShowWidth ,m_nShowHeight };*/
	
}

void CSprite::Init(vector<TSTRING> &animationName)
{
	for (int i = 0; i < animationName.size(); i++)
	{
		m_pAnimation[animationName[i]] = CResManager::GetInstance()->GetAnimation(animationName[i]);
	}
	m_curAnimation = animationName[0];
	/*m_nShowHeight = m_pAnimation[animationName[0]]->GetHeight();
	m_nShowWidth = m_pAnimation[animationName[0]]->GetWidth();*/
	//m_sCollideRect = { 0,0,m_nShowWidth ,m_nShowHeight };
}

void CSprite::SetCurAnimation(TSTRING animation)
{
	m_curAnimation = animation;

}

void CSprite::SetCurFrame(int frame)
{
	m_nCurFrame = frame;
}

void CSprite::SetSrcPos(D3DXVECTOR3 desPos)
{
	m_sSrcPos = desPos;
}

void CSprite::SetDesPos(D3DXVECTOR3 desPos)
{
	m_sDesPos = desPos;
}

void CSprite::SetWorldPos(D3DXVECTOR3 worldPos)
{
	m_sWorldPos = worldPos;
}

void CSprite::SetCollideRect(RECT collideRect)
{
	m_sCollideRect = collideRect;
}

RECT CSprite::GetCollideRect()
{
	RECT collideRect;

	float width = m_sCollideRect.right - m_sCollideRect.left;
	float height = m_sCollideRect.bottom - m_sCollideRect.top;


	collideRect.left = m_sCollideRect.left*m_xScale + m_sWorldPos.x - m_center.x;
	collideRect.right = collideRect.left + width*m_xScale;
	collideRect.top = m_sCollideRect.top*m_yScale + m_sWorldPos.y - m_center.y;
	collideRect.bottom = collideRect.top + height*m_yScale;
	return collideRect;
}

void CSprite::SetShowWidth(int showWidth)
{
	m_nShowWidth = showWidth;
}

void CSprite::SetShowHeight(int showHeight)
{
	m_nShowHeight = showHeight;
}

void CSprite::SetCenter(D3DXVECTOR3 center)
{
	m_center = center;
}

void CSprite::SetTransparent(int transpatency)
{
	m_nTransparency = transpatency;
}

void CSprite::SetShowColor(int showColor)
{
	m_nRGBColor = showColor;
}

void CSprite::UpdateMAatrix()
{
	//放缩图片
	D3DXMatrixScaling(&scaleMatrix, 1, m_yScale, 0);
	//旋转图片
	D3DXMatrixRotationZ(&rotateMatrix, m_angle);
	// 平移图片到我们的指定位置
	D3DXMatrixTranslation(&translateMatrix, m_sDesPos.x, m_sDesPos.y, 0);
	//综合矩阵
	matMatrix = scaleMatrix*rotateMatrix*translateMatrix;
	m_pSprite->SetTransform(&matMatrix);
}

void CSprite::SetXScale(float xScale)
{
	m_xScale = xScale;
}

void CSprite::SetYScale(float yScale)
{
	m_yScale = yScale;
}

void CSprite::SetAngle(float angle)
{
	m_angle = angle;
}

void CSprite::SetTurrnSpeed(float turnspeed)
{
	m_turnspeed = turnspeed;
}

D3DXVECTOR3 CSprite::GetSpeed()
{
	return m_sSpeed;
}

void CSprite::SetSpeed(float x,float y,float z)
{
	m_sSpeed.x = x;
	m_sSpeed.y = y;
	m_sSpeed.z = z;
}
VOID CSprite::SetTexture(LPDIRECT3DTEXTURE9 _tex)
{
	Texture = _tex;
}

四、输入管理

#pragma once
#include "stdafx.h"
#include "DirectInput.h"

#define SAFE_RELEASE(p) {if(p) {(p)->Release(); (p) = NULL;}}  
//添加库文件  
#pragma comment(lib, "dinput8.lib")  
#pragma comment(lib, "dxguid.lib")  
CDirectInput::CDirectInput(void)
{
	//赋初值  
	m_pDirectInput = NULL;
	m_KeyboardDevice = NULL;
	m_MouseDevice = NULL;

	ZeroMemory(m_keyBuffer, sizeof(m_keyBuffer));
	ZeroMemory(&m_MouseState, sizeof(m_MouseState));
}
CDirectInput::~CDirectInput(void)
{
	//释放对象  
	if (m_KeyboardDevice)
		m_KeyboardDevice->Unacquire();
	if (m_MouseDevice)
		m_MouseDevice->Unacquire();
	SAFE_RELEASE(m_MouseDevice);
	SAFE_RELEASE(m_KeyboardDevice);
	SAFE_RELEASE(m_pDirectInput);
}

HRESULT CDirectInput::Init(HWND hWnd, HINSTANCE hInstance, DWORD keyboardCoopFlags, DWORD mouseCoopFlags)
{
	//初始化接口对象  
	DirectInput8Create(
		hInstance,                  //程序实例的句柄  
		DIRECTINPUT_VERSION,        //0x0800当前使用的DirectInput版本号  
		IID_IDirectInput8,          //接口标识，使用IID_IDirectInput8即可  
		(void**)&m_pDirectInput,    //创建的接口的对象的指针  
		NULL);                      //COM对象相关联参数，为NULL  
	//初始化键盘设备  
	m_pDirectInput->CreateDevice(       //创建设备  
		GUID_SysKeyboard,              //GUID值，对于鼠标和键盘有宏定义，其余设备需要通过枚举找出  
		&m_KeyboardDevice,             //键盘设备指针的指针  
		NULL);                           //COM相关参数，为NULL  
	m_KeyboardDevice->SetCooperativeLevel(//设置协作级别  
		hWnd,                              //窗口句柄  
		keyboardCoopFlags);                  //协作级别（前台后台，独占非独占）  
	m_KeyboardDevice->SetDataFormat(        //设置数据格式  
		&c_dfDIKeyboard);                  //键盘鼠标等的数据格式，宏定义  
	m_KeyboardDevice->Acquire();            //获得设备控制权  
	m_KeyboardDevice->Poll();               //轮询设备  
	//初始化鼠标设备  
	m_pDirectInput->CreateDevice(GUID_SysMouse, &m_MouseDevice, NULL);
	m_MouseDevice->SetCooperativeLevel(hWnd, mouseCoopFlags);
	m_MouseDevice->SetDataFormat(&c_dfDIMouse);
	m_MouseDevice->Acquire();
	m_MouseDevice->Poll();
	m_hWnd = hWnd;
	return true;
}

void CDirectInput::GetInput()
{
	//将上一次的按键信息更新
	memcpy(m_keyBufferlast, m_keyBuffer, 256);
	//获得键盘输入消息  
	HRESULT hr = m_KeyboardDevice->GetDeviceState(sizeof(m_keyBuffer), (void**)&m_keyBuffer);
	if (FAILED(hr))//如果失败尝试重新获取
	{
		m_KeyboardDevice->Acquire();//获取键盘控制
		m_KeyboardDevice->GetDeviceState(sizeof(m_keyBuffer), (void**)&m_keyBuffer);
	}

	//将上一次的鼠标信息更新
	memcpy(&m_MouseLastState, &m_MouseState, sizeof(m_MouseState));
	//获得鼠标输入信息  
	hr = m_MouseDevice->GetDeviceState(sizeof(m_MouseState), (void**)&m_MouseState);
	if (FAILED(hr))//如果失败尝试重新获取
	{
		m_MouseDevice->Acquire();//获取鼠标控制
		m_MouseDevice->GetDeviceState(sizeof(m_MouseState), (void**)&m_MouseState);
	}
}

bool CDirectInput::IsKeyCurrentDown(int iKey)
{
	if (((m_keyBuffer[iKey] & 0x80) != 0) && ((m_keyBufferlast[iKey] & 0x80) == 0))
		return true;
	return false;
}
bool CDirectInput::IsKeyHold(int iKey)
{
	if (m_keyBuffer[iKey] & 0x80)
		return true;
	return false;
}
bool CDirectInput::IsKeyCurrentUp(int iKey)
{
	if (((m_keyBuffer[iKey] & 0x80) == 0) && ((m_keyBufferlast[iKey] & 0x80) != 0))
		return true;
	return false;
}
bool CDirectInput::IsKeyUp(int iKey)
{
	if (((m_keyBuffer[iKey] & 0x80) == 0) && ((m_keyBufferlast[iKey] & 0x80) == 0))
		return true;
	return false;
}

bool CDirectInput::IsMouseButtonCurrentDown(int iButton)
{
	if (((m_MouseState.rgbButtons[iButton] & 0x80) != 0) && (m_MouseLastState.rgbButtons[iButton] & 0x80) == 0)
		return true;
	return false;
}
bool CDirectInput::IsMouseButtonHold(int iButton)
{
	return (m_MouseState.rgbButtons[iButton] & 0x80) != 0;
}
bool CDirectInput::IsMouseButtonCurrentUp(int iButton)
{
	if (((m_MouseState.rgbButtons[iButton] & 0x80) == 0) && (m_MouseLastState.rgbButtons[iButton] & 0x80) != 0)
		return true;
	return false;
}
bool CDirectInput::IsMouseButtonUp(int iButton)
{
	if (((m_MouseState.rgbButtons[iButton] & 0x80) == 0) && (m_MouseLastState.rgbButtons[iButton] & 0x80) == 0)
		return true;
	return false;
}

float CDirectInput::MouseX()
{
	POINT pos;
	GetCursorPos(&pos);
	ScreenToClient(m_hWnd, &pos);
	return pos.x;
}

float CDirectInput::MouseY()
{
	POINT pos;
	GetCursorPos(&pos);
	ScreenToClient(m_hWnd, &pos);
	return pos.y;
}
void CDirectInput::MousePosition(LPPOINT pos)
{
	GetCursorPos(pos);
	ScreenToClient(m_hWnd, pos);
}

float CDirectInput::MouseDX()
{
	return (float)m_MouseState.lX;
}

float CDirectInput::MouseDY()
{
	return (float)m_MouseState.lY;
}

float CDirectInput::MouseDZ()
{
	return (float)m_MouseState.lZ;
}

五、游戏管理

#include "stdafx.h"


CGameManager::CGameManager(){}

CGameManager::~CGameManager(){}

IDirect3DDevice9* CGameManager::GetDevice() { return D3DDevice; }

void CGameManager::Init(HWND hWnd)
{
	Direct3D = Direct3DCreate9(D3D_SDK_VERSION);       //Direct3DCreate9 的惟一一个参数用于传入创建的DirectX接口的版本信息，  
	D3DPRESENT_PARAMETERS d3dpp;                       //定义双缓冲的后台参数
	ZeroMemory(&d3dpp, sizeof(d3dpp));                 //设置其他成员为默认值
	d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;          //后台缓冲的像素格式，32真彩色
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;          //交换模式，设置后台缓冲和前台缓冲之间的交换模式
	d3dpp.Windowed = true;                             //是否窗口显示，false为全屏
	Direct3D->CreateDevice(D3DADAPTER_DEFAULT          //指定对象要表示的物理显示设备（显卡）
		, D3DDEVTYPE_HAL                               //Direct3D设备的类型(三种,当前为硬件类型)
		, hWnd,                                        //窗口句柄 
		D3DCREATE_HARDWARE_VERTEXPROCESSING            //Direct3D设备进行3D运算的部分方式
		, &d3dpp                                       //&d3dpp:指向一个已经初始化的D3DPRESENT_PARAMETERS对象的地址
		, &D3DDevice);                                 //&g_pDevice:返回创建的IDirect3DDevice9接口指针
	/*CLog::GetInstance()->Init();*/                   //日志
	g_DXInput.Init(hWnd, hInst,
		DISCL_FOREGROUND | DISCL_NONEXCLUSIVE,	       //协作级别（前台后台，独占非独占）  
		DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);        //协作级别（前台后台，独占非独占）  
	//XML加载图片信息
	CResManager::GetInstance()->LoadPictureFromFile(_T("../bin/data/gamepicture.xml"));
	//XML加载动画信息
	CResManager::GetInstance()->LoadAnimationFromFile(_T("../bin/data/gameanimation.xml"));
	//开始场景初始化
	beginscene = new CBeginScene;
	beginscene->Init();
	CSceneManager::GetInstance()->AddScene(_T("beginscene"), beginscene);
    //游戏场景初始化
	gamescene = new CGameScene;
	gamescene->Init();
	CSceneManager::GetInstance()->AddScene(_T("gamescene"), gamescene);

	//设定初始场景为beginscene开始场景
	CSceneManager::GetInstance()->SetCurSceneName(_T("beginscene"));
	

	//通过设备接口，创建线条接口
	/*D3DXCreateLine(D3DDevice, &g_pLine);*/
	/*CLog::GetInstance()->SetText(_T("初始化完成"));*/       //日志
}

void CGameManager::Render()
{                                                          //背景色
	D3DDevice->Clear((unsigned long)0, 0, D3DCLEAR_TARGET, 0xfffffffff, 1.0f, (unsigned long) 0.0);//清屏刷新
	D3DDevice->BeginScene();//通知设备接口开始进行图形渲染工作
	//采用当前场景进行绘制
	CSceneManager::GetInstance()->GetCurScene()->Render();//进行场景绘制
	/*CLog::GetInstance()->ShowLog();*/       //日志
	D3DDevice->EndScene();//通知Direct3D设备结束图形渲染工作 
	D3DDevice->Present(NULL, 0, 0, 0);//屏幕翻转，实现双缓冲逻辑，后台向前台更新
}

void CGameManager::Update()
{
	//采用当前场景进行更新
	g_DXInput.GetInput();		//获取输入事件
	CSceneManager::GetInstance()->GetCurScene()->Update();//场景里的更新
}

void CGameManager::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	
}

六、源文件

#include "stdafx.h"
#include "CEnemyManager.h"


CEnemyManager::CEnemyManager()
{
}


CEnemyManager::~CEnemyManager()
{
}

//新版本.cpp: 定义应用程序的入口点。
//

#include "stdafx.h"
#include "新版本.h"

#define MAX_LOADSTRING 100

// 全局变量: 
HWND g_hWnd;
CDirectInput g_DXInput;
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名

// 此代码模块中包含的函数的前向声明: 
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: 在此放置代码。

    // 初始化全局字符串
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_MY, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化: 
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MY));
	CGameManager::GetInstance()->Init(g_hWnd);                //游戏管理有所有场景的初始化
    MSG msg;
	ZeroMemory(&msg, sizeof(msg));
	
    // 主消息循环: 
	while (msg.message != WM_QUIT)
	{
		if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			static DWORD preTime = GetTickCount();
			DWORD curTime = GetTickCount();
			float elapsedTime = (curTime - preTime)*0.001f;		//换算成秒
			if (elapsedTime >= 1.0f / 60)						//每秒60帧
			{
				CGameManager::GetInstance()->Update();              //游戏管理的更新
				CGameManager::GetInstance()->Render();              //渲染
				preTime = curTime; 
			}
			else
				Sleep(1);
		}
	}
	UnregisterClass(szWindowClass, hInst);

	return (int)msg.wParam;
}



//
//  函数: MyRegisterClass()
//
//  目的: 注册窗口类。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MY));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_MY);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   函数: InitInstance(HINSTANCE, int)
//
//   目的: 保存实例句柄并创建主窗口
//
//   注释: 
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // 将实例句柄存储在全局变量中
   int nX = GetSystemMetrics(SM_CXFRAME) * 2;
   int nY = GetSystemMetrics(SM_CYFRAME) * 2 + GetSystemMetrics(SM_CYCAPTION);
   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
     200, 0, 715+nX, 450+nY, nullptr, nullptr, hInstance, nullptr);      //窗口的大小
   g_hWnd = hWnd;
   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目的:    处理主窗口的消息。
//
//  WM_COMMAND  - 处理应用程序菜单
//  WM_PAINT    - 绘制主窗口
//  WM_DESTROY  - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // 分析菜单选择: 
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: 在此处添加使用 hdc 的任何绘图代码...
            EndPaint(hWnd, &ps);
        }
        break;
	case WM_KEYDOWN:
	{
		switch (wParam)
		{
		case VK_ESCAPE:
			SendMessage(hWnd, WM_CLOSE, 0, 0);
			break;
		default:
			break;
		}
	}
	break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

// stdafx.cpp : 只包括标准包含文件的源文件
// 新版本.pch 将作为预编译标头
// stdafx.obj 将包含预编译类型信息

#include "stdafx.h"

// TODO: 在 STDAFX.H 中引用任何所需的附加头文件，
//而不是在此文件中引用

七、资源管理

1、动画

#include "stdafx.h"
#include "Animation.h"

CAnimation::CAnimation(TSTRING name,int frame)
{
	Name = name;
	Frame = frame;
	m_PreTime = 0;
}

CAnimation::~CAnimation()
{
	
}

void CAnimation::PlayAnimation()
{
	m_PreTime = GetTickCount();
	m_bIsplaying = true;
	m_curFrame = 0;
	m_bLoop = true;
}

void CAnimation::Update()
{
	if (!m_bIsplaying)
		return;
	DWORD curTime = GetTickCount();
	if ((curTime - m_PreTime)*0.001f < m_fTime)
		return;
	m_PreTime = GetTickCount();
	++m_curFrame;
	if (m_bLoop)
		m_curFrame %= Frame;
	else if (m_curFrame >= Frame)
	{
		//停止播放动画
		m_bIsplaying = false;
	}
}

2、动画帧

#include "stdafx.h"



CAnimationFrame::CAnimationFrame(TSTRING name, LPDIRECT3DTEXTURE9 texture, RECT rect)
{
	Name = name;
	Texture = texture;
	Rect = rect;
}


CAnimationFrame::~CAnimationFrame()
{
}

RECT CAnimationFrame::GetRect()
{
	return Rect;
}

LPDIRECT3DTEXTURE9 CAnimationFrame::GetTexture()
{
	return Texture;
}

3、照片

#include "stdafx.h"


CPicture::CPicture(TSTRING name, TSTRING path, D3DCOLOR color)
{
	Name = name;
	Path = path;
	Path += Name;
	LPDIRECT3DDEVICE9 pDev = (LPDIRECT3DDEVICE9)CGameManager::GetInstance()->GetDevice();
	D3DXCreateTextureFromFileEx(pDev, 
		
		Path.c_str(), D3DX_FROM_FILE, D3DX_FROM_FILE, D3DX_FROM_FILE, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, color, 0, 0, &Texture);
	
	D3DSURFACE_DESC desc;
	Texture->GetLevelDesc(0, &desc);
	Height = desc.Height;
	Width = desc.Width;
	m_rect = { 0, 0 , Width, Height };
}

CPicture::~CPicture() { RELEASE(Texture); }

WORD CPicture::GetHeight() { return Height; }
WORD CPicture::GetWidth() { return Width; }
LPDIRECT3DTEXTURE9 CPicture::GetTexture() { return Texture; }
RECT CPicture::GetRect() { return m_rect; }

4、资源管理

#include "stdafx.h"


CResManager::CResManager(){}

CResManager::~CResManager()
{
	map<TSTRING, CPicture*>::iterator it1 = picture.begin();
	for (; it1 != picture.end(); it1++)
		delete it1->second;
	picture.clear();

	map<TSTRING, CAnimationFrame*>::iterator it2 = frame.begin();
	for (; it2 != frame.end(); it2++)
		delete it2->second;
	frame.clear();

	map<TSTRING, CAnimation*>::iterator it3 = animation.begin();
	for (; it3 != animation.end(); it2++)
		delete it3->second;
	animation.clear();
}

void CResManager::LoadPictureFromFile(TSTRING fileName)
{
#ifdef UNICODE
	char*file = CUtility::CU_U2A(fileName.c_str());       //从xml文件中读取图片内容
#else
	const char*file = fileName.c_str();
#endif
	TiXmlDocument* doc = new TiXmlDocument(file);
	doc->LoadFile();
	TiXmlElement* root = doc->FirstChildElement("Root");
	TiXmlElement* element = root->FirstChildElement();

	while (element)
	{
#ifdef UNICODE
		wchar_t* name;
		name = CUtility::CU_A2U(element->Attribute("name"));
		wchar_t* path;
		path = CUtility::CU_A2U(element->Attribute("path"));
#else
		const char*name = element->Attribute("name");
		const char*path = element->Attribute("path");
#endif
		CPicture* Picture = new CPicture(name, path,0xffffffff);
		AddPicture(name, Picture);//将图片存入容器

		//生成帧信息
		int row; element->Attribute("row", &row);
		int col; element->Attribute("col", &col);

		int Height = Picture->GetHeight();
		int Width = Picture->GetWidth();

		int FrameHeight = Height / row;
		int FrameWidth = Width / col;

		int count = 0;

		for (int i = 0; i < row; i++)
		{
			for (int j = 0; j < col; j++)
			{
				RECT rect =
				{
					j*FrameWidth,
					i*FrameHeight,
					(j + 1)*FrameWidth,
					(i + 1)*FrameHeight
				};

				char temp[200];
#ifdef UNICODE
				sprintf_s(temp, 200, "%s%d", CUtility::CU_U2A(name), count++);
#else
				sprintf_s(temp, 200, "%s%d", name, count++);
#endif
				wchar_t* framename = CUtility::CU_A2U(temp);
				//CLog::GetInstance()->SetText(framename);
				CAnimationFrame* Frame = new CAnimationFrame(framename, Picture->GetTexture(), rect);
				AddAnimationFrame(framename, Frame);//将帧信息存入容器
			}
		}
		element = element->NextSiblingElement();
	}
	delete doc;
}

void CResManager::LoadAnimationFromFile(TSTRING fileName)
{
#ifdef UNICODE
	char*file = CUtility::CU_U2A(fileName.c_str());       //从xml文件中读取动画所需的帧信息
#else
	const char*file = fileName.c_str();
#endif
	TiXmlDocument* doc = new TiXmlDocument(file);
	doc->LoadFile();
	TiXmlElement* root = doc->FirstChildElement();
	TiXmlElement* element = root->FirstChildElement();

	while (element)
	{
#ifdef UNICODE
			wchar_t* name;
			name = CUtility::CU_A2U(element->Attribute("name"));
#else
			const char*name = element->Attribute("name");
#endif
			int frame; element->Attribute("frame", &frame);

			CAnimation* Animation = new CAnimation(name, frame);//创建动画（动画名称，帧数）

			TiXmlElement* frameelement = element->FirstChildElement();//将动画所需的帧信息进行输入
			while (frameelement)
			{
#ifdef UNICODE
				wchar_t* framename;
				framename = CUtility::CU_A2U(frameelement->Attribute("framename"));
#else
				const char*framename = element->Attribute("framename");
#endif
				CAnimationFrame* Frame = CResManager::GetInstance()->GetAnimationFrame(framename);
				Animation->FrameList.push_back(Frame);

				frameelement = frameelement->NextSiblingElement();
			}

			AddAnimation(name, Animation);
		
			element = element->NextSiblingElement();
		}
	delete doc;
}

void CResManager::AddPicture(TSTRING name, CPicture* pic)
{
	picture[name] = pic;
}

CPicture* CResManager::GetPicture(TSTRING name)
{
	map<TSTRING, CPicture*>::iterator it = picture.find(name);
	if (it != picture.end())
		return it->second;
	return nullptr;
}


void CResManager::AddAnimation(TSTRING animationName, CAnimation* ani)
{
	animation[animationName] = ani;
}

CAnimation * CResManager::GetAnimation(TSTRING animationName)
{
	map<TSTRING, CAnimation*>::iterator iter = animation.find(animationName);
	if (iter != animation.end())
		return iter->second;
	return nullptr;
}


void CResManager::AddAnimationFrame(TSTRING framename, CAnimationFrame* animationframe)
{
	frame[framename] = animationframe;
}

CAnimationFrame* CResManager::GetAnimationFrame(TSTRING animationName)
{
	map<TSTRING, CAnimationFrame*>::iterator iter = frame.find(animationName);
	if (iter != frame.end())
		return iter->second;
	return nullptr;
}

大家可以进来我的一个学习圈【806041599】一起学习交流，完整源码也是在这个群里领取。有一些资料可以帮助大家更好的学习，在学习C语言的过程中遇到任何的问题，都可以发出来一起讨论，大家都是学习C/C++的，或是转行，或是大学生，还有工作中想提升自己能力的前端党，如果你是正在学习C/C++的小伙伴可以加入学习。点击链接加入群聊【C语言/C++互助学习群】https://jq.qq.com/?_wv=1027&k=6kWMsB6V

空弦的编程小屋

关注

5
点赞
踩
46

收藏

觉得还不错? 一键收藏
0
评论
C语言项目实战—坦克大战

闲暇时间写的一个坦克大战，有些功能还没完善，但是给新手参考学习还是不错的。先看看效果图：看看各部分代码吧一、场景管理1、背景#include "stdafx.h"CBackGround::CBackGround(TSTRING name){CPicture*_pPic= CResManager::GetInstance()->GetPicture(name); if (_pPic==nullptr) { assert (_T("pic is nul..
复制链接

扫一扫