funcode(c++)--不一样的黄金矿工

苍茫大地一剑尽挽破，何处繁华笙歌落。斜倚云端千壶掩寂寞，纵使他人空笑我。

为什么不能上传资源？？？

悲催的我只能共享了?

下面代码请开始你的表演：

LessonX.cpp

/
//
//
//
//
/
#include 
#include "CommonClass.h"
#include "LessonX.h"
#include
using namespace std;
CGameMain		g_GameMain;
// 构造函数
CGameMain::CGameMain()
{
    m_fEmptyHookSpeed		=	15.f;
    m_iGoldCount			=	0;
    sum=0;
    t1=0;
    t2=0;
    t3=0;
    m_iGoldBornMinX			=	0;
    m_iGoldBornMaxX			=	0;
    m_iGoldBornMinY			=	0;
    m_iGoldBornMaxY			=	0;
    m_iGetGoldState=0;
    m_fHookRotation=0.f;
    m_iHookRotToLeft=1;
    m_fHookStartPosX=0.f;
    m_fHookStartPosY=0.f;
    m_iInitedHookPos=0;
    m_pGoldenTemplate	=	new CSprite("GoldTemplate");
    m_pGameBegin		=	new CSprite("GameBegin");
    m_count	=	new CTextSprite("count");
    m_score	=	new CTextSprite("score");
    m_time	=	new CTextSprite("time");
    m_pGoldenHook=new CSprite("GoldHook");
    m_pGoldenMan=new CAnimateSprite("GoldMan");
    m_voice=new CSound("mztknz.wav",true,1.f);
    m_voice=new CSound("BLIP.wav",true,1.f);
    mcp =new CSprite("mcp");// 重设钩子从0度、由右往左自动旋转
}
//析构函数
CGameMain::~CGameMain()
{
   m_voice->StopSound();
}
// 游戏主循环，此函数将被不停的调用，引擎每刷新一次屏幕，此函数即被调用一次
// 用以处理游戏的开始、进行中、结束等各种状态.
// 函数参数fDeltaTime : 上次调用本函数到此次调用本函数的时间间隔，单位：秒
void CGameMain::GameMainLoop( float	fDeltaTime )
{
    switch( GetGameState() )
    {
    // 初始化游戏，清空上一局相关数据
    case 1:
    {
        GameInit();
        SetGameState(2); // 初始化之后，将游戏状态设置为进行中
    }
    break;

    // 游戏进行中，处理各种游戏逻辑
    case 2:
    {
        // TODO 修改此处游戏循环条件，完成正确游戏逻辑
        if(m_iGoldCount>0)
        {
            GameRun( fDeltaTime );
        }
        else // 游戏结束。调用游戏结算函数，并把游戏状态修改为结束状态
        {
            SetGameState(0);
            GameEnd();
        }
    }
    break;
    // 游戏结束/等待按空格键开始
    case 0:
    default:
        break;
    };
    DrawHookLine();
}
// 每局开始前进行初始化，清空上一局相关数据
void CGameMain::GameInit()
{
    m_iGoldCount=18;
    m_fHookRotation	=	0.f;
    m_iHookRotToLeft	=	1;
    // 初始化抓取状态
    m_iGetGoldState	=	0;
    // 以下变量只需要初始化一次。
    m_iInitedHookPos	=	0;
    sum=1;
    if( 0 == m_iInitedHookPos )
    {
        //钩子可以发出碰撞
        m_pGoldenHook->SetSpriteCollisionSend(true);
        //金子可以接收碰撞
        m_pGoldenTemplate->SetSpriteCollisionReceive(true);
        mcp->SetSpriteCollisionReceive(true);
        m_iGoldBornMinX		=	CSystem::GetScreenLeft() + 5;
        m_iGoldBornMaxX		=	CSystem::GetScreenRight() - 5;
        m_iGoldBornMinY		=	CSystem::GetScreenTop() + 20;
        m_iGoldBornMaxY		=	CSystem::GetScreenBottom() - 5;
        m_iInitedHookPos		=	1;
        // 钩子初始位置值初始化
        m_fHookStartPosX	=	m_pGoldenHook->GetSpritePositionX();
        m_fHookStartPosY	=	m_pGoldenHook->GetSpritePositionY();
        //钩子的世界边界初始化
        m_pGoldenHook->SetSpriteWorldLimit(WORLD_LIMIT_NULL,CSystem::GetScreenLeft(),CSystem::GetScreenTop(),CSystem::GetScreenRight(),CSystem::GetScreenBottom());
        m_pGoldenMan->AnimateSpritePlayAnimation("GolderManAnimation2", 0);
    }
    int		iLoop	=	0;
    // const char	*szName	=	new char[15];
    int		iSize	=	4, iPosX = 0, iPosY = 0;
    for( iLoop = 0; iLoop < m_iGoldCount; iLoop++ )
    {
        if( iLoop < 10 )
            iSize	=	4;
        else if( iLoop >= 10 && iLoop < 16 )
            iSize	=	6;
        else
            iSize	=	8;
        // 初始化金子精灵实例
        char* tmpBlock;
        tmpBlock=CSystem::MakeSpriteName("GoldBlock",iLoop);
        CSprite *tmpGlodenBlock=new CSprite(tmpBlock);
        tmpGlodenBlock->CloneSprite("GoldTemplate");
        tmpGlodenBlock->SetSpriteWidth((float)iSize );
        tmpGlodenBlock->SetSpriteHeight((float)iSize);
        // 随机一个位置
        iPosX	=	CSystem::RandomRange(m_iGoldBornMinX, m_iGoldBornMaxX);
        iPosY	=	CSystem::RandomRange(m_iGoldBornMinY, m_iGoldBornMaxY);
        tmpGlodenBlock->SetSpritePosition((float)iPosX, (float)iPosY);
        m_vGoldenBlock.push_back(*tmpGlodenBlock);
    }
    char* tmpBlock1;
    tmpBlock1=CSystem::MakeSpriteName("mcp1",1);
    CSprite *tmpGlodenBlock1=new CSprite(tmpBlock1);
    tmpGlodenBlock1->CloneSprite("mcp");
    tmpGlodenBlock1->SetSpriteWidth(10);
    tmpGlodenBlock1->SetSpriteHeight(8);    // 随机一个位置
    tmpGlodenBlock1->SetSpritePosition(-5, -10);
    m_vmyname.push_back(*tmpGlodenBlock1);    // 播放挖金者的动作(恢复初始守候动作)
    m_pGoldenMan->AnimateSpritePlayAnimation("GolderManAnimation2", 0);    // 隐藏游戏开始的提示
    m_pGameBegin->SetSpriteVisible(0);
}
// 每局游戏进行中
void CGameMain::GameRun( float fDeltaTime )
{
    int flag=0;
    if(flag==0){
        m_voice->GetName();
            m_voice->PlaySound();
            flag=1;
    }
    t3+=fDeltaTime;
    m_time->SetTextValue((int)t3);
    if( 0 == m_iGetGoldState )
    {
        const	float	fRotateSpeed	=	100.f; // 摇摆速度，单位度/秒
        float	 fThisRotate	=	fRotateSpeed * fDeltaTime; // 本次旋转的度数
        if( m_iHookRotToLeft )
        {
            m_fHookRotation	+= fThisRotate;
            if( m_fHookRotation >= 180.f )
            {
                m_fHookRotation		=	180.f;
                m_iHookRotToLeft	=	0;
            }
        }
        else
        {
            m_fHookRotation	-= fThisRotate;
            if( m_fHookRotation <= 0.f )
            {
                m_fHookRotation		=	0.f;
                m_iHookRotToLeft	=	1;
            }
        }
        m_pGoldenHook->SetSpriteRotation(m_fHookRotation);
    }
    else if( 2 == m_iGetGoldState || 3 == m_iGetGoldState )
    {
        // 判断是否移动到终点(判断的依据是XY方向的移动速度为0，即金子是否已经停止移动)
        float	fSpeedX	=	m_pGoldenHook->GetSpriteLinearVelocityX();
        float	fSpeedY	=	m_pGoldenHook->GetSpriteLinearVelocityY();
        // 当前速度不为0，还在运动中
        // 浮点数是否为0，不能直接判断 == != 0
        if( fSpeedX > 0.00001f || fSpeedX < -0.00001f || fSpeedY > 0.00001f || fSpeedY < -0.00001f )
               return;
        // 速度为0，钩子回到初始点，开始下一轮的抓取
        // 当前抓取到金子，将抓取到的金子释放并删除之。然后将金子数量减一
        if(3 == m_iGetGoldState&&stricmp(m_szCurGetGold,"GoldBlock")==1)
        {
            t1++;
            CSprite *Glodennow=new CSprite(m_szCurGetGold);
            float gd=Glodennow->GetSpriteHeight();
            if(gd==4)
                t2+=10;
            if(gd==6)
                t2+=50;
            if(gd==8)
                t2+=100;
            m_score->SetTextValue(t2);
            m_count->SetTextValue(t1);
            m_iGoldCount--;
            GetCurGoldenSprite( m_szCurGetGold ).SpriteDismount();
            GetCurGoldenSprite( m_szCurGetGold ).DeleteSprite();
        }
        if(3 == m_iGetGoldState&&stricmp(m_szCurGetname,"mcp1")==1)
        {
            sum--;
            GetCurGoldenSprite1( m_szCurGetname ).SpriteDismount();
            GetCurGoldenSprite1( m_szCurGetname ).DeleteSprite();
        }
        m_iGetGoldState	=	0;
        m_pGoldenMan->AnimateSpritePlayAnimation("GolderManAnimation2", 0);
    }
}
void	CGameMain::GameEnd()
{
    t1=0;
    t2=0;
    t3=0;
    m_pGameBegin->SetSpriteVisible(1);
}
// 键盘按下
// 参数 iKey：被按下的键，值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress，iCtrlPress：键盘上的功能键Alt，Ctrl，Shift当前是否也处于按下状态(0未按下，1按下)
void CGameMain::OnKeyDown( const int iKey, const bool bAltPress, const bool bShiftPress, const bool bCtrlPress )
{
    if( KEY_SPACE == iKey && false == m_iGameState )
    {
        m_iGameState	=	true;
        m_pGameBegin->SetSpriteVisible(false);
    }
    else if( KEY_DOWN == iKey && 2 == m_iGameState && 0 == m_iGetGoldState )
    {
        // 设置抓取状态为：钩子往外伸
        m_iGetGoldState	=	1;
        // 以当前朝向给钩子一个向前的速度
        m_pGoldenHook->SetSpriteLinearVelocityPolar(m_fEmptyHookSpeed, m_fHookRotation);
        // 播放挖金者的动作(一个胳膊往下压的动作)
        m_pGoldenMan->AnimateSpritePlayAnimation("GolderManAnimation1", 0);
    }
}
//获得绳子
void CGameMain::DrawHookLine()
{
    // 首先，从矿工精灵上获取一个缆绳链接点作为绳子的起始点(该链接点在编辑器里编辑好)
    float	fStartX	=	m_pGoldenMan->GetSpriteLinkPointPosX(1);
    float	fStartY	=	m_pGoldenMan->GetSpriteLinkPointPosY(1);
    // 绳子终点在钩子精灵上获取(该链接点在编辑器里编辑好)
    float	fEndX	=	m_pGoldenHook->GetSpriteLinkPointPosX(1);
    float	fEndY	=	m_pGoldenHook->GetSpriteLinkPointPosY(1);
    // 在这两点之间划线.线的颜色红绿蓝值都为50，即灰色
    CSystem::DrawLine( fStartX, fStartY, fEndX, fEndY, 2.f, 0, 50, 50, 50, 255 );
}
CSprite CGameMain::GetCurGoldenSprite(const char* goldenname)
{
    for(int i=0; iSpriteMoveTo(m_fHookStartPosX, m_fHookStartPosY, m_fEmptyHookSpeed, 1);
        // 播放挖金者的动作(胳膊来回动的动作)
        m_pGoldenMan->AnimateSpritePlayAnimation("GolderManAnimation3", 0);
    }

}
// 精灵与精灵碰撞
// 参数 szSrcName：发起碰撞的精灵名字
// 参数 szTarName：被碰撞的精灵名字
void CGameMain::OnSpriteColSprite( const char *szSrcName, const char *szTarName )
{
    if( 2 != m_iGameState || 1 != m_iGetGoldState )
        return;
    if( stricmp( "GoldHook", szSrcName ) != 0 && stricmp( "GoldHook", szTarName ) != 0 )
        return;
    // 找到哪个是金子的名字
    const char	*szGoldName	=	NULL;
    if( strstr( szSrcName, "GoldBlock" ) )
        szGoldName = szSrcName;
    else if( strstr( szTarName, "GoldBlock" ) )
        szGoldName = szTarName;
    else
        return;
    CSprite tmpSprite= GetCurGoldenSprite(szGoldName);
    tmpSprite.SpriteMountToSpriteLinkPoint("GoldHook",2);
    m_iGetGoldState	=	3;
    strcpy( m_szCurGetGold, szGoldName );
    float	fWidth;
    fWidth=	GetCurGoldenSprite( szGoldName ).GetSpriteWidth();
    float	fSpeed	=	((10.f - fWidth) / 10.f) * m_fEmptyHookSpeed;
    // 钩子往初始位置移动
    m_pGoldenHook->SpriteMoveTo(m_fHookStartPosX, m_fHookStartPosY, fSpeed, 1);
    // 播放挖金者的动作(胳膊来回动的动作)
    m_pGoldenMan->AnimateSpritePlayAnimation("GolderManAnimation3", 0 );

}
void CGameMain::OnSpriteColSprite1( const char szSrcName[], const char szTarName[] )
{
    if( 2 != m_iGameState || 1 != m_iGetGoldState )        return;
    if( stricmp( "goldHook", szSrcName ) != 0 && stricmp( "goldHook", szTarName ) != 0)        return;
    const char	*myName	=	NULL;
    if( strstr( szTarName, "mcp1" ) )        myName = szTarName;
    else if( strstr( szSrcName, "mcp1" ) )        myName = szSrcName;
    else        return;
    CSprite tmpSprite1= GetCurGoldenSprite1(myName);
    tmpSprite1.SpriteMountToSpriteLinkPoint("goldHook",2);
    m_iGetGoldState	=	3;
    strcpy( m_szCurGetname, myName );
    float	fSpeed	=	10;
    m_pGoldenHook->SpriteMoveTo(m_fHookStartPosX, m_fHookStartPosY, fSpeed, 1);    // 播放挖金者的动作(胳膊来回动的动作)
    m_pGoldenMan->AnimateSpritePlayAnimation("GolderManAnimation3", 0 );
}

