FunCode程序设计实验教材系列
C++面向对象课程设计
实验指南
课程设计三 太空战机
一、游戏介绍
太空战机是玩家用键盘控制战机移动并发射子弹，消灭敌方的战机。敌方战机从右到左移动，同时上下浮动。
二、实验目的
综合应用C++语言和面向对象的知识开发一款小游戏。
三、实验内容
在外星球上，玩家通过键盘WSAD键控制己方战机，消灭外星球的邪恶战机。
要求如下：
1、 游戏运行时，初始界面如下图。
2、 按下空格键，游戏开始，玩家通过WSAD键控制己方战机移动；己方战机不能超出世界边界。
3、 玩家战机每隔0.3秒发射一发子弹；
4、 添加敌方战机，每隔5秒创建一架敌方战机；
5、 敌方战机每隔3秒发射一发子弹；
6、 记录游戏的最高分。
游戏初始界面
四、实验指南
实验一 游戏开始和控制我方战机移动
【实验内容】
1、 按空格键，游戏开始，“空格开始”字样消失。
2、 创建CMyFighter类，并创建对象实例玩家控制的战机。
3、 战机碰到世界边界时，静止。
4、 游戏开始后，通过键盘WSAD键控制战机移动。
5、 战机左右运动的速度为30，上下运动的速度为15。
6、 在游戏中显示游戏的当前积分和最高积分。
【实验思路】
按空格键开始游戏，属于键盘按下事件，我们在OnKeyDown函数中编写代码。
在游戏中，我们运用面向对象的知识将战机看成一个对象，并为这个对象添加一个类叫CMyFighter。类具有属性和方法，要控制战机能在各个方向上自由的游动，我们为CMyFighter类添加上下左右四个方向的速度，并且我们为战机添加OnMove方法控制战机的游动状态。
【实验指导】
1、 在CGameMain中定义类成员变量：
CSprite* m_pBeginSprite ; //GameBegin为“空格开始”精灵 CTextSprite* m_pCurScoreText;//显示当前积分 CTextSprite* m_pMaxScoreText;// 显示最高分
2、 在CGameMain类的构造函数中添加代码，对变量进行初始化。
m_pBeginSprite = new CSprite("GameBegin");
m_pCurScoreText = new CTextSprite("CurScoreText");
m_pMaxScoreText = new CTextSprite("MaxScoreText");
3、 在OnKeyDown中，当按下的按键为空格键并且此时的游戏状态为0,则设置游戏的状态为1。0表示此时游戏为等待状态，未开始。1表示游戏进行初始化，2表示初始化后会进入游戏运行状态。
// 按下空格，游戏开始
if( KEY_SPACE == iKey && 0 == GetGameState() )
{
SetGameState( 1 );
}
4、 在游戏初始化函数GameInit中隐藏 "按空格开始游戏"图片。
m_pBeginSprite->SetSpriteVisible( false );
5、 通过类向导创建CMyFighter类，其继承于CSprite类。以VC++ 6.0为例：
第一步、点击菜单“插入”–〉“新建类”。
第二步、在“New Class”对话框中输入类名和父类名。
第三步、点击“更改”按钮，在新对话框中修改CMyFighter类的头文件和cpp文件的路径。将头文件保存到项目文件夹的\SourceCode\Header文件夹中，将cpp文件保存到项目文件夹下的\SourceCode\Src文件夹中。
这里需要特别注意的是创建文件路径的问题，所有的.h头文件应该在项目文件夹\SourceCode\Header中，所有的.cpp源文件应该放在项目文件夹下的\SourceCode\Src文件夹中。
（1）CMyFighter的父类是CSprite类（具体声明查看CommonClass.h），构造函数为CSprite( const char *szName )。
在MyFighter.cpp的首部包含“CommonClass.h”。
将系统自动生成构造函数CMyFighter()改为：
CMyFighter (const char* szName)。
CMyFighter:: CMyFighter (const char* szName):CSprite(szName) //对构造函数进行实现
{
}
子类对象创建时，要先调用父类的构造函数完成父类部分的构造。如果父类没有默认构造函数，子类的构造函数必须显示调用父类的构造函数。CMyFighter构造函数调用CSprite类构造函数，并将参数szName的值传递给它，从而将名称为szName的精灵图片与CMyFighter对象绑定起来。
（2）为CMyFighter类添加m_fVelocityLeft，m_fVelocityRight，m_fVelocityUp，m_fVelocityDown四个成员变量，分别表示飞机上下左右的速度，权限为private。
本文档的命名采用匈牙利命名法，m_表示类成员变量，i表示整型，f表示float型，sz表示字符指针，g_表示全局变量等。
6、 在CMyFighter类的构造函数中，首先初始化4个方向的速度为0。
m_fVelocityLeft = 0.f; m_fVelocityRight = 0.f; m_fVelocityUp = 0.f; m_fVelocityDown = 0.f;
7、 添加成员函数OnMove控制战机的游动，其参数bKeyDown表示键盘按键是否按下，iKey表示相应的是哪个按键。
void OnMove(bool bKeyDown, int iKey);
8、 编写CMyFighter类OnMove方法代码。首先判断当前按键是按下还是松开的，其次判断是哪个按键的消息，根据这两个判断，为4个方向的速度矢量赋值。再次算出X后和Y轴上的速度，并设置战机的速度。
void CMyFighter::OnMove(bool bKeyDown, int iKey)
{
if(bKeyDown)
{
switch(iKey)
{
case KEY_A: // 左
m_fVelocityLeft = 30.f;
break;
case KEY_D: // 右
m_fVelocityRight = 30.f;
break;
case KEY_W: // 上
m_fVelocityUp = 15.f;
break;
case KEY_S: // 下
m_fVelocityDown = 15.f;
break;
}
}
else
{
switch(iKey)
{
case KEY_A: // 左
m_fVelocityLeft = 0.f;
break;
case KEY_D: // 右
m_fVelocityRight = 0.f;
break;
case KEY_W: // 上
m_fVelocityUp = 0.f;
break;
case KEY_S: // 下
m_fVelocityDown = 0.f;
break;
}
}
float fVelX = m_fVelocityRight - m_fVelocityLeft;
float fVelY = m_fVelocityDown - m_fVelocityUp;
SetSpriteLinearVelocity( fVelX,fVelY );
}
9、 在CGameMain类中
（1）首先添加一个成员变量，代表玩家战机对象的指针m_pMyFighter。
CMyFighter* m_pMyFighter; //玩家战机
注意需要包含头文件：
#include "MyFighter.h"
（2）在构造函数中将m_pMyFighter赋予NULL的初始值。
（3）在GameInit方法中初始化m_pMyFighter，并设置和世界编辑的碰撞属性为WORLD_LIMIT_STICKY，当碰到世界边界时，战机静止不动。
// 创建玩家控制的Sprite
if( NULL == m_pMyFighter )
{
m_pMyFighter = new CMyFighter("ControlSprite");
m_pMyFighter->SetSpriteWorldLimit(WORLD_LIMIT_STICKY,CSystem::GetScreenLeft()-10.f,CSystem::GetScreenTop(),CSystem::GetScreenRight(),CSystem::GetScreenBottom());
}
因为用new方法创建了m_pMyFighter对象，分配了内存，所以在CGameMain类的析构函数中需要调用delete方法将m_pMyFighter使用的内存释放掉。
10、 在OnKeyDown和OnkeyUp中响应战机OnMove方法，它们的区别只是第一个参数的值不同。下面是OnKeyDown方法中的调用。
if( 2 == GetGameState() ) //当游戏状态为2时
{
m_pMyFighter->OnMove(true,iKey);
}
在OnKeyUp中调用
if( 2 == GetGameState() )
{
m_pMyFighter->OnMove(false,iKey);
}
11、 在CGameMain类的GameInit方法中显示当前积分和最高积分（初值为0）。
m_pCurScoreText->SetTextValue(0); m_pMaxScoreText->SetTextValue(0);
实验二 添加子弹类，实现战机开炮
【实验内容】
1、 创建子弹类CBullet；
2、 通过空格键控制飞机发射子弹；
3、 当空格键按下时，飞机每隔0.3秒发射一发子弹；
【实验思路】
运用面向对象的知识，我们将游戏中的元素都看为一个对象，因此我们将子弹对象抽象为CBullet类。当子弹与世界边界碰撞时，子弹消失。
当空格键按下时飞机每隔0.3发射一发子弹，因此我们在飞机类中增加一个bool型的属性m_bCanFire，控制子弹是否发射。然后增加方法OnFire，参数为游戏循环一次的时间间隔，当时间间隔大于0.3时并且m_ bCanFire为true时，飞机发射一发子弹。飞机发射的子弹，我们在CGameMain类中进行创建。
在游戏循环的GameRun函数中调用飞机的OnFire方法，实现飞机每隔三秒发射一发子弹。
在CGameMain类中添加一个创举子弹的方法，当战机发射子弹时，调用此方法。
【实验指导】
1、 仿照创建我方战机的方法创建CBullet类；
class CBullet : public CSprite
{
public:
CBullet( const char *szName);
~CBullet();
};
2、 为CMyFighter增加控制是否发射子弹的变量，权限为private。
bool m_bCanFire;
并添加SetCanFire方法设置其值，权限为public：
void
SetCanFire( const bool bCan )
{ m_bCanFire = bCan; }
添加GetCanFire方法获取其值：
bool GetCanFire(){return m_bCanFire;}
3、 在CGameMain类中添加m_iCreatedBulletCount属性，表示游戏中发射子弹的数目注意在构造函数中初始化为0。
4、 在CGameMain类中添加CreateBullet()函数，参数为子弹的X轴和Y轴坐标。并在该方法中创建一个子弹类，并设置子弹的位置、速度、碰撞方式。因为模板子弹的方向是朝左，所以需要设置子弹翻转朝右。
void CGameMain::CreateBullet( const float fPosX, const float fPosY )
{
char szName[MAX_NAME_LEN];// MAX_NAME_LE为CommonClass.h中宏定义 值为128
sprintf( szName, "Bullet1_%d", m_iCreatedBulletCount);
m_iCreatedBulletCount++;
CBullet *pBullet = new CBullet(szName);
pBullet->CloneSprite( "Bullet1_Template" );
pBullet->SetSpritePosition( fPosX, fPosY );
pBullet->SetSpriteFlipX(true);
pBullet->SetSpriteLinearVelocityX( 60 );
pBullet->SetSpriteWorldLimit(WORLD_LIMIT_NULL,CSystem::GetScreenLeft()-10.f,CSystem::GetScreenTop(),CSystem::GetScreenRight() + 200.f, CSystem::GetScreenBottom());
pBullet->SetSpriteCollisionActive(true,true);
}
这里用到CBullet类，所以应该在LessonX.h中包含头文件：
#include"Bullet.h"
5、 在CMyFighter中添加成员变量m_fBulletCreateTime，表示子弹的发射间隔，注意在构造函数中将其初始化为0.3。
6、 在CMyFighter中添加成员函数OnFire()，处理玩家战机子弹的发射。参数为游戏的时间间隔；
// 处理子弹的发射
void CMyFighter::OnFire( float fDeltaTime )
{
m_fBulletCreateTime -= fDeltaTime;
if( m_fBulletCreateTime <= 0.f && m_bCanFire==true )
{
// 固定发射时间
m_fBulletCreateTime = 0.3f;
g_GameMain.CreateBullet(GetSpritePositionX(), GetSpritePositionY() );
}
}
这里用到了g_GameMain这个全局对象，所以在CMyFight.cpp中应该包含头文件：
#include "LessonX.h"
7、 在CGameMain类GameRun方法中，调用CMyFighter类的OnFire方法，控制玩家战机发射子弹；
void CGameMain::GameRun( float fDeltaTime )
{
// 执行我方战机的循环函数 if( m_pMyFighter ) m_pMyFighter->OnFire( fDeltaTime );
}
8、 玩家发射子弹需要有当空格键按下，设置CMyFighter的m_bCanFire值为true。在OnKeyDown方法中添加如下代码；
// 游戏进行中，按下空格发射子弹 if( 2 == GetGameState() && KEY_SPACE == iKey && NULL != m_pMyFighter ) m_pMyFighter->SetCanFire( true );
9、 同理在OnKeyUp中设置m_bCanFire值为false。
实验三 敌方战机
【实验内容】
1、 创建一个敌方战机类CEnemyFighter；
2、 战机以编辑器中HorizontalSprite_Template精灵为模板；
3、 每隔几秒创建一架敌方战机；
【实验思路】
运用面向对象知识，创建CEnemyFighter类。该类具有点方战机的属性，战机隔一定的事件被复制出来，然后上下浮动，开始向我方战机发射子弹，这样有助于增加敌方战机的杀伤力，也增加了游戏的趣味性。
【实验指导】
1、 仿照方便的方法创建CEnemyFighter类，其继承与CSprite类，修改其构造函数。
2、 为类增添两个静态变量，一个表示表示创建敌机的数量，一个表示创建敌机的时间；
static float m_fCreateTime; // 创建敌机的时间间隔 static int m_m_iCreatedEnemyCount;//表示创建战机数量
并在EnemyFighter.cpp文件最后进行初始化：
float CEnemyFighter::m_fCreateTime = 0.f; int CEnemyFighter:: m_iCreatedEnemyCount= 0;
3、 为CEnemyFighter类添加一个创建敌方战机的静态方法createEnemyFighter (float fDeltaTime)。
1）在EnemyFighter类中添加函数的声明：
void static createEnemyFighter ( float fDeltaTime );
2）其参数为游戏的时间间隔。当创建战机的时间间隔递减为0时，创建战机。并重新设置时间间隔时间为1到3秒。
void CEnemyFighter:: createEnemyFighter ( float fDeltaTime ) //创建敌方战机
{
// 是否到时间创建
m_fCreateTime -= fDeltaTime;
if( m_fCreateTime <= 0.f )
{
// 随机一个时间，作为下次出生的时间
m_fCreateTime = (float)CSystem::RandomRange( 1, 3 );
//在以下添加创建一架敌方战机的代码
……
}
}
3）从“HorizontalSprite_Template”模板创建CEnemyFighter类对象。在createEnemyFighter函数的if( m_fCreateTime <= 0.f )判断中添加以下代码：
char szName[MAX_NAME_LEN]; sprintf(szName,"HorizontalSprite_%d", m_iCreatedSpriteCount); //给新建的敌方战机起名 m_iCreatedEnemyCount++; CEnemyFighter *pSprite = new CEnemyFighter( szName ); pSprite->CloneSprite( "HorizontalSprite_Template" ); //克隆模板
4）设置敌方飞机X轴和Y轴的坐标、速度、世界边界碰撞属性、碰撞模式等。
创建战机时，只需要战机不显示在世界边界之外就可以，即Y轴坐标在比世界边界的上下边界稍微大一点的范围之间，在此我们设置比世界边界大10个世界坐标单位：
int iPosBase=CSystem::RandomRange((int)CSystem::GetScreenTop()+10,(int)CSystem::GetScreenBottom() - 10); int iRandom = CSystem::RandomRange( iPosBase - 10, iPosBase + 10 ); float fPosX = (int)CSystem::GetScreenRight() + 20.f; pSprite->SetSpritePosition( fPosX, (float)iRandom ); pSprite->SetSpriteLinearVelocityX( -10.f ); pSprite->SetSpriteWorldLimit(WORLD_LIMIT_KILL, CSystem::GetScreenLeft()-10.f,CSystem::GetScreenTop(),CSystem::GetScreenRight() + 200.f, CSystem::GetScreenBottom() ); pSprite->SetSpriteCollisionActive(true,true);
这里用到sprintf函数，所以应该在EnemyFighter.cpp中包含头文件：
#include<stdio.h>
4、 在CGameRun中，调用CEnemyFighter类的静态方法createEnemyFighter，不停地创建敌方战机。
CEnemyFighter:: createEnemyFighter ( fDeltaTime );
在LessonX.cpp中包含敌机类文件：
#include "enemyFighter.h"
实验四 敌方战机发射子弹
【实验内容】
1、 创建一个精灵链接类
2、 将生成的战机添加到链表中
3、 敌方战机每隔1秒发射一发子弹
4、 敌方战机飞行中上下浮动；
【实验思路】
因为在游戏中不断地创建子弹和战机，并有子弹和战机不断地销毁，为了有效地管理内存，这里使用链表来存储子弹和战机，并在链表中实现子弹和战机精灵的查找、删除、添加等操作。
【实验指导】
（一）子弹类的相关操作
1、 为CBullet添加一个表示该子弹是谁发射的变量。
int m_iType;
2、 在CBullet类构造函数中为此变量赋值，更改构造函数为两个参数：
CBullet::CBullet(const int iType, const char *szName) : CSprite( szName )
{
m_iType = iType;
}
3、 修改CGameMain类的CreateBullet()函数，注意同时修改函数声明。
在CreateBullet() 函数中，创建子弹对象时，传入类型变量iType，1表示敌方子弹，0表示是玩家子弹。并根据iType取值，设置子弹的前进速度和子弹头方向。
void CGameMain::CreateBullet( int iType, const float fPosX, const float fPosY )
{
……
CBullet *pBullet = new CBullet(iType, szName);
……
if( 1 == iType ) //如果iType值为1，则说明子弹为敌方战机发射。
{
pBullet->SetSpriteLinearVelocityX( -30 );
}
else//其他情况说明为我方战机反射
{
pBullet->SetSpriteFlipX( true );
pBullet->SetSpriteLinearVelocityX( 60 );
}
}
修改MyFighter.cpp中调用CreateBullet()函数的代码：
将MyFighter.cpp中的OnFire()函数中g_GameMain.CreateBullet(GetSpritePositionX(), GetSpritePositionY() );改为g_GameMain.CreateBullet(0,GetSpritePositionX(), GetSpritePositionY() ); 传入玩家子弹类型。
4、 在CBullet类中添加成员函数IsMyBullet()，利用m_iType判断子弹是否是玩家发射的。
bool CBullet::IsMyBullet()
{
return m_iType==0;
}
（二）链表类的相关操作
1、 创建一个链表类CSpriteList用来管理精灵。此类不继承CSprite类，但因链表中要保存精灵，所以仍需在文件开头声明头文件：
#include "CommonClass.h"
2、 在SpriteList.h文件的首部创建一个精灵结构体SpriteStruct（链表的结点类型）；
struct SpriteStruct
{
CSprite *pSprite;
SpriteStruct *pNext;
SpriteStruct *pPrev;
};
3、 为链表类CSpriteList添加两个私有成员变量：头节点指针和链表结点数变量。
SpriteStruct *m_pListHeader; int m_iListSize;
同时添加获取m_iListSize值的成员函数：
int GetListSize() {return m_iListSize;};
4、 为链表类添加增加结点的方法。
// 添加一个Sprite到链表里
SpriteStruct *CSpriteList::AddSprite( CSprite *pSprite )
{
if( NULL == pSprite )
return NULL;
SpriteStruct *pPtr = new SpriteStruct;
pPtr->pSprite = pSprite;
pPtr->pNext = NULL;
pPtr->pPrev = NULL;
// 插入链表表尾
if( NULL == m_pListHeader )
m_pListHeader = pPtr;
else
{
SpriteStruct *pTemp = m_pListHeader;
while( NULL != pTemp->pNext )
pTemp = pTemp->pNext;
pPtr->pPrev = pTemp;
pTemp->pNext = pPtr;
}
m_iListSize++;
return pPtr;
}
5、 添加根据精灵名称将其从链表中删除的方法，第二个参数表示是否将其在游戏中的精灵也删除。
void CSpriteList::DeleteSprite( const char *szName, bool bDeleteImage )
{
SpriteStruct *pPtr = NULL;
for( pPtr = m_pListHeader; NULL != pPtr; pPtr = pPtr->pNext )
{
if( strcmp( szName, pPtr->pSprite->GetName() ) == 0 )
{
// 将本指针从链表中取出(即将链表中的前后指针重新指定)
// 假设目前链表如下：有ABC三个值，A <-> B <-> C，需要删除B
// 则需要将A的Next指向C，C的Prev指向A，删除后结果为A <->C
if( NULL != pPtr->pNext )
{
pPtr->pNext->pPrev = pPtr->pPrev;
}
if( NULL != pPtr->pPrev )
{
pPtr->pPrev->pNext = pPtr->pNext;
}
// 如果是表头
if( pPtr == m_pListHeader )
{
m_pListHeader = m_pListHeader->pNext;
}
// 删除Sprite
if( bDeleteImage )
pPtr->pSprite->DeleteSprite();
// 释放内存
delete pPtr;
m_iListSize--;
return;
}
}
}
6、 添加按位序查找链表中某个节点的方法。
CSprite *CSpriteList::GetSprite( const int iIndex )
{
int iLoop = 0;
SpriteStruct *pPtr = m_pListHeader;
while( NULL != pPtr )
{
if( iLoop == iIndex )
return pPtr->pSprite;
iLoop++;
pPtr = pPtr->pNext;
}
return NULL;
}
7、 添加通过精灵名字获得结点的方法。
CSprite* CSpriteList::GetSprite( const char *szName )
{
SpriteStruct *pPtr = m_pListHeader;
while( NULL != pPtr )
{
if( strcmp( pPtr->pSprite->GetName(), szName ) == 0 )
return pPtr->pSprite;
pPtr = pPtr->pNext;
}
return NULL;
}
8、 添加删除所有精灵的方法。
void CSpriteList::DeleteAllSprite( bool bDeleteImage )
{
SpriteStruct *pPtr = NULL;
SpriteStruct *pPtrhNext = m_pListHeader;
while( NULL != pPtrhNext )
{
pPtr = pPtrhNext;
pPtrhNext = pPtrhNext->pNext;
if( bDeleteImage )
pPtr->pSprite->DeleteSprite();
delete pPtr;
};
m_pListHeader = NULL;
m_iListSize = 0;
}
（三）添加敌机发射子弹的功能
1、 在CEnemyFighter类中添加成员函数OnFire()，实现在游戏循环时，战机发射子弹和上下浮动飞行的功能。其参数为游戏的时间间隔。
1）添加三个成员变量，分别表示子弹的发射间隔，战机飞行时上下浮动的时间间隔，战机飞行时是上浮还是下浮。
float m_fBulletCreateTime;
float m_fFloatTime;
bool m_bFloatUp;
注意把这这些变量在构造函数中初始化。
2） 然后在EnemyFighter.h中声明函数：
void OnFire ( float fDeltaTime );
在EnemyFighter.cpp中对函数进行实现：
void CEnemyFighter:: OnFire ( float fDeltaTime )
{
}
3） 在函数中添加代码，当表示战机创建之后，隔多久才可以开始发射子弹的变量递减到小于等于0时，开始可以创建子弹，然后开始递减子弹的发射间隔变量，当递减到小于等于0时，战机发射子弹。
m_fCanFireAfterCreated -= fDeltaTime;
if( m_fCanFireAfterCreated <= 0.f )
{
m_fBulletCreateTime -= fDeltaTime;
if( m_fBulletCreateTime <= 0.f )
{
m_fBulletCreateTime = 1.f;
g_GameMain.CreateBullet(1, GetSpritePositionX(),
GetSpritePositionY()); //1表示是敌方战机子弹
}
}
这里用到g_GameMain这个全局对象，所以应该在EnemyFighter.cpp中包含头文件：
#include"LessonX.h"
4） 添加战机上下浮动的代码。当战机浮动时，首先累计浮动的时间，当浮动时间大于1和小于0时，修改上浮还是下浮的变量值。然后获得战机此时的Y轴坐标，我们设置上下浮动的速度为6，这样就可以计算出浮动后的Y轴坐标。
if( m_bFloatUp )
{
m_fFloatTime += fDeltaTime;
if( m_fFloatTime >= 1.f )
{
m_bFloatUp = false;
}
float fPosY = GetSpritePositionY();
fPosY += 6.f * fDeltaTime;
SetSpritePositionY( fPosY );
}
else
{
m_fFloatTime -= fDeltaTime;
if( m_fFloatTime <= 0.f )
{
m_bFloatUp = true;
}
float fPosY = GetSpritePositionY();
fPosY -= 6.f * fDeltaTime;
SetSpritePositionY( fPosY );
}
（四）在CGameMain类中添加链表的操作
1、 在CGameMain类中定义一个成员变量代表链表对象m_SpriteList。
注意添加：#include "spriteList.h"。
2、 添加AddSprite方法，对链表类的添加函数进行包装，用于将游戏中的精灵添加到链表中。
void CGameMain::AddSprite( CSprite *pSprite )
{
m_SpriteList.AddSprite( pSprite );
}
3、 在CGameMain类的createBullet()函数最后，将创建的子弹添加到链表中。
AddSprite(pBullet);
4、 在CEnemyFighter类的createEnemyFighter()函数中，调用CGameMain类的AddSprite方法将创建好的敌方战机添加到链表中。
g_GameMain.AddSprite( pSprite );
5、 在CGameMain类的GameRun方法中，遍历链表中的每个节点，获得所有敌方战机的结点，让战机执行OnFire()方法，实现战机发射子弹和上下浮动。
int iListSize = m_SpriteList.GetListSize();
for( int iLoop = 0; iLoop < iListSize; iLoop++ )
{
CSprite * pSprite = m_SpriteList.GetSprite(iLoop);
if (pSprite != NULL && (strstr(pSprite->GetName(), "HorizontalSprite") != NULL))
{
((CEnemyFighter *)pSprite)->OnFire(fDeltaTime);
}
}
5、在GameEnd中添加代码，清空所有精灵，显示空格开始。
m_pBeginSprite->SetSpriteVisible(true); m_SpriteList.DeleteAllSprite(true); m_pMyFighter->SetSpriteVisible(false); delete m_pMyFighter; m_pMyFighter = NULL;
实验五 添加碰撞检测
【实验内容】
1、 创建一个精灵父类CWeapon；
2、 将战机类和子弹类改为继承于CWeapon类；
3、 为游戏中的精灵添加HP属性，并为子弹添加破坏力的属性。
4、 CWeapon类添加检测碰撞的虚函数，并在各子类中实现；
5、 当玩家战机的HP值小于0是游戏结束。
【实验思路】
检测碰撞时，我们先获取碰撞的双方，然后再将其各自做碰撞检测。并且产生碰撞特效，是游戏看起来更加逼真。用虚函数的方式实现多态。
【实验指导】
（一）创建公共父类CWeapon
1、 分析我方战机类、敌方战机类、子弹类的共同特性，我们提取它们的这些共性，创建它们的父类CWeapon，使得玩家战机、敌方战机和子弹类都继承于CWeapon类。仿照上边方法创建CWeapon类：
为CWeapon类添加数据成员生命值m_iHp、碰上敌方，给敌方造成的伤害值m_iDamage、击毁本Sprite将获得的积分值m_iScore以及精灵类型m_iType。
int m_iHp; int m_iDamage; int m_iScore; int m_iType;
为这四个个属性添加Set和Get方法。
2、 将CBullet、CMyFighter和CEnemyFighter三个类的父类改为CWeapon，注意需要修改各自的构造函数，并包含头文件：
#include"weapon.h"
其中，子弹类CBullet中的数据成员m_iType，因为父类CWeapon中已具有，所以将其删除（原IsMyBullet函数做相应修改）。在CWeapon中增加构造函数CWeapon(int iType, const char* szName)。
class CWeapon : public CSprite
{
private:
public:
CWeapon( const char *szName );
CWeapon(int iType, const char* szName); //为CBullet类准备
virtual ~CWeapon() { };
};
CBullet::CBullet(int iType, const char* szName):CWeapon(iType, szName)
{
}
CMyFighter::CMyFighter(const char* szName):CWeapon(szName)
{
……
}
CEnemyFighter::CEnemyFighter(const char* szName):CWeapon(szName)
{
……
}
3、 在CWeapon类中添加成员函数IsDead。当m_iHp小于等于0时，精灵为死亡状态。
bool IsDead() { return m_iHp <= 0; }
4、 在CWeapon类中添加虚成员函数IsMyBullet，方法判断子弹是否是玩家战机发射的。默认返回false，由子弹类CBullet重写，实现运行时多态。
virtual bool IsMyBullet() { return false; }
bool CBullet::IsMyBullet()
{
return GetType()==0;
}
5、 在CWeapon类中添加虚成员函数IsMyFighter，判断是否为玩家战机。
virtual bool IsMyFighter() { return false; }
默认返回false，由玩家战机CMyFighter重写，实现运行时多态。
bool CMyFighter::IsMyFighter()
{
return true;
}
6、 在CWeapon类中添加虚函数OnColOtherSprite，处理精灵之间的碰撞。
virtual void OnColOtherSprite( CWeapon *pOther ){}
由CBullet、CMyFighter、CEnemyFighter类分别重写，实现运行时多态。
7、 修改CSpriteList类中的函数参数以及返回值，将原先所有的CSprite * 更改为CWeapon *；并将结构体中的CSprite * pSprite； 改为CWeapon * pSprite;
8、 修改CGameMain中AddSprite(CSprite *pSprite );中的CSprite * 为CWeapon *。
（二）为子弹、玩家战机、敌方战机做初始化
1、 在GameInit函数中添加玩家战机的初始化代码，在GameInit函数最后添加代码：
m_pMyFighter->SetHp( 500 ); m_pMyFighter->SetScore( 0 ); 2、 在CEnemyFighter的createEnemyFighter ( float fDeltaTime )函数中，添加如下代码，对创建的敌机进行初始化： pSprite->SetHp(300); pSprite->SetScore(100); pSprite->SetDamage(200);
3、 在CGameMain的:CreateBullet( int iType, const float fPosX, const float fPosY )函数中，添加如下代码，对子弹进行初始化：
pBullet->SetDamage(100);
pBullet->SetHp(10);
（三）包装链表操作
添加通过索引值查找精灵、通过名字查找精灵、删除精灵的函数，对链表类的操作在CGameMain中进行包装。
CWeapon *CGameMain::GetSprite( const int iIndex )
{
return m_SpriteList.GetSprite(iIndex);
}
CWeapon *CGameMain::GetSprite( const char *szName )
{
return m_SpriteList.GetSprite(szName);
}
//包装删除精灵
void CGameMain::DeleteSprite( const char *szName, bool bDeleteImage )
{
m_SpriteList.DeleteSprite( szName, bDeleteImage );
}
（四）进行碰撞处理
1、 在CGameMain类中添加函数，通过名字判断是否是我方坦克：
bool CGameMain::IsMyFighter( const char *szName )
{
return (strcmp( m_pMyFighter ->GetName(), szName ) == 0);
}
2、 在CGameMain类中的OnSpriteColSprite方法中添加碰撞检测。
void CGameMain::OnSpriteColSprite( const char *szSrcName, const char
*szTarName )
{
if( 2 != GetGameState() )
return;
CWeapon *pSrcSprite = IsMyFighter(szSrcName ) ? m_pMyFighter : GetSprite( szSrcName );
CWeapon *pTarSprite = IsMyFighter(szTarName ) ? m_pMyFighter : GetSprite( szTarName );
if( NULL == pSrcSprite || NULL == pTarSprite )
return;
pSrcSprite->OnColOtherSprite( pTarSprite );
pTarSprite->OnColOtherSprite( pSrcSprite );
if( !pSrcSprite-> IsMyFighter () )
{
if( pSrcSprite->IsDead() )
g_GameMain.DeleteSprite( szSrcName, true );
}
if( !pTarSprite-> IsMyFighter () )
{
if( pTarSprite->IsDead() )
g_GameMain.DeleteSprite( szTarName, true );
}
}
3、 为CBullet添加OnColOtherSprite方法，并实现此方法。
子弹发生碰撞后，进行血量的消耗。
void CBullet::OnColOtherSprite( CWeapon *pOther )
{
if( NULL == pOther )
return;
if(IsMyBullet () )
{
if( pOther->IsMyFighter () )
return;
SetHp( GetHp() - pOther->GetDamage() );
}
else
{
if( pOther->IsMyFighter () || pOther->IsMyBullet () )
{
SetHp( GetHp() - pOther->GetDamage() );
}
}
}
4、 为CMyFighter添加OnColOtherSprite方法，并实现此方法。
void CMyFighter::OnColOtherSprite( CWeapon *pOther )
{
if( NULL == pOther )
return;
if( pOther-> IsMyBullet () )
return;
SetHp( GetHp() - pOther->GetDamage() );
if( GetHp() <= 200 )
{
SetSpriteColorGreen( 0 );
SetSpriteColorBlue( 0 );
}
else if( GetHp() <= 500 )
{
SetSpriteColorGreen( 128 );
SetSpriteColorBlue( 128 );
}
else
{
SetSpriteColorGreen( 255 );
SetSpriteColorBlue( 255 );
}
}
5、 为CEnemyFighter添加OnColOtherSprite方法，并实现此方法。
void CEnemyFighter::OnColOtherSprite( CWeapon *pOther )
{
if( NULL == pOther )
return;
if( pOther-> IsMyFighter () || pOther-> IsMyBullet () )
{
SetHp( GetHp() - pOther->GetDamage() );
if (IsDead())
{
g_GameMain.GetMyFight()->SetScore(g_GameMain.GetMyFight()->GetScore() + GetScore());
}
}
}
因为在CEnemyFighter中需要获取玩家战机，所以此操作前先在CGameMain中添加GetMyFighter()成员函数：
CMyFight * CGameMain::GetMyFighter()
{
return m_pMyFighter;
}
6、 显示玩家战机得分。
在构造函数中创建对象：
m_pCurScoreText = new CTextSprite("CurScoreText");
在GameInit()函数中，显示得分初值（0）：
m_pCurScoreText->SetTextValue(m_pMyFighter->GetScore());
在GameRun()函数中，实时显示当前得分：
m_pCurScoreText->SetTextValue(m_pMyFighter->GetScore());
7、 当我方战机的HP值小于0是，游戏结束。增加IsGameLost方法。
bool CGameMain::IsGameLost()
{
return ( m_pMyFighter ? m_pMyFighter->IsDead() : false );
}
8、 在GameMainLoop中的switch语句中的case 2中调用：
if( !IsGameLost() )
{
GameRun( fDeltaTime );
}
实验六 读写游戏记录
【实验内容】
1、 读取游戏最高分记录；
2、 写入游戏最高分记录；
【实验思路】
用流方式读写文件。
【实验指导】
1、 在CGameMain中添加表示最高分数的私有成员变量m_iMaxScore，并在构造函数中初始化为0。
2、 在CGameMain类的GameInit方法中读取游戏记录。
fstream ScoreFile("Score.dat",fstream::in | fstream::binary);
if( ScoreFile.is_open() )
{
ScoreFile >> m_iMaxScore;
ScoreFile.close();
}
//更新最大积分
m_pMaxScoreText ->SetTextValue( m_iMaxScore );
注意需要包含头文件，并声明命名空间：
#include "fstream"
using namespace std;
3、 在CGameMain类的GameEnd方法中写入记录。
if( m_iMaxScore < GetControlSprite()->GetScore() )
{
m_iMaxScore = GetControlSprite()->GetScore();
// 写文件
fstream ScoreFile("Score.dat",fstream::out | fstream::binary);
if( ScoreFile.is_open() )
{
ScoreFile << m_iMaxScore;
ScoreFile.close();
}
}
至此，本游戏全部结束。
代写CS&Finance|建模|代码|系统|报告|考试
编程类：C代写,JAVA代写 ,数据库代写,WEB代写,Python代写,Matlab代写,GO语言,R代写
金融类：统计，计量，风险投资，金融工程，R语言，Python语言，Matlab，建立模型，数据分析，数据处理
服务类：Lab/Assignment/Project/Course/Qzui/Midterm/Final/Exam/Test帮助代写代考辅导
天才写手,代写CS,代写finance,代写statistics,考试助攻
E-mail:850190831@qq.com 微信：BadGeniuscs 工作时间：无休息工作日-早上8点到凌晨3点
如果您用的手机请先保存二维码到手机里面，识别图中二维码。如果用电脑，直接掏出手机果断扫描。