Main.cpp

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonClass.h"
#include "LessonX.h"
///
//
// 主函数入口
//
//
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
	// 初始化游戏引擎
	if( !CSystem::InitGameEngine( hInstance, lpCmdLine ) )
		return 0;

	// To do : 在此使用API更改窗口标题
	CSystem::SetWindowTitle("LessonX");

	// 引擎主循环，处理屏幕图像刷新等工作
	while( CSystem::EngineMainLoop() )
	{
		// 获取两次调用之间的时间差，传递给游戏逻辑处理
		float	fTimeDelta	=	CSystem::GetTimeDelta();

		// 执行游戏主循环
		g_GameMain.GameMainLoop( fTimeDelta );
	};

	// 关闭游戏引擎
	CSystem::ShutdownGameEngine();
	return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后，将调用到本函数
// 参数 fMouseX, fMouseY：为鼠标当前坐标
//
void CSystem::OnMouseMove( const float fMouseX, const float fMouseY )
{
	// 可以在此添加游戏需要的响应函数
//	g_GameMain.OnMouseMove(fMouseX, fMouseY);
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后，将调用到本函数
// 参数 iMouseType：鼠标按键值，见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY：为鼠标当前坐标
//
void CSystem::OnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
	// 可以在此添加游戏需要的响应函数
//	g_GameMain.OnMouseClick(iMouseType, fMouseX, fMouseY);
}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后，将调用到本函数
// 参数 iMouseType：鼠标按键值，见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY：为鼠标当前坐标
//
void CSystem::OnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
	// 可以在此添加游戏需要的响应函数
	//g_GameMain.OnMouseUp(iMouseType, fMouseX, fMouseY);
}
//==========================================================================
//
// 引擎捕捉键盘按下消息后，将调用到本函数
// 参数 iKey：被按下的键，值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress，iCtrlPress：键盘上的功能键Alt，Ctrl，Shift当前是否也处于按下状态(0未按下，1按下)
//
void CSystem::OnKeyDown( const int iKey, const bool bAltPress, const bool bShiftPress, const bool bCtrlPress )
{
	// 可以在此添加游戏需要的响应函数
	g_GameMain.OnKeyDown(iKey, bAltPress, bShiftPress, bCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后，将调用到本函数
// 参数 iKey：弹起的键，值见 enum KeyCodes 宏定义
//
void CSystem::OnKeyUp( const int iKey )
{
	// 可以在此添加游戏需要的响应函数
//	g_GameMain.OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后，调用此函数
// 精灵之间要产生碰撞，必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName：发起碰撞的精灵名字
// 参数 szTarName：被碰撞的精灵名字
//
void CSystem::OnSpriteColSprite( const char *szSrcName, const char *szTarName )
{
	// 可以在此添加游戏需要的响应函数
	g_GameMain.OnSpriteColSprite(szSrcName, szTarName);
	 g_GameMain.OnSpriteColSprite1(szSrcName,szTarName);
}

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后，调用此函数.
// 精灵之间要产生碰撞，必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName：碰撞到边界的精灵名字
// 参数 iColSide：碰撞到的边界 0 左边，1 右边，2 上边，3 下边
//
void CSystem::OnSpriteColWorldLimit( const char *szName, const int iColSide )
{
	// 可以在此添加游戏需要的响应函数
	g_GameMain.OnSpriteColWorldLimit(szName, iColSide);
}

LessonX.h

/
//
//
//
//
/
#ifndef _LESSON_X_H_
#define _LESSON_X_H_
//
#include 
#include
using namespace std;
// 游戏总管类。负责处理游戏主循环、游戏初始化、结束等工作
class	CGameMain
{
private:
    vector		m_vGoldenBlock;	//金子精灵数组
    vector		m_vmyname;	//名字精灵数组
    CSprite*	m_pGameBegin;			//GameBegin精灵实例
    CSprite*			m_pGoldenHook;	//钩子精灵实例
    CTextSprite*    m_count;//文字实例
    CTextSprite*    m_score;//文字实例
    CTextSprite*    m_time;//文字实例
    CTextSprite*    m_zzr;//文字实例
    CTextSprite*    m_xm;//文字实例
    CAnimateSprite*   m_pGoldenMan;
    CSprite*	mcp;	//挖金人实
    CSprite* m_shuliang;
    CSprite*	m_pGoldenTemplate;	//默认绑定的金子精灵，用来创建其他金子
    CSound* m_voice;//声音
    CSound* m_voice1;//声音
    int sum;
    int				m_iGameState;				// 游戏状态，0：结束或者等待开始；1：初始化；2：游戏进行中
    int m_igoldCount;
    int t1,t2;
    float t3;
    int         m_iGoldCount	    ;
    int			m_iGoldBornMinX		;
    int			m_iGoldBornMaxX		;
    int			m_iGoldBornMinY		;
    int			m_iGoldBornMaxY		;
    int m_iGetGoldState	;// 抓取金子状态：0 -- 等待按键开始抓金子；1 -- 钩子伸出去；2 -- 钩子往回伸，未抓到东西；3 -- 钩子往回伸，带着金子
    float m_fHookRotation;	// 钩子当前转动的朝向
    int m_iHookRotToLeft;	// 钩子当前是往左摆动还是往右摆动( 1 右-左， 0 左-右 )
    float m_fHookStartPosX;	// 钩子初始位置。在刚开始的时候初始化一次，用于钩子复位
    float	m_fHookStartPosY;
    int m_iInitedHookPos;
    char		m_szCurGetGold[64];			// 当前抓取到的金子名字
    float		m_fEmptyHookSpeed	;		// 空的钩子的移动速度
    char		m_szCurGetname[1];
    char sy;
public:
    CGameMain();            //构造函数
    ~CGameMain();           //析构函数
    // Get方法
    int				GetGameState()
    {
        return m_iGameState;
    }
    // Set方法
    void			SetGameState( const int iState )
    {
        m_iGameState	=	iState;
    }
    void		    SetTextValue( int iValue );
    void			GameMainLoop( float	fDeltaTime );
    void			GameInit();
    void			GameRun( float fDeltaTime );
    void			GameEnd();
    void 			OnKeyDown( const int iKey, const bool bAltPress, const bool bShiftPress, const bool bCtrlPress );
    void            DrawHookLine();
    void 			OnMouseMove( const float fMouseX, const float fMouseY );
    void 			OnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY );
    void 			OnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY );
    void 			OnKeyUp( const int iKey );
    void 			OnSpriteColSprite( const char *szSrcName, const char *szTarName );
    void 			OnSpriteColWorldLimit( const char *szName, const int iColSide );
    CSprite			GetCurGoldenSprite(const char* goldenname);
    //以下为自定义函数
    void	        OnSpriteColSprite1( const char szSrcName[], const char szTarName []);
    CSprite         GetCurGoldenSprite1(const char* goldenname);
};
extern CGameMain	g_GameMain;
#endif // _LESSON_X_H_