2020大一下暑期实习--funcode游戏设计

07/10 14:44
阅读数 974

专业学习之路 的 第一个长文博客 hhhhh,但是出师不利,网不好,导致我写完的文章直接消失了,于是我又来了一遍。

之前怕python查重,我把所有的python文章都删了,现在肠子都悔青了,只怪当时的我太过单纯。不过后期应该会继续写python,哎,虽然我对python已经没有感情了。大概会关于图形图像识别与处理方面。

接下来讲讲我的funcode实习过程心得,hhh,第一个给老师验收的队伍,第一次一个人打了2000+行代码,大概花了4天吧,其实后面几天更多是花在优化游戏玩法。代码框架部分我也另辟蹊径,毕竟一个人搞会很自由hhhh,在我眼里看这个代码真的很笨,受限与funcode本身,我也不知道为什么很多库都用不上,导致重复工作量很大。除此,funcode不能支持联机,在此非常感谢大佬帮我测试。虽然老师说我们的游戏做的挺不错的,但是确实和一个4399一些经典游戏相比,少了些趣味性。当然外行看热闹,内行看门道,感谢老师的鼓励hhhh

最后,其实有2个bug我一直没改出来,其中一个bug是精灵跳跃部分,虽然我还有很多其他思路来改,但是由于自己的懒惰hhh就混过了这个小小的bug,虽然原理没错,但是参数不准确。另一个bug是我到现在都没有找到原因,原理是绝对没有错的,但是坐标就是不准确,(我printf出来也是正确的),个人认为是funcode里面的坐标参数,以及精灵的中心点这个两个点没有很好匹配上。但是后面这个bug成了一个我们队很好的一个“有寓意的点”。不得不说我太能编了hhhh。

首先附上我修改好的十个提高案例 

导入地图,修改精灵名后直接用。

1、 海底世界

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"

float		g_fScreenLeft		=	0.f;    // 屏幕左边界值
float		g_fScreenRight		=	0.f;    // 右
float		g_fScreenTop		=	0.f;    // 上
float		g_fScreenBottom	=	0.f;    // 下
float		g_fSpeedLeft	=	0.f;  	// 左方向速度
float		g_fSpeedRight	=	0.f;  	// 右
float		g_fSpeedTop		=	0.f;  	// 上
float		g_fSpeedBottom	=	0.f;  	// 下


///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;
    g_fScreenLeft	 	= 	dGetScreenLeft();
    g_fScreenRight  	= 	dGetScreenRight();
    g_fScreenTop 	 	= 	dGetScreenTop();
    g_fScreenBottom 	= 	dGetScreenBottom();
//    dSetSpriteLinearVelocity("yu_0", 30, 0);
//    dSetSpriteWorldLimit("yu_0", WORLD_LIMIT_NULL, g_fScreenLeft, g_fScreenTop, g_fScreenRight, g_fScreenBottom);
    dSetSpriteWorldLimit("myfish",
                         WORLD_LIMIT_NULL,
                         g_fScreenLeft,
                         g_fScreenTop,
                         g_fScreenRight,
                         g_fScreenBottom);

    for(int i=0; i<3; i++)
    {
        // 生成待拷贝鱼的名字
        char *destFish = dMakeSpriteName("fish%d",i);
// 拷贝rockfishTemplate到destFish
        dCloneSprite("fish_muban",destFish);
// 随机产生鱼的纵坐标
        float fPosX, fPosY;
        float fSpeedX;

        fPosX = dRandomRange(g_fScreenLeft+10.f, g_fScreenRight-10.f);
        fPosY = dRandomRange(g_fScreenTop+10.f, g_fScreenBottom-10.f);
        dSetSpritePosition(destFish, fPosX, fPosY);
        fSpeedX = dRandomRange(-10, -20);
        //设置拷贝得到的鱼的Y坐标
        dSetSpritePositionY(destFish,fPosY);
        dSetSpriteLinearVelocity(destFish,fSpeedX, 0);
        dSetSpriteWorldLimit(destFish,WORLD_LIMIT_NULL,
                             g_fScreenLeft-20.f,
                             g_fScreenTop,
                             g_fScreenRight+20.f,
                             g_fScreenBottom);

    }



    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("Lesson");



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

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

    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    // 可以在此添加游戏需要的响应函数
    switch(iKey)
    {
    case KEY_W:
        g_fSpeedTop = -10.f;
        break;
    case KEY_A:
        g_fSpeedLeft = -15.f;
        break;
    case KEY_S:
        g_fSpeedBottom = 10.f;
        break;
    case KEY_D:
        g_fSpeedRight = 15.f;
        break;
    default:
        break;
    }
   dSetSpriteLinearVelocity("myfish", g_fSpeedLeft + g_fSpeedRight, g_fSpeedTop + g_fSpeedBottom);
  if((g_fSpeedLeft + g_fSpeedRight) > 0.f)
		dSetSpriteFlipX("myfish", false);
	else if((g_fSpeedLeft + g_fSpeedRight) < 0.f)
		dSetSpriteFlipX("myfish", true);

    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    // 可以在此添加游戏需要的响应函数
    switch(iKey)
    {
    case KEY_W:
        g_fSpeedTop = 0.f;
        break;
    case KEY_A:
        g_fSpeedLeft = 0.f;
        break;
    case KEY_S:
        g_fSpeedBottom = 0.f;
        break;
    case KEY_D:
        g_fSpeedRight = 0.f;
        break;
    }
    dSetSpriteLinearVelocity("myfish", g_fSpeedLeft + g_fSpeedRight, g_fSpeedTop + g_fSpeedBottom);

if((g_fSpeedLeft + g_fSpeedRight) > 0.f)
		dSetSpriteFlipX("myfish", false);
	else if((g_fSpeedLeft + g_fSpeedRight) < 0.f)
		dSetSpriteFlipX("myfish", true);

    OnKeyUp(iKey);
}

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

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后,调用此函数.
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName:碰撞到边界的精灵名字
// 参数 iColSide:碰撞到的边界 0 左边,1 右边,2 上边,3 下边
//
void dOnSpriteColWorldLimit( const char *szName, const int iColSide )
{
    int	iFlip;
    float	fSpeedX;
    float	fPosY;

    if(strstr(szName, "fish")!=NULL)
    {
        if(strcmp(szName, "myfish") == 0)      // myfish精灵
        {
            dSetSpriteLinearVelocity(szName, 0, 0);
        }
        else
        {
// 另外4条鱼
            if(iColSide == 1)  // 右边
            {
                iFlip = 1;
                fSpeedX = -dRandomRange(10, 20);
            }
            else if(iColSide == 0)   // 左边
            {
                iFlip = 0;
                fSpeedX = dRandomRange(10, 20);
            }
            dSetSpriteFlipX(szName,iFlip);
            dSetSpriteLinearVelocity(szName, fSpeedX, 0);

            fPosY=dRandomRange(g_fScreenTop+10.f,g_fScreenBottom-10.f);
            dSetSpritePositionY(szName, fPosY);
        }
    }


    // 可以在此添加游戏需要的响应函数
    OnSpriteColWorldLimit(szName, iColSide);
}

2、拼图游戏

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
int g_iGameStart=0;
const int BLOCK_COUNT=4;
int	g_iBlockState[BLOCK_COUNT][BLOCK_COUNT];
//	一维数组,存储上面二维数组中的方块精灵的名字。TO DO 思考一下数	    //	组大小一样的二维数组索引与一维数组索引如何相互转换?
char	g_szBlockName[BLOCK_COUNT * BLOCK_COUNT][64];
// 	按方块大小,在编辑器里摆放的第一块方块的起始坐标
const float	g_fBlockStartX		=	-40.625f;
const float	g_fBlockStartY		=	-28.125f;
// 	屏幕高度75 / 4块 = 18.75每块的大小.编辑器里预先摆放好的方块宽和高  //	必须与此值一致
const float		g_fBlockSize		=	18.75f;
//二维数组转化成一维数组
int XYToOneIndex( const int iIndexX, const int iIndexY )
{
    return (iIndexY * BLOCK_COUNT + iIndexX);
}
void MoveSpriteToBlock( const char *szName, const int iIndexX, const int iIndexY )
{
    float	fPosX	=	g_fBlockStartX + iIndexX * g_fBlockSize;
    float	fPosY	=	g_fBlockStartY + iIndexY * g_fBlockSize;
    dSetSpritePosition( szName, fPosX, fPosY );
}
// 一维数组索引转换到二维数组索引X,注意这2个数组大小必须一致
int OneIndexToX( const int iIndex )
{
    return (iIndex % BLOCK_COUNT);
}
// 一维数组索引转换到二维数组索引Y,注意这2个数组大小必须一致
int OneIndexToY( const int iIndex )
{
    return (iIndex / BLOCK_COUNT);
}
int  IsGameWin()
{
    int	iLoopX	= 0, iLoopY = 0;
    int	iResult	= 1;
    for( iLoopY = 0; iLoopY < BLOCK_COUNT; iLoopY++ )
    {
        for( iLoopX = 0; iLoopX < BLOCK_COUNT; iLoopX++ )
        {
            // 数组的最后一个
            if( BLOCK_COUNT - 1 == iLoopX && BLOCK_COUNT - 1 == iLoopY )
                break;
            // 其中一个值不等于,那么就没有胜利
            if( g_iBlockState[iLoopY][iLoopX] != iResult )
                return 0;
            iResult++;
        }
    }
    return 1;


}


///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)

{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;
    int	iLoopX		= 0, iLoopY		= 0, iLoop = 0;
    int	iOneIndex	= 0, iRandIndex = 0;
    int	iDataCount	=	BLOCK_COUNT * BLOCK_COUNT - 1;
    int	iRandData[BLOCK_COUNT * BLOCK_COUNT - 1] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("Lesson");
    for( iLoopY = 0; iLoopY < BLOCK_COUNT; iLoopY++ )
    {
        for( iLoopX = 0; iLoopX < BLOCK_COUNT; iLoopX++ )
        {
            iOneIndex	=	XYToOneIndex( iLoopX, iLoopY );
            if( BLOCK_COUNT - 1 == iLoopX && BLOCK_COUNT - 1 == iLoopY )
            {
                g_iBlockState[iLoopY][iLoopX] = 0;
                g_szBlockName[iOneIndex][0] = '\0';
            }
            else
            {
                // 在当前剩余未使用到的数值里随机一个出来,赋值给二维数组
                iRandIndex	=	dRandomRange( 0, iDataCount - 1 );
                g_iBlockState[iLoopY][iLoopX] = iRandData[iRandIndex];
                /* 	给对应的名字数组赋值。该名字的方块已经预先在地图里摆放好,因此只需要生成对应的名字即可,不用创建精灵 */
                strcpy( g_szBlockName[iOneIndex], dMakeSpriteName( "PictureBlock",g_iBlockState[iLoopY][iLoopX] ) );
                // 将该精灵移动到对应的位置
                MoveSpriteToBlock( g_szBlockName[iOneIndex], iLoopX, iLoopY );
                /*dMakeSpriteName: 将前面的字符串与后面的数字整合成一个字符串
                // 参数 szPrev:一个非空字符串,最长不能超过20个英文字符。名字前面的字符。
                // 参数 iId:一个数字
                // 返回值:返回一个字符串,比如传入("xxx", 2),则返回"xxx2"
                extern char*	dMakeSpriteName(const char *szPrev, const int iId);
                */
                for( iLoop = iRandIndex; iLoop < iDataCount - 1; iLoop++ )
                {
                    iRandData[iLoop] = iRandData[iLoop + 1];
                }
                // 剩余有效值总数减一
                iDataCount--;
            }
        }
    }


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

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


    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}


//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // if( 2 != m_iGameState )
    //   return;
    int	iClickIndex	=	-1;
    int	iLoop	=	0;
    for( iLoop = 0; iLoop < BLOCK_COUNT * BLOCK_COUNT; iLoop++ )
    {
        if( '\0' == g_szBlockName[iLoop][0] )
            continue;
        // 使用API dIsPointInSprite 判断指定坐标是否位于某个名字的精灵内部
        if( dIsPointInSprite( g_szBlockName[iLoop], fMouseX, fMouseY ) )
        {
            iClickIndex	=	iLoop;
            break;
        }
    }
    // 判断鼠标是否点中方块
    if( -1 == iClickIndex )
        return;
    // 将该一维数组的Index转换成二维数组的X,Y
    int	iIndexX	=	OneIndexToX( iClickIndex );
    int	iIndexY	=	OneIndexToY( iClickIndex );
// TODO 在二维数组里查找鼠标点击的方块上下左右4个方向上是否有空位:
// 注意边界判断,否则数组访问会越界。比如判断左边时,需要判断是否已经是	//最左边的索引(iIndexX == 0)
// 如果有空位(值为0),则将该空位的索引赋值给下面这2个变量
    int	iEmptyIndexX = -1, iEmptyIndexY = -1;

// X 左方向(4个方向均需要判断是否是位于边缘,iIndexX > 0 即起此作用)
    if( iIndexX > 0 )
    {
        if( 0 == g_iBlockState[iIndexY][iIndexX - 1] )
        {
            iEmptyIndexX = iIndexX - 1;
            iEmptyIndexY = iIndexY;
        }
    }
    // X 右方向
    if( -1 == iEmptyIndexX && iIndexX < BLOCK_COUNT - 1 )
    {
        if( 0 == g_iBlockState[iIndexY][iIndexX + 1] )
        {
            iEmptyIndexX = iIndexX + 1;
            iEmptyIndexY = iIndexY;
        }
    }
    // Y 上方向
    if( -1 == iEmptyIndexY && iIndexY > 0 )
    {
        if( 0 == g_iBlockState[iIndexY - 1][iIndexX] )
        {
            iEmptyIndexX = iIndexX;
            iEmptyIndexY = iIndexY - 1;
        }
    }
    // Y 下方向
    if( -1 == iEmptyIndexY && iIndexY < BLOCK_COUNT - 1 )
    {
        if( 0 == g_iBlockState[iIndexY + 1][iIndexX] )
        {
            iEmptyIndexX = iIndexX;
            iEmptyIndexY = iIndexY + 1;
        }
    }
    // 判断是否找到空位
    if( -1 == iEmptyIndexX || -1 == iEmptyIndexY )
        return;
// 有空位,在二维数组里,将该索引对应的值进行交换
    g_iBlockState[iEmptyIndexY][iEmptyIndexX] = g_iBlockState[iIndexY][iIndexX];
    g_iBlockState[iIndexY][iIndexX]	=	0;
// 对应的名字也进行交换
    int	iOneIndex	=	XYToOneIndex( iEmptyIndexX, iEmptyIndexY );
    strcpy( g_szBlockName[iOneIndex], g_szBlockName[iClickIndex] );
    g_szBlockName[iClickIndex][0]	=	'\0';
// 将该精灵移动到对应的位置
    MoveSpriteToBlock( g_szBlockName[iOneIndex], iEmptyIndexX, iEmptyIndexY );


    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if(iKey==KEY_SPACE)
    {
        if(g_iGameStart==0)
        {
            g_iGameStart=1;
            dDeleteSprite("GameBegin");
        }
    }
    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{

    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

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

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

3、桌球

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
int g_iBallNumber=0, g_fOldRotation=0;
char g_szBallName[20];
int g_iPlayState	=  0;
float g_fRotateTime	 =  0.f;
int	g_iHoleNumber[8];//={0,1,2,3,4,5,6,7};
char g_szHoleName[8][64];			// 8个球洞的精灵名字
float g_fHoleRollTime	=	0.f;		// 球洞循环滚动间隔时间
int	g_iGameState1=0;
///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;

    int	iLoop = 0;
    for( iLoop = 0; iLoop < 8; iLoop++ )
    {
        g_iHoleNumber[iLoop]	=	iLoop;
        strcpy( g_szHoleName[iLoop], dMakeSpriteName( "BallHole", iLoop ) );
    }
    int	iNewBallNumber = dRandomRange( 0, 7 );
    if( iNewBallNumber != g_iBallNumber )
    {
        // dSetSpritePositionY( g_szBallName, 50.f );
        // 新球,移动到屏幕中
        g_iBallNumber	=	iNewBallNumber;
        strcpy( g_szBallName, dMakeSpriteName("Ball", g_iBallNumber) );
        dSetSpritePositionX( g_szBallName, -30.f );
    }


// 在Y向上随机摆放球的出生位置,只随机Y方向坐标,不动X方向
    int	iPosY	=	dRandomRange( -25, 25 );
    dSetSpritePositionY( g_szBallName, (float)iPosY );



// 获取球拍的初始朝向,只做一次
    static int iInited = 0;
    if( !iInited )
    {
        iInited	=	1;
        g_fOldRotation	=	dGetSpriteRotation( "BallCue" );
        dShowCursor( 0 );
    }

    iLoop = 0;
    for( iLoop = 0; iLoop < 8; iLoop++ )
    {
        g_iHoleNumber[iLoop]	=	iLoop;
        strcpy( g_szHoleName[iLoop], dMakeSpriteName( "BallHole", iLoop ) );

    }
    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("Lesson");

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

        if( 0 == g_iPlayState )
        {
// 下面的代码,用于画出球前进方向的一段虚线
// 之前的案例里,有段画抛物线弹道轨迹的代码,比较复杂。这里画虚线比较		  // 简单,可以自己动手实现
// 获取球杆和球的位置
            float	fBallPosX	=	dGetSpritePositionX( g_szBallName );
            float	fBallPosY	=	dGetSpritePositionY( g_szBallName );
            float	fCuePosX	=	dGetSpritePositionX( "BallCue" );
            float	fCuePosY	=	dGetSpritePositionY( "BallCue" );
            float	fVectorX	=	fBallPosX - fCuePosX;
            float	fVectorY	=	fBallPosY - fCuePosY;
            if( fVectorX > 0.001f || fVectorX < -0.001f || fVectorY > 0.001f || fVectorY < 			-0.001f )
            {
// 计算该向量的大小,以及将该向量单位化(sqrt函数是开平方函数,回想下	// 数学里如何求单位向量)
                float  fVectorSize = sqrt( fVectorX * fVectorX + fVectorY * fVectorY );
                float  fDirX	=  fVectorX / fVectorSize;
                float  fDirY	  =  fVectorY / fVectorSize;
                int		iLoop		= 0;
                float	fLastPosX	= fBallPosX, fLastPosY = fBallPosY;
                float	fNewPosX	= 0.f, fNewPosY = 0.f;
                float	fPosStep	= fVectorSize / 10.f;
                 for( iLoop = 0; iLoop < 12; iLoop++ )
                {
                    // 新坐标等于前一坐标加上向量方向上的一个距离值
                    fNewPosX	=	fLastPosX + fDirX * fPosStep;
                    fNewPosY	=	fLastPosY + fDirY * fPosStep;
                    // 偶数段就画
                    if( iLoop % 2 == 0 )
                        dDrawLine( fLastPosX, fLastPosY, fNewPosX, fNewPosY, 2.f, 0, 					0, 255, 0, 255 );
                    // 坐标往前移动(NewPos赋值给LastPos)
                    fLastPosX	=	fNewPosX;
                    fLastPosY	=	fNewPosY;
                }
            }
        }
        int	iLoop = 0;
        for( iLoop = 0; iLoop < 8; iLoop++ )
        {
            g_iHoleNumber[iLoop]	=	iLoop;
            strcpy( g_szHoleName[iLoop], dMakeSpriteName( "BallHole", iLoop ) );
        }

        int	iLastData	 =	0;
        float  fTempPosY	= 0.f;
        float  fLastPosY	=	0.f;
        char	 szLastName[64];
//iLoop是循环因子,iListData记录最后一个球洞的在m_iHoleNumber中的数值。
        // 隔一定时间滚动一次
        g_fHoleRollTime += 	fTimeDelta;
        if( g_fHoleRollTime > 1.f )
        {
            g_fHoleRollTime -= 1.f;
            // 取出最后一个值
            iLastData	=	g_iHoleNumber[7];
            fLastPosY	=	dGetSpritePositionY( g_szHoleName[7] );
            strcpy( szLastName, g_szHoleName[7] );
// 从后往前遍历数组。注意只需要做6次循环(iLoop由7递减至1)
            for( iLoop = 7; iLoop > 0; iLoop-- )
            {
                g_iHoleNumber[iLoop]	=	g_iHoleNumber[iLoop - 1];
                // 先保存需要更改坐标的精灵的Y坐标作为下一个精灵的坐标,然后再给它	// 赋值
                fTempPosY	=	dGetSpritePositionY( g_szHoleName[iLoop - 1] );
                dSetSpritePositionY( g_szHoleName[iLoop - 1], fLastPosY );
                fLastPosY 	=	fTempPosY;
                strcpy( g_szHoleName[iLoop], g_szHoleName[iLoop - 1] );
            }
// 将取出来的最后一个值赋值给第一个
            g_iHoleNumber[0]	=	iLastData;
            strcpy( g_szHoleName[0], szLastName );
            dSetSpritePositionY( g_szHoleName[0], fLastPosY );

        }
        	if( g_fRotateTime > 0.f )
	{
		g_fRotateTime	-= 1.f;
		if( g_fRotateTime <= 0.f )
		{
			// 球杆旋转复位
			dSetSpriteRotation( "BallCue", g_fOldRotation );
		}
	}


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



// 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    dSetSpritePosition( "BallCue", fMouseX, fMouseY );
dShowCursor( 0 );


    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    if( 1 != iMouseType || 0 != g_iPlayState )
        return;
    g_iPlayState = 1;
     g_iGameState1=2;
    g_fRotateTime	=0.2f;
    dSetSpriteRotation( "BallCue", g_fOldRotation + 10.f );
    // 球的位置
    float	fPosX		=	dGetSpritePositionX( g_szBallName );
    float	fPosY		=	dGetSpritePositionY( g_szBallName );
    // 有A,B两点坐标,求两点间向量 ==> B减去A得到一条由A指向B的向量。
    // 下面的计算,得到一条鼠标坐标指向球坐标的向量
    float	fVectorX	=	fPosX - fMouseX;
    float	fVectorY	=	fPosY - fMouseY;
// 将该向量放大,得到我们想要的速度
    fVectorX	*= 12.f;
    fVectorY	*= 12.f;
    // 给球设置该速度,以及设置一个速度衰减系数,使其逐渐停止
    dSetSpriteLinearVelocity( g_szBallName, fVectorX, fVectorY );
    dSetSpriteDamping( g_szBallName, 1.6f );
    if( g_fRotateTime > 0.f )
    {
        g_fRotateTime	-=1.f;
        if( g_fRotateTime <= 0.f )
        {
            // 球杆旋转复位
            dSetSpriteRotation( "BallCue", g_fOldRotation );
        }
    }

    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);
    printf("@@@@");

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后,调用此函数
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName:发起碰撞的精灵名字
// 参数 szTarName:被碰撞的精灵名字
//
void dOnSpriteColSprite( const char *szSrcName, const char *szTarName )
{
    if( strcmp( szSrcName, g_szBallName )  ==  0  ||  strcmp( szTarName, g_szBallName ) == 0)
    {
        if( strstr( szSrcName, "VerSide" ) || strstr( szTarName, "VerSide" ) )
        {
            float	fVelX	=	dGetSpriteLinearVelocityX( g_szBallName );
            dSetSpriteLinearVelocityX( g_szBallName, fVelX * -1.f );
        }
        else if( strstr( szSrcName, "HorSide" ) || strstr( szTarName, "HorSide" ) )
        {
            float	fVelY	=	dGetSpriteLinearVelocityY( g_szBallName );
            dSetSpriteLinearVelocityY( g_szBallName, fVelY * -1.f );
        }
    }
    // 可以在此添加游戏需要的响应函数
    OnSpriteColSprite(szSrcName, szTarName);
}

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

4、 迷你高尔夫球

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"

#include<bits/stdc++.h>
const int GRID_COUNT=12;	// N * N 的矩阵方块,一个N的大小
const int MAX_LEVEL=3;	// 最大关卡数量。如果要增加关卡,请先修改此值
const int RIGID_BLOCK=1;	// 以下3个分别为方块阻挡物、黑洞、出口的值
const int BLACK_HOLE=2;
const int GOLF_EXIT=3;//游戏状态,0 -- 游戏结束等待开始状态;1 -- 初始化游戏;2 -- 游戏进行中
int	g_iGameState1	= 1;
int	g_iMoveState1	=  0;//控制球的移动状态:0当前静止,可以移动,1、2、3、4:代表上下左右4个	// 方向移动中,按键无响应
int	g_iCurLevel	=	1;	// 当前关卡
//第一块的起始坐标 =-(GRID_COUNT * g_fGridSize * 0.5 - g_fGridSize / 2)
float g_fGridStartX	=  -27.5f;
float g_fGridStartY	=  -27.5f;
float g_fGridSize =  5.f;	// 每块的大小,包括球、出口等都是此大小
int	g_iRigidBlockCount1;	// 本关卡创建的阻挡物方块数量
int	g_iBlackHoleCount1	;	// 本关卡创建的黑洞数量
int	g_iGolfExitCount1	=	0;	// 本关卡创建的出口的数量
int iControlStartX, iControlStartY;
//二维数组,存储当前关卡N*N的矩阵方块信息
int	g_iGridData[12][12];
int m_iLevelData1[GRID_COUNT][GRID_COUNT] =
{
    {0, 0, 0, 0,			0,				0,				0,				0,				0, 0, 0, 0},
    {0, 0, 0, 0,			0,				0,				0,				0,				0, 0, 0, 0},
    {0, 0, 0, 0,			0,				0,				0,				0,				0, 0, 0, 0},
    {0, 0, 0, RIGID_BLOCK,	RIGID_BLOCK,	RIGID_BLOCK,	RIGID_BLOCK,	RIGID_BLOCK,	RIGID_BLOCK, 0, 0, 0},
    {0, 0, 0, RIGID_BLOCK,	0,				0,				0,				0,				RIGID_BLOCK, 0, 0, 0},
    {0, 0, 0, RIGID_BLOCK,	0,				0,				0,				0,				RIGID_BLOCK, 0, 0, 0},
    {0, 0, 0, RIGID_BLOCK,	0,				0,				0,				0,				BLACK_HOLE, 0, 0, 0},
    {0, 0, 0, 0,			0,				0,				0,				GOLF_EXIT,		RIGID_BLOCK, 0, 0, 0},
    {0, 0, 0, 0,			0,				0,				0,				0,				0, 0, 0, 0},
    {0, 0, 0, 0,			0,				0,				0,				0,				0, 0, 0, 0},
    {0, 0, 0, 0,			0,				0,				0,				0,				0, 0, 0, 0},
    {0, 0, 0, 0,			0,				0,				0,				0,				0, 0, 0, 0}
};
const int m_iLevelData2[GRID_COUNT][GRID_COUNT]=
{
    {0, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, 0, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, RIGID_BLOCK, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, GOLF_EXIT, RIGID_BLOCK, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, RIGID_BLOCK, 0, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, 0, RIGID_BLOCK, 0}
};
const int m_iLevelData3[GRID_COUNT][GRID_COUNT]=
{
    {0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, RIGID_BLOCK, 0, 0},
    {0, 0, RIGID_BLOCK, RIGID_BLOCK, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, RIGID_BLOCK},
    {RIGID_BLOCK, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK},
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK},
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, GOLF_EXIT, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, RIGID_BLOCK, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, 0, 0, RIGID_BLOCK, 0, 0, 0, 0, 0, 0, RIGID_BLOCK, 0},
    {0, 0, 0, 0, BLACK_HOLE, RIGID_BLOCK, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};

int SpritePosXToIndexX ( const float fPosX )
{
    // 左右边界坐标值。g_fGridStartX是在方块的中心,所以需要减去半个方块的	   // 宽度才是左边边界
    const  float	fLeftSide	=	g_fGridStartX - g_fGridSize / 2.f;
    const  float	fRightSide  =  fLeftSide + g_fGridSize * GRID_COUNT;
    // printf("x:%f %f\n",fLeftSide,fRightSide );

    // printf("@#$%^&*()(111111");
    // 判断是否出了左右边界
    if( fPosX < fLeftSide || fPosX > fRightSide )
        return -1;
    int	iIndexX	=	(int)( (fPosX - fLeftSide) / g_fGridSize );
    return iIndexX;
}
int SpritePosYToIndexY( const float fPosY )
{
    // 上下边界坐标值。g_fGridStartY是在方块的中心,所以需要减去半个方块的	   // 宽度才是上边边界
    const	float	fTopSide	=	g_fGridStartY - g_fGridSize / 2.f;
    const	float	fBottomSide	=	fTopSide + g_fGridSize * GRID_COUNT;// 判断是否出了上下边界
    // printf("@#$%^&*()(2222222");
    // printf("y:%f %f\n",fTopSide,fBottomSide );
    if( fPosY < fTopSide || fPosY > fBottomSide )
        return -1;
    int	iIndexY	=	(int)( (fPosY - fTopSide) / g_fGridSize );
    return iIndexY;


}


void MoveSpriteToBlock( const char *szName, const int iIndexX, const int iIndexY )
{
    float	fPosX	=	g_fGridStartX + iIndexX * g_fGridSize;
    float	fPosY	=	g_fGridStartY + iIndexY * g_fGridSize;
    dSetSpritePosition( szName, fPosX, fPosY );
    int	iLoopX = 0, iLoopY = 0;
    for( iLoopY = 0; iLoopY < GRID_COUNT; iLoopY++ )
    {
        for( int iLoopX = 0; iLoopX < GRID_COUNT; iLoopX++ )
        {
            if( 0 == g_iGridData[iLoopY][iLoopX] )
                continue;
            if( RIGID_BLOCK == g_iGridData[iLoopY][iLoopX] )
            {
                szName	=	dMakeSpriteName( "RigidBlock", g_iRigidBlockCount1);
                dCloneSprite( "RigidBlockTemplate", szName );
                dSetSpritePosition( szName,	g_fGridStartX + iLoopX * g_fGridSize, g_fGridStartY + iLoopY * g_fGridSize );
                g_iRigidBlockCount1++;
                //printf("####1");
            }
            else if( BLACK_HOLE == g_iGridData[iLoopY][iLoopX] )
            {
                //如果是黑洞就建立黑洞
                szName	=	dMakeSpriteName( "BlackHole", g_iBlackHoleCount1 );
                dCloneSprite( "BlackHoleTemplate", szName );
                dSetSpritePosition( szName,	g_fGridStartX + iLoopX * g_fGridSize, g_fGridStartY + iLoopY * g_fGridSize );
                g_iBlackHoleCount1++;
                //printf("####2");
            }
            else if( GOLF_EXIT == g_iGridData[iLoopY][iLoopX] )
            {
                //如果是出口,就出去
                szName	=	dMakeSpriteName( "GolfExit", g_iGolfExitCount1 );
                dCloneSprite( "GolfExitTemplate", szName );
                dSetSpritePosition( szName,	g_fGridStartX + iLoopX * g_fGridSize, g_fGridStartY + iLoopY * g_fGridSize );
                g_iGolfExitCount1++;
                // printf("####3");
            }
            // printf("%s %f %f\n",szName,g_fGridStartX + iLoopX * g_fGridSize, g_fGridStartY + iLoopY * g_fGridSize );
        }
    }



}

void init()
{


    int		iLoop	= 0;
    char *szName = NULL;
    for( iLoop = 0; iLoop < g_iRigidBlockCount1; iLoop++ )
    {
        szName	=	dMakeSpriteName( "RigidBlock", iLoop );
        dDeleteSprite( szName );
    }
    for( iLoop = 0; iLoop < g_iBlackHoleCount1; iLoop++ )
    {
        szName	=	dMakeSpriteName( "BlackHole", iLoop );
        dDeleteSprite( szName );
    }
    for( iLoop = 0; iLoop < g_iGolfExitCount1; iLoop++ )
    {
        szName	=	dMakeSpriteName( "GolfExit", iLoop );
        dDeleteSprite( szName );
    }
}


///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;
    g_iMoveState1=0;
// 控制球在数组中的开始位置(出生点),该位置不能为0.根据关卡数据自行指定
    int	iControlStartX = 0, iControlStartY = 0;
    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("Lesson");

    g_iRigidBlockCount1=0;	// 本关卡创建的阻挡物方块数量
    g_iBlackHoleCount1	=0;	// 本关卡创建的黑洞数量
    g_iGolfExitCount1	=	0;	// 本关卡创建的出口的数量
    // 将控制的球和指示箭头摆放到出生点

    // 执行游戏主循环


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

        if( 0 != g_iMoveState1)
        {
            // 先将控制球精灵坐标转换到二维格子数组索引
            float	fPosX	=	dGetSpritePositionX( "ControlBall" );
            float	fPosY	=	dGetSpritePositionY( "ControlBall" );
            int		iIndexX	=	SpritePosXToIndexX( fPosX );
            int		iIndexY	=	SpritePosYToIndexY( fPosY );
            // 控制球已经出了边界,所以不需要再判断
            if( iIndexX < 0 || iIndexX >= GRID_COUNT || iIndexY < 0 || iIndexY >= GRID_COUNT )
                return 0;
            float	fNextPosX	=	fPosX;
            float	fNextPosY	=	fPosY;
            if( 1 == g_iMoveState1 )
            {
                fNextPosY -= g_fGridSize * 0.5f;
            }
            else if( 2 == g_iMoveState1 )
            {
                fNextPosY += g_fGridSize * 0.5f;
            }
            else if( 3 == g_iMoveState1 )
            {
                fNextPosX	-= g_fGridSize * 0.5f;
            }
            else if( 4 == g_iMoveState1 )
            {
                fNextPosX	+= g_fGridSize * 0.5f;
            }
            int	iNextIndexX	=	SpritePosXToIndexX( fNextPosX );
            int iNextIndexY	=	SpritePosYToIndexY( fNextPosY );
            // 该边缘已经出了边界,不需要往下判断
            if( iNextIndexX < 0 || iNextIndexX >= GRID_COUNT || iNextIndexY < 0 || iNextIndexY >= GRID_COUNT )
                return 0;
            if( RIGID_BLOCK == g_iGridData[iNextIndexY][iNextIndexX] )
            {
                // 清零移动状态
                g_iMoveState1 = 0;
                // 速度清零,显示指示箭头
                dSetSpriteLinearVelocity( "ControlBall", 0.f, 0.f );
                dSetSpriteVisible( "GolfArrow", 1 );
                // 把球和指示箭头设置在本方块的中心
                MoveSpriteToBlock( "ControlBall", iIndexX, iIndexY );
                MoveSpriteToBlock( "GolfArrow", iIndexX, iIndexY );
            }
            else if( BLACK_HOLE == g_iGridData[iNextIndexY][iNextIndexX] )
            {
                // 将游戏状态设置为1,重新开始关卡
                g_iGameState1	=	1;
            }
            else if( GOLF_EXIT == g_iGridData[iNextIndexY][iNextIndexX] )
            {
// 将游戏状态设置为1,开始新关卡
                g_iGameState1=	1;
// 往下一关卡,如果已经是最大值,则返回第一关
                g_iCurLevel++;
                if( g_iCurLevel > MAX_LEVEL )
                    g_iCurLevel = 1;
            }
        }
        if( g_iGameState1==1)
        {
            g_iGameState1=0;
            switch( g_iCurLevel )
            {
            case 2:
            {
                init();
                iControlStartX	=	5;
                iControlStartY	=	9;
                memcpy( g_iGridData, m_iLevelData2, sizeof(int) * GRID_COUNT *GRID_COUNT );

            }
            break;
            case 3:
            {
                init();
                iControlStartX	=	3;
                iControlStartY	=	6;
                memcpy( g_iGridData, m_iLevelData3, sizeof(int) * GRID_COUNT * GRID_COUNT );
            }
            break;
            // 如果要新增关卡,在此处增加case即可
            // case...
            // Level1 或者g_iCurLevel错误
            case 1:
            default:
            {
                init();
                iControlStartX	=	5;
                iControlStartY	=	6;
                memcpy( g_iGridData, m_iLevelData1, sizeof(int) * GRID_COUNT *GRID_COUNT );

                printf("case 1\n");
            }
            break;
            };
            dSetSpriteLinearVelocity( "ControlBall", 0.f, 0.f );
            MoveSpriteToBlock( "ControlBall", iControlStartX, iControlStartY );
            MoveSpriteToBlock( "GolfArrow", iControlStartX, iControlStartY );
            dSetSpriteVisible( "GolfArrow", 1 );

        }

        GameMainLoop( fTimeDelta );

    };


    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    // if( 2 != g_iGameState1 || 0 != g_iMoveState1 )
    //   return;

    //printf("dff");
    float	fPosX	=	dGetSpritePositionX( "ControlBall" );
    float	fPosY	=	dGetSpritePositionY( "ControlBall" );
    int		iIndexX	=	SpritePosXToIndexX( fPosX );
    int		iIndexY	=	SpritePosYToIndexY( fPosY );
    if( iIndexX < 0 || iIndexX >= GRID_COUNT || iIndexY < 0 || iIndexY >= GRID_COUNT )
        return;
    if( KEY_UP == iKey )
    {
        //printf("up:%f %f %d %d\n",fPosX,fPosY,iIndexX,iIndexY);
        if( iIndexY > 0 && RIGID_BLOCK == g_iGridData[iIndexY - 1][iIndexX] )
            return;
        // 给予控制球一个方向速度,并设置移动状态、隐藏指示箭头
        g_iMoveState1	=	1;
        dSetSpriteLinearVelocityY( "ControlBall", -31.f );
        dSetSpriteVisible( "GolfArrow", 0 );
    }
// TODO 按下方向键,控制球移动:
// 参考上面的if代码,完成下、左、右三个方向的控制代码
    else if( KEY_DOWN == iKey )
    {
        if( iIndexY < GRID_COUNT - 1 && RIGID_BLOCK == g_iGridData[iIndexY + 1][iIndexX] )
            return;
        // 给予控制球一个方向速度,并设置移动状态、隐藏指示箭头
        g_iMoveState1	=	2;
        dSetSpriteLinearVelocityY( "ControlBall", 31.f );
        dSetSpriteVisible( "GolfArrow", 0 );
    }
    else if( KEY_LEFT == iKey )
    {
        if( iIndexX > 0&&RIGID_BLOCK == g_iGridData[iIndexY][iIndexX -1])
            return;
        // 给予控制球一个方向速度,并设置移动状态、隐藏指示箭头
        g_iMoveState1	=	3;
        dSetSpriteLinearVelocityX( "ControlBall", -31.f );
        dSetSpriteVisible( "GolfArrow", 0 );
    }
    else if( KEY_RIGHT == iKey )
    {
        if(iIndexX<GRID_COUNT-1&&RIGID_BLOCK == g_iGridData[iIndexY][iIndexX + 1])
            return;
        // 给予控制球一个方向速度,并设置移动状态、隐藏指示箭头
        g_iMoveState1	=	4;
        dSetSpriteLinearVelocityX( "ControlBall", 31.f );
        dSetSpriteVisible( "GolfArrow", 0 );
    }

    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    if( KEY_UP == iKey )
    {
        dSetSpriteLinearVelocityY( "ControlBall", -0.f );
        dSetSpriteVisible( "GolfArrow", 0 );
    }
// TODO 按下方向键,控制球移动:
// 参考上面的if代码,完成下、左、右三个方向的控制代码
    else if( KEY_DOWN == iKey )
    {
        dSetSpriteLinearVelocityY( "ControlBall", 0.f );
        //dSetSpriteVisible( "GolfArrow", 0 );
    }
    else if( KEY_LEFT == iKey )
    {

        dSetSpriteLinearVelocityX( "ControlBall", 0.f );
        //dSetSpriteVisible( "GolfArrow", 0 );
    }
    else if( KEY_RIGHT == iKey )
    {

        dSetSpriteLinearVelocityX( "ControlBall", 0.f );
        //dSetSpriteVisible( "GolfArrow", 0 );
    }


    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

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

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后,调用此函数.
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName:碰撞到边界的精灵名字
// 参数 iColSide:碰撞到的边界 0 左边,1 右边,2 上边,3 下边
//
void dOnSpriteColWorldLimit( const char *szName, const int iColSide )
{
    // 只处理控制的球
    if( stricmp( szName, "ControlBall" ) != 0 )
        return;
    // 将游戏状态设置为1,重新开始关卡
    g_iGameState1=	1;

    // 可以在此添加游戏需要的响应函数
    OnSpriteColWorldLimit(szName, iColSide);
}


/*
RigidBlock0 -12.500000 -12.500000
RigidBlock1 -7.500000 -12.500000
RigidBlock2 -2.500000 -12.500000
RigidBlock3 2.500000 -12.500000
RigidBlock4 7.500000 -12.500000
RigidBlock5 12.500000 -12.500000
RigidBlock6 -12.500000 -7.500000
RigidBlock7 12.500000 -7.500000
RigidBlock8 -12.500000 -2.500000
RigidBlock9 12.500000 -2.500000
RigidBlock10 -12.500000 2.500000
BlackHole0 12.500000 2.500000
GolfExit0 7.500000 7.500000
x:l -30.000000 r 30.000000
y:up -30.000000 bottlem 30.000000
*/

5、弹弹堂

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include <stdio.h>
#include <stdlib.h>
#define	TARGET_COUNT	3	// 目标数目
// 目标被击中次数,被击中3次后死亡重新开始下回合
int	g_iTargetHit[TARGET_COUNT];
// 目标名字
char	g_szTargetName[TARGET_COUNT][32]	= {"DandanTarget1", "DandanTarget2", "DandanTarget3"};
// 最大旋转角度,也是初始角度
const float g_fMaxRotation=	350.f;
int g_iFireState1=0;
int g_iGameState1=0;
float g_fGunRotation=350.f;	// 炮的朝向
float g_fGunStrength=0.f;		// 炮的力度
int g_iCalStrength	=0;		// 1:空格键按下中,计算力度,力度渐增。0 :不计算力度
float g_fKeyUp=0.f;			// 上下键是否按下的变量:1按下0弹起,用于计算角度
float g_fKeyDown=0.f;
// 炮弹发射之后,给它一个向下的常力,使其形成一个抛物线弹道轨迹
const float g_fBumbForceY  =  10.f;
float	g_fRoundTime	 =  0.f;	// 炮弹发射之后,等待一定时间才开始下回合

int g_iCalRotation=0;

void ProcessBumbHit( const int iHitState, const char *szBumbName, const char *szTargetName )
{
    float fPosX=dGetSpritePositionX(szBumbName);
    float fPosY=dGetSpritePositionY(szBumbName);
    if(iHitState==1)
    {
        int iLoop = 0;
        for( iLoop = 0; iLoop < TARGET_COUNT; iLoop++ )
        {
            if( strcmp( g_szTargetName[iLoop], szTargetName ) == 0 )
            {
                g_iTargetHit[iLoop]++;
                if( 1 == g_iTargetHit[iLoop] )
                {
                    dAnimateSpritePlayAnimation(g_szTargetName[iLoop], 								"DandanTargetAnimation2", 0 );
                }
                else
                {
                    dAnimateSpritePlayAnimation(g_szTargetName[iLoop], 								"DandanTargetAnimation3", 0 );
                }
                // 隐藏
                if( g_iTargetHit[iLoop] >= 3 )
                    dSetSpriteVisible( g_szTargetName[iLoop], 0 );
                break;
            }
        }
    }
    if( 1 == iHitState ||2==  iHitState)
    {
        dPlayEffect( "BumbExplode", 1.f, fPosX, fPosY, 0.f );
    }

        dDeleteSprite(szBumbName);


}


///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;

    g_iFireState1=0;
    for(int i=0; i<TARGET_COUNT; i++)
    {
        int		iLoop = 0;
        float	fPosX = 0, fPosY = 0;
        for( iLoop = 0; iLoop < TARGET_COUNT; iLoop++ )
        {
            g_iTargetHit[iLoop]	=	0;
            // 在X方向上,目标在0-45范围内随机移动
            fPosX	=	dRandomRange( 0, 45 );
            fPosY	=	dGetSpritePositionY( g_szTargetName[iLoop] );
            dSpriteMoveTo( g_szTargetName[iLoop], fPosX, fPosY, 40.f, 1 );
            dSetSpriteVisible( g_szTargetName[iLoop], 1 );
            // 恢复初始动画/图片
            dAnimateSpritePlayAnimation( g_szTargetName[iLoop], 									"DandanTargetAnimation1", 0 );
        }
        g_iTargetHit[iLoop]	=	0;
    }
    g_fGunRotation=g_fMaxRotation;  // 炮台的初始角度为最大角度
    g_fGunStrength=0.f;

    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("Lesson");

    // 引擎主循环,处理屏幕图像刷新等工作
    while( dEngineMainLoop() )
    {
        // 获取两次调用之间的时间差,传递给游戏逻辑处理
        float	fTimeDelta	=	dGetTimeDelta();
        if(g_iFireState1==0)
        {

            g_fGunRotation+=15.f*fTimeDelta*(g_fKeyDown-g_fKeyUp);
            g_fGunRotation=min(g_fGunRotation,g_fMaxRotation);
            g_fGunRotation=max(g_fGunRotation,280.f);
            if(g_iCalStrength)
            {
                g_fGunStrength+=50.f*fTimeDelta;
                if(g_fGunStrength>200.f)
                {
                    g_fGunStrength=200.f;
                }
            }
        }
        else
        {
           g_iFireState1=0;
           g_fGunStrength=0;
          // printf("@\n");
        }
        //  printf("1\n");
        float fOldPosX=dGetSpriteLinkPointPosX("DandanGun",1);
        float fOldPosY=dGetSpriteLinkPointPosY("DandanGun",1);
        float fNewPosX=0.f;
        float fNewPosY=0.f;
        float fMass=dGetSpriteMass("BumbTemplate");
        float	fVelocityX  =  dRotationToVectorX( g_fGunRotation ) * g_fGunStrength;
        float	fVelocityY  =  dRotationToVectorY( g_fGunRotation ) * g_fGunStrength;
        float	fHalfTime	=	fVelocityY / (g_fBumbForceY / fMass);
        float	fForceVelY	=	g_fBumbForceY / fMass;
        float	fTime		=	0.f;
        float	fSimDelta	=	0.0333f;
        //printf("g_fGunStrength %f\n",g_fGunStrength);
        //printf("fMass %f\n",fMass);
        //printf("fVelocityY %f\n",fVelocityY);
        //printf("fVelocityX %f\n",fVelocityX);
        //printf("fHalfTime :%f\n",fHalfTime);
        for( fTime = 0.f; fTime < fHalfTime; fTime += fSimDelta )
        {
            fNewPosX	=	fOldPosX + fVelocityX * fSimDelta;
            fNewPosY	=	fOldPosY + (fVelocityY + fForceVelY * fTime) * fSimDelta;
            // 画线
            dDrawLine( fOldPosX, fOldPosY, fNewPosX, fNewPosY, 2.f, 0, 0, 255, 0, 255 );
            //printf("2\n");
            fOldPosX = fNewPosX;
            fOldPosY = fNewPosY;
        }
        dSetSpriteRotation("DandanGun", g_fGunRotation);
        dSetTextValue( "DegreeText", g_fGunRotation );
        dSetTextValue( "StrengthText", g_fGunStrength );

    };

    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{

    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if( 0 == g_iFireState1 )
    {
        if(KEY_SPACE == iKey )
            g_iCalStrength=1;
    }
        if( KEY_UP == iKey)
            g_fKeyUp=1;
        if( KEY_DOWN == iKey)
            g_fKeyDown=1;



    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    //1)	判断空格键是否弹起,并且还有游戏的状态,开火的状态信息
    if( KEY_SPACE == iKey  && 0== g_iFireState1 )
    {
        g_iFireState1=1;
        g_iCalStrength=0;
        g_fRoundTime=3.f;
        float fPosX=dGetSpriteLinkPointPosX("DandanGun",1);
        float fPosY=dGetSpriteLinkPointPosY("DandanGun",1);
        int	iLoop = 0 ;
        float	fGunRotation	= g_fGunRotation - 10.f;
        float	fGunStrength	= g_fGunStrength - 10.f;
        char	*szName	 =	NULL;
        for( iLoop = 0; iLoop < 3; iLoop++ )
        {
            szName	=	dMakeSpriteName( "DandanBumb", iLoop );
            dCloneSprite( "BumbTemplate", szName );
            dSetSpritePosition( szName, fPosX, fPosY );
            dSetSpriteLinearVelocityPolar( szName, g_fGunStrength, fGunRotation );//按照角度朝向设置精灵速度
//我们要模拟的是真实的炮弹,弹道轨迹是一个抛物线,所以我们需要给	//炮弹一个向下的力量(回忆下物理课: 抛物线是如何产生的?)
            dSetSpriteConstantForceY( szName, g_fBumbForceY );
            fGunRotation += 10.f;
            fGunStrength += 10.f;
        }
    }
    if( KEY_DOWN == iKey)
        g_fKeyDown=0;
    if( KEY_UP == iKey)
        g_fKeyUp=0;
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后,调用此函数
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName:发起碰撞的精灵名字
// 参数 szTarName:被碰撞的精灵名字
//
void dOnSpriteColSprite( const char *szSrcName, const char *szTarName )
{

    if(strstr(szSrcName,"DandanBumb"))
    {
        if(strstr(szTarName,"DandanTarget"))
        {
            ProcessBumbHit(1,szSrcName,szTarName);
        }
        else
        {
            ProcessBumbHit(2,szSrcName,"");
        }

    }
    else if(strstr(szTarName,"DandanBumb"))
    {
        if(strstr(szSrcName,"DandanTarget"))
        {
            ProcessBumbHit(1,szSrcName,szTarName);
        }
        else
        {
            ProcessBumbHit(2,szSrcName,"");
        }


    }
    // 可以在此添加游戏需要的响应函数
    OnSpriteColSprite(szSrcName, szTarName);
}

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

6、拍飞虫

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include<stdio.h>
bool  	g_bStart       =  false; //// true:一局游戏开始,一局false:游戏结束。
int   	g_iGameScore  =	0;//用来记录本局游戏得分
float	g_fGameTime  =	30;//用来记录每局游戏剩余的时间
float 	g_fOldRotation  =  0.f;
float 	g_fRotateTime	 =	0.f;//用来记录拍子距离复位的剩余时间
float		g_fScreenLeft		=	0.f;    // 屏幕左边界值
float		g_fScreenRight		=	10.f;   // 右
float		g_fScreenTop		=	0.f;    // 上
int g_iCount;
float		g_fScreenBottom		=	10.f;   // 下
int iHighScore[5] = {0, 0, 0, 0, 0};
int g_kk;
struct	FlyBug
{
    char		szName[128];	//	飞虫名字
    int			iScore;			//	分数值
    int f;
} FlyBugs[20];
void AddFlyBugs()
{
    for(int i=1; i<=12; i++)
    {
        sprintf(FlyBugs[g_iCount].szName, "feichong_%d", g_iCount);
        FlyBugs[g_iCount].iScore = 1;
          FlyBugs[g_iCount].f = 1;
        g_iCount++;
    }
    for(int i=13;i<=15;i++)
    {
         sprintf(FlyBugs[g_iCount].szName, "feichong_%d", g_iCount);
        FlyBugs[g_iCount].iScore = 2;
         FlyBugs[g_iCount].f = 1;
        g_iCount++;
    }

}
void Flying(char *szName)
{
    int iDir = 0;
    iDir = dRandomRange(0,3);
    float dx=0,dy=0;
    switch(iDir)
    {
    case 0: // 左方
        dx=dRandomRange(g_fScreenLeft-5.f, g_fScreenLeft);
        dy=dRandomRange(g_fScreenBottom+5.f, g_fScreenTop-5.f);
//dSetSpritePosition(szName,dx,dy);
        break;
    case 1: // 下方
        dx=dRandomRange(g_fScreenLeft-5.f, g_fScreenRight+5.f);
        dy=dRandomRange(g_fScreenBottom, g_fScreenBottom+0.5f);
        // dSetSpritePosition(szName,dx,dy);
        break;
    case 2: // 右方
        dx=dRandomRange(g_fScreenRight-5.f, g_fScreenRight);
        dy=dRandomRange(g_fScreenBottom+5.f, g_fScreenTop-5.f);
        // dSetSpritePosition(szName,dx,dy);
        break;
    case 3: // 上方
        dx=dRandomRange(g_fScreenLeft-5.f, g_fScreenRight+5.f);
        dy=dRandomRange(g_fScreenTop-5.f, g_fScreenTop);

        break;
    }
    float dvx=dRandomRange(5,30);
    float dvy=dRandomRange(5,30);
    dSetSpritePosition(szName,dx,dy);
    dSetSpriteLinearVelocity(szName,dvx,dvy);

}
int cmp(const void *x,const void *y)
{
    return (int)x>(int)y;
}
///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;

    g_fScreenLeft	=dGetScreenLeft()-10;    // 屏幕左边界值
    g_fScreenRight	=	dGetScreenRight()+10;   // 右
    g_fScreenTop=dGetScreenTop()-10;    // 上
    g_fScreenBottom=dGetScreenBottom()+10;
    g_fOldRotation = dGetSpriteRotation("paizi");
    // printf("%f",g_fOldRotation);
    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("Lesson");

    // 引擎主循环,处理屏幕图像刷新等工作
    while( dEngineMainLoop() )
    {
        // 获取两次调用之间的时间差,传递给游戏逻辑处理
        float	fTimeDelta	=	dGetTimeDelta();
         dSetTextValue("score",g_iGameScore);
        // 执行游戏主循环
        if(g_bStart)  // 游戏开始
        {
            g_fGameTime -= fTimeDelta;

            if(g_fGameTime > 0)  // 游戏进行中
            {
                dSetTextValue("Time",g_fGameTime);
                //Score
            }
            else  // 一局游戏时间到
            {
                g_bStart = false;  // 设置游戏进入结束状态
            }
            if(g_fRotateTime>0)
            {
                g_fRotateTime-=fTimeDelta;
                if(g_fRotateTime <= 0)
                {
                    dSetSpriteRotation("paizi", g_fOldRotation);
                }
            }
            if(g_iCount==0)
            {
                if(g_iGameScore> iHighScore[4])
                {
                     iHighScore[4]=g_iGameScore;
                }
               // qsort(iHighScore,4,sizeof(int),cmp);
            }
        }
        else // 游戏结束
        {
            if(g_kk==0) continue;
            else
            {


            g_fGameTime=30;
            dDeleteSprite("feichong_0");
            if(  g_iGameScore>iHighScore[3])
                iHighScore[4]=  g_iGameScore;
             qsort(iHighScore,5,sizeof(int),cmp);
             for(int i=0;i<=4;i++)
             {
                  dSetTextValue(dMakeSpriteName("Score",i),iHighScore[i]);
                 //Score0
             }
             for(int i=0;i<g_iCount;i++)
             {

                      dDeleteSprite( FlyBugs[i].szName );

             }
             dSetSpriteVisible("kaishi",1);
            }
           //
        }


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

    };

    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{

    if(g_bStart)
    {
        dSetSpritePosition( "paizi", fMouseX, fMouseY );

    }
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    if(g_bStart)
    {
        if(iMouseType==1)
        {
            dSetSpriteRotation("paizi",10.f);
            g_fRotateTime=0.2f;
        }
        for(int i=0; i<g_iCount; i++)
        {
            float dchongx=dGetSpritePositionX(FlyBugs[i].szName);
            float dchongy=dGetSpritePositionY(FlyBugs[i].szName);

            if(dIsPointInSprite( "paizi", dchongx,dchongy ))
            {
                dSetSpriteVisible( FlyBugs[i].szName, 0 );
                g_iGameScore += FlyBugs[i].iScore;
                 FlyBugs[g_iCount].f = 0;
               // printf("f:%d all:%d\n",FlyBugs[i].iScore,g_iGameScore);
                //Flying( FlyBugs[i].szName);
            }
        }
    }

    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if(iKey==KEY_SPACE&&g_bStart ==0)
    {
        g_kk++;
        g_bStart =1;
        //kaishi
        dSetSpriteVisible("kaishi",0);
        //feichong_muban1
        AddFlyBugs();
        for(int i=0; i<12; i++)
        {
            dCloneSprite("feichong_muban1",FlyBugs[i].szName);
            dSetSpriteWorldLimit(FlyBugs[i].szName, WORLD_LIMIT_BOUNCE,g_fScreenLeft,g_fScreenTop, g_fScreenRight, g_fScreenBottom );
            Flying(FlyBugs[i].szName);
        }
        for(int i=12;i<g_iCount;i++)
        {
             dCloneSprite("feichong_muban2",FlyBugs[i].szName);
            dSetSpriteWorldLimit(FlyBugs[i].szName, WORLD_LIMIT_BOUNCE,g_fScreenLeft,g_fScreenTop, g_fScreenRight, g_fScreenBottom );
            Flying(FlyBugs[i].szName);
        }

    }
    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);

}

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

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

7、黄金矿工

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include<stdio.h>
int g_fGoldBornMinX	=	0;
int	g_fGoldBornMaxX	=	0;
int	g_fGoldBornMinY	=	0;
int	g_fGoldBornMaxY	=	0;
int g_iGoldCount	=	0;
float g_fHookRotation = 0.f;	//钩子与地面的夹角
const float	fRotateSpeed = 45.f; 	//  摇摆速度,单位 度/秒
int iHookRotToLeft = 1;			//钩子摆动的方向:1 ← ;0 →
int g_iGameState1 = 0;//游戏状态,0表示钩子旋转,1表示释放绳索,后面还会定义其他状态
float g_fEmptyHookSpeed	= 15.f;
float g_fHookStartPosX;	//存储钩子的初始X位置
float g_fHookStartPosY;	//存储钩子的初始Y位置
char szGotGoldName[20]	;	//当前抓到金子的名称

void Gameinit()
{

}
///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;

    dSetWindowTitle("黄金矿工");
    g_iGoldCount=20;	//金子数量
    g_fGoldBornMinX		=	dGetScreenLeft() + 5;		//金子左边界
    g_fGoldBornMaxX		=	dGetScreenRight() - 5;		//金子右边界
    g_fGoldBornMinY		=	dGetScreenTop() + 20;		//金子上边界
    g_fGoldBornMaxY		=	dGetScreenBottom() - 5;	//金子下边界
    int	iLoop	=	0;	//循环变量控制
    int	iSize	=	4, iPosX = 0, iPosY = 0; //iSize表示金块大小的变量
    dSetSpriteCollisionSend("goldHook", 1);
    dSetSpriteCollisionReceive("goldTemplate", 1);
    g_fHookStartPosX = dGetSpritePositionX("GoldHook");	//获取钩子的初始X坐标
    g_fHookStartPosY = dGetSpritePositionY("GoldHook");	//获取钩子的初始Y坐标
    //dSetSpriteWorldLimitMode("goldHook", WORLD_LIMIT_NULL);
    for( iLoop = 0; iLoop < g_iGoldCount; iLoop++ )
    {
        if( iLoop < 10 )		//生成10个小金块,大小为4
        {
            iSize	=	4;
        }
        else if( iLoop >= 10 && iLoop < 16 )	//生成6个中金块,大小为6
        {
            iSize	=	6;
        }
        else			//生成4个大金块,大小为8
        {
            iSize	=	8;
        }
        //初始化金子精灵实例
        char *tmpName;
        tmpName=dMakeSpriteName("GoldBlock",iLoop);	//生成金块名字
        //printf("%s",tmpName);
        dCloneSprite("goldTemplate",tmpName);
        dSetSpriteWidth(tmpName,(float)iSize);			//设置金块的宽度
        dSetSpriteHeight(tmpName,(float)iSize);			//设置金块的高度
        //设置金子精灵位置
        iPosX	=	dRandomRange(g_fGoldBornMinX, g_fGoldBornMaxX);
        iPosY	=	dRandomRange(g_fGoldBornMinY, g_fGoldBornMaxY);
        dSetSpritePosition(tmpName,(float)iPosX, (float)iPosY);
    }

    dSetSpritePosition("GameBegin", 0,5);
    // 引擎主循环,处理屏幕图像刷新等工作
    while( dEngineMainLoop() )
    {
        // 获取两次调用之间的时间差,传递给游戏逻辑处理
        float	fTimeDelta	=	dGetTimeDelta();

        if(g_iGameState1 == 1)
        {
            float fThisRotate =	fRotateSpeed * fTimeDelta;
            if( iHookRotToLeft )
            {
                g_fHookRotation	+= fThisRotate;
                if( g_fHookRotation >= 180.f )
                {
                    g_fHookRotation		=	180.f;
                    iHookRotToLeft	=	0;
                }
            }
            else
            {
                g_fHookRotation	-= fThisRotate;
                if( g_fHookRotation <= 0.f )
                {
                    g_fHookRotation		=	0.f;
                    iHookRotToLeft	=	1;
                }
            }
            dSetSpriteRotation("GoldHook",g_fHookRotation);
        }
        if(g_iGameState1 == 2||g_iGameState1 == 3)
        {
            // 首先,从矿工精灵上获取一个缆绳链接点作为绳子的起始点(该链接点在编辑器里编辑好)
            float fStartX =	dGetSpriteLinkPointPosX("GoldMan",1);
            float fStartY = dGetSpriteLinkPointPosY("GoldMan",1);
            // 绳子终点在钩子精灵上获取(该链接点在编辑器里编辑好)
            float fEndX	= dGetSpriteLinkPointPosX("GoldHook",1);
            float fEndY	= dGetSpriteLinkPointPosY("GoldHook",1);
            // 在这两点之间划线.线的颜色红绿蓝值都为50,即灰色;255表示不透明,2.0f表示线的粗细,	0表示所在的层
            dDrawLine(fStartX, fStartY, fEndX, fEndY, 2.f, 0, 50, 50, 50, 255 );

        }
        if(g_iGameState1 == 3)
        {
//获取钩子X方向的速度
            float	fSpeedX	=	dGetSpriteLinearVelocityX("GoldHook");
//获取钩子Y方向的速度
            float	fSpeedY	=	dGetSpriteLinearVelocityY("GoldHook");
//当速度接近为0时,即可判定其已到达初始点
            if( fSpeedX < 0.00001f && fSpeedX > -0.00001f && fSpeedY < 0.00001f && fSpeedY > -0.00001f )
            {
//解除金块与钩子的锚定
                dSpriteDismount(szGotGoldName);
//删除获取的金块
                dDeleteSprite(szGotGoldName);
//回拉结束,设定状态为0
                g_iGameState1 = 1;
//播放矿工的动画,即准备拉金子的动画
                dAnimateSpritePlayAnimation("GoldMan","GolderManAnimation2", 0 );
            }
        }


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

    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if(iKey==KEY_SPACE&&g_iGameState1==0)
    {
        g_iGameState1=1;
        dSetSpriteVisible( "GameBegin", 0 );
        //GameBegin
    }
    if( KEY_DOWN == iKey &&  g_iGameState1 == 1)
    {
        g_iGameState1 = 2;		//置游戏状态为1,可用于控制钩子是否摆动
        // 以当前朝向给钩子一个向前的速度
        dSetSpriteLinearVelocityPolar("GoldHook",g_fEmptyHookSpeed, g_fHookRotation);
        // 播放挖金者的动作(一个胳膊往下压的动作)
        dAnimateSpritePlayAnimation("GoldMan","GolderManAnimation1", 0);
//0 表示播放一次,这里胳膊往下压就是一次
    }

    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后,调用此函数
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName:发起碰撞的精灵名字
// 参数 szTarName:被碰撞的精灵名字
//
void dOnSpriteColSprite( const char *szSrcName, const char *szTarName )
{


        dSpriteMountToSpriteLinkPoint( szTarName, "GoldHook", 2 );//将金块锚定在钩子上
        dSpriteMoveTo("GoldHook",g_fHookStartPosX, g_fHookStartPosY, g_fEmptyHookSpeed, 1);	//使钩子向初始位置移动,即会拉
        dAnimateSpritePlayAnimation("GoldMan","GolderManAnimation3", 1 );	//播放拉金块的动作
        strcpy(szGotGoldName,szTarName);	//复制并保存当前抓取到金块的名称
        g_iGameState1 = 3;			//表示绳索回拉





    // 可以在此添加游戏需要的响应函数
    OnSpriteColSprite(szSrcName, szTarName);
}

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后,调用此函数.
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName:碰撞到边界的精灵名字
// 参数 iColSide:碰撞到的边界 0 左边,1 右边,2 上边,3 下边
//
void dOnSpriteColWorldLimit( const char *szName, const int iColSide )
{

//碰到边界的为钩子时
        dSpriteMoveTo(szName,g_fHookStartPosX, g_fHookStartPosY, g_fEmptyHookSpeed, 1);
        dAnimateSpritePlayAnimation("GoldMan","GolderManAnimation3", 1 );
//同样设置为回拉,只是没有碰到金子
        g_iGameState1 = 3;


    // 可以在此添加游戏需要的响应函数
    OnSpriteColWorldLimit(szName, iColSide);
}

8、打飞碟

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include <stdio.h>
#include<stdlib.h>
#include<math.h>
#define PI 3.141592653589793f
int g_GameState=0;
int g_iNum = 0;	//发射的炮弹数量,没发射一枚加1
//飞碟的数量
int g_iCount = 0;
//三种飞碟的间隔时
float g_fBaseTime[3] = {1.7f, 3.5f, 5.2f};
float g_fCurrentTime[3] = {1.7f, 3.5f, 5.2f} ;
//三种飞碟的速度
float g_fSpeed[3] = {10, 15, 25};
//三种飞碟对应的名字前缀
char g_szType[3][20] = {"ufo_muban0","ufo_muban1","ufo_muban2"};
int g_iGameScore = 0;		//游戏得分
int g_iScore[3] = {1, 2, 5};
float g_time=30.f;
///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;
    float fScreenLeft = dGetScreenLeft();
    float fScreenRight = dGetScreenRight() ;
    float fScreenTop = dGetScreenTop() ;

    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("打飞碟");
    dShowCursor(false);


    // 引擎主循环,处理屏幕图像刷新等工作
    while( dEngineMainLoop() )
    {
        // 获取两次调用之间的时间差,传递给游戏逻辑处理
        float	fTimeDelta	=	dGetTimeDelta();
        //CurScoreText
        if(g_GameState==1)
        {
            g_time-=fTimeDelta;
            if(g_time<0)
            {
                g_time=30.f;
                g_GameState=0;
                dSetSpriteVisible("kaishi",1);
            }
            dSetTextValue( "TimeText",  g_time);

            dSetTextValue( "CurScoreText", g_iGameScore );


            float fPosX,fPosY;
            char *szName;
//飞碟出现的Y坐标固定在距窗口顶部5处
            fPosY = fScreenTop - 5.f;
            for(int i=0; i<3; i++)
            {
//思考:g_fCurrentTime的作用是什么?
                g_fCurrentTime[i] -= fTimeDelta;
                if(g_fCurrentTime[i] <= 0)
                {
                    g_fCurrentTime[i] = g_fBaseTime[i];
                    //重新设置下次飞碟产生的时间
                    fPosX = dRandomRange(fScreenLeft + 5, fScreenRight - 5);
                    fPosY= fScreenTop - 5.f;
//随机生成飞碟的横坐标
                    if(i == 0)
                    {
//i == 0时,对应big
                        szName =dMakeSpriteName("ufo_big",g_iCount++);
                    }
                    else if(i == 1)
                    {
//i== 1时,对应medium
                        szName =dMakeSpriteName("ufo_medium",g_iCount++);
                    }
                    else if(i == 2)
                    {
//i == 2时,对应small
                        szName =dMakeSpriteName("ufo_small",g_iCount++);
                    }
                    dCloneSprite(g_szType[i],szName);	//复制对应的模板
                    dSetSpritePosition(szName,fPosX, fPosY);
                    dSetSpriteLinearVelocityY(szName,g_fSpeed[i]);
//思考:程序是如何为不同的飞碟设置不同的速度名字和模板的?
                }
            }
        }


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

    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    float fX = dGetSpritePositionX("dapao");
    float fY = dGetSpritePositionY("dapao");
    float  fRotation	;	//炮口和X轴正方向的夹角
    float  ftan =atan2((fMouseY-fY),(fMouseX-fX));	//鼠标和大炮的连接线和X轴的夹角
    fRotation=180*ftan/PI; 	//弧度制转换为角度

    if(fRotation<0)
        fRotation+=360;
//思考:为何要加上360度
    if(fRotation>90 && fRotation<180)	//限制炮口角度
        fRotation = 90;
    else if(fRotation >= 180 && fRotation<270)	//限制炮口角度
        fRotation = 270;
    dSetSpriteRotation("dapao",fRotation);	//设置炮口转向

    //最后再将鼠标位置赋给准心:
    dSetSpritePosition("zhunxing",fMouseX,fMouseY);
    //zhunxing
//思考:将鼠标位置给准心应添加在哪里
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    if(iMouseType == MOUSE_LEFT)
    {
        //鼠标左键按下
        float fPosX, fPosY;
        //获得大炮链接点位置,作为炮弹起点
        fPosX = dGetSpriteLinkPointPosX("dapao",1);
        fPosY = dGetSpriteLinkPointPosY("dapao",1);
        char *szName;
        szName = dMakeSpriteName("paodan_%d", g_iNum++);		//得到炮弹名字
        dCloneSprite("paodan_muban",szName);		//复制炮弹模板
        dSetSpritePosition(szName,fPosX, fPosY);
        dSpriteMoveTo(szName,fMouseX, fMouseY, 50, false);
//思考: dSpriteMoveTo中的参数false的作用是什么
        dPlayEffect("Gunfire",0.2,fPosX, fPosY, 0.f);	//播放特效
    }

    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{


    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if(iKey==KEY_SPACE&&g_GameState==0)
    {
        g_GameState=1;
        dSetSpriteVisible("kaishi",0);
        //kaishi
    }
    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后,调用此函数
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName:发起碰撞的精灵名字
// 参数 szTarName:被碰撞的精灵名字
//
void dOnSpriteColSprite( const char *szSrcName, const char *szTarName )
{
    //如果碰撞的不是模板
    if(strstr(szSrcName,"muban")==NULL || strstr(szTarName,"muban")==NULL )
    {
//如果碰撞的是炮弹和飞碟
        if(strstr(szSrcName, "paodan") && strstr(szTarName,"ufo"))
        {
            //根据名字确定飞碟的类型
            int type = -1;
            if(strstr(szTarName,"big")!=NULL)
            {
                type = 0;
            }
            else if(strstr(szTarName,"medium")!=NULL)
            {
                type = 1;
            }
            else if(strstr(szTarName,"small")!=NULL)
            {
                type = 2;
            }
            else
            {
                //如果不是这三种类型,直接返回,return直接跳出函数,不再执行后续代码
                return;
            }
//思考:type 0,1,2的含义是什么?
            float fPosX = dGetSpritePositionX(szSrcName);
            float fPosY	= dGetSpritePositionY(szSrcName);
            dPlayEffect("BumbExplode",0.2,fPosX,fPosY, 0.f );	//在爆炸位置播放特效
            dDeleteSprite(szSrcName);		//删除炮弹
            dDeleteSprite(szTarName);		//删除飞碟
            g_iGameScore += g_iScore[type];	//累加游戏积分
            dSetTextValue("score",g_iGameScore);


        }
    }


    // 可以在此添加游戏需要的响应函数
    OnSpriteColSprite(szSrcName, szTarName);
}

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后,调用此函数.
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName:碰撞到边界的精灵名字
// 参数 iColSide:碰撞到的边界 0 左边,1 右边,2 上边,3 下边
//
void dOnSpriteColWorldLimit( const char *szName, const int iColSide )
{

//如果碰到世界边界的不是模板
    if(strstr(szName,"ufo")!=NULL && iColSide == 3)
    {
//3表示下边界
        dDeleteSprite(szName);
    }
    else if(strstr(szName,"paodan_muban")!=NULL)
    {
        dDeleteSprite(szName);
    }


    // 可以在此添加游戏需要的响应函数
    OnSpriteColWorldLimit(szName, iColSide);
}

9、太空战机

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include <stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX_NAME_LEN  128 		// 名字的最大长度
#define	CONTROL_MAX_HP 1000	// 我方战机的最大生命值是1000
#define BULLET_DAMAGE_1 100		// 子弹1的伤害值是100
#define VER_MIN_CREATE	1
#define VER_MAX_CREATE	6
int g_GameState;
int g_iCreatedSpriteCount=0;
float g_fWorldLeft,g_fWorldRight,g_fWorldTop,g_fWorldBottom;
float g_fVelocityLeft,g_fVelocityRight,g_fVelocityTop,g_fVelocityBottom;
float g_vy=0.f,g_vx=0.f;
int g_kw,g_ka,g_ks,g_kd;
char s[20]="mybullet";
char t[20]="badbullet";
float g_hittime=2.f;
float g_t=5.f;
int g_score;
int g_last=10;
int g_max=0;
///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;

    dSetSpriteCollisionSend(s, 1);
    dSetSpriteCollisionSend(t, 1);
    dSetSpriteCollisionReceive("ControlSprite", 1);
    dSetSpriteCollisionReceive("VerticalSprite_Template", 1);
    //  dSetSpriteWorldLimitMode(s, WORLD_LIMIT_NULL);
    // dSetSpriteWorldLimitMode(t,WORLD_LIMIT_NULL);
    // To do : 在此使用API更改窗口标题
    dSetWindowTitle("Lesson");
    dSetSpriteLinearVelocity("VerticalSprite_Template",-2,0);
    // 引擎主循环,处理屏幕图像刷新等工作

    while( dEngineMainLoop() )
    {
        // 获取两次调用之间的时间差,传递给游戏逻辑处理
        float	fTimeDelta	=	dGetTimeDelta();
        //CurScoreText
        if(g_last<=0)
        {
            g_GameState=0;
            freopen("in.txt","r",stdin); //输入重定向,输入数据将从in.txt文件中读取
            int a[10]={0},cnt=0;
            while(~scanf("%d",&a[cnt++])) {}
            if(g_score>a[cnt-1]) a[cnt-1]=g_score;
            for(int j=0; j<cnt; j++)
            {
                for(int k=j; k<cnt; k++)
                {
                    if(a[j]<a[k])
                    {
                        int temp=a[k];
                        a[k]=a[j];
                        a[j]=temp;
                    }
                }
            }
            g_max=a[0];
            freopen("in.txt","w",stdout); //输出重定向,输出数据将保存在out.
            for(int i=0;i<5;i++)
                printf("%d ",a[i]);
            fclose(stdin);//关闭文件
    fclose(stdout);//关闭文


        }
        dSetTextValue("CurScoreText",g_score);
        if(g_GameState)
        {
            g_hittime-=fTimeDelta;
            float dxchuan=dGetSpritePositionX("ControlSprite");
            float dychuan=dGetSpritePositionY("ControlSprite");
            float dxnow=dGetSpritePositionX("VerticalSprite_Template");
            float dynow=dGetSpritePositionY("VerticalSprite_Template");
            if(g_hittime<0)
            {
                g_hittime=2.f;

                dCloneSprite("Bullet2_Template",t);
                float dx=dxchuan-dxnow;
                float dy=-dynow+dychuan;
                dSetSpritePosition(t,dxnow,dynow);
                dSetSpriteLinearVelocity(t,dx,dy);
                //dRotationToVectorX();
            }
            g_t-=fTimeDelta;
            if(g_t<0)
            {
                g_t=5.f;
                if( dynow>0)
                    dSetSpriteLinearVelocity("VerticalSprite_Template",-3,-5);
                if( dynow<0)
                    dSetSpriteLinearVelocity("VerticalSprite_Template",-3,5);
            }

            //printf("1\n");
        }


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

    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{

    // 可以在此添加游戏需要的响应函数
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{
    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if(iKey==KEY_SPACE&&g_GameState==0)
    {
        g_GameState=1;
        dSetSpriteVisible( "GameBegin", false );

    }
    if(g_GameState)
    {

        if(iKey==KEY_W)
            g_vy=-10.f;
        if(iKey==KEY_A)
            g_vx=-10.f;
        if(iKey==KEY_S)
            g_vy=10.f;
        if(iKey==KEY_D)
            g_vx=10.f;
        dSetSpriteLinearVelocity("ControlSprite",g_vx,g_vy);
    }
    if(g_GameState)
    {
        if(iKey==KEY_SPACE)
        {
            float x_ship=dGetSpritePositionX("ControlSprite");
            float y_ship=dGetSpritePositionY("ControlSprite");
            //dMakeSpriteName(,)
            dSetSpritePosition(s,x_ship,y_ship);
            dSetSpriteLinearVelocity(s,g_vx+50,g_vy);
            dSetSpriteConstantForceY(s,10.f);
            dCloneSprite("Bullet1_Template",s);
            //dCloneSprite("Bullet2_Template",t);
            //printf("1\n");
        }
    }
    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    if(g_GameState)
    {

        if(iKey==KEY_W)
            g_kw=0;
        if(iKey==KEY_A)
            g_ka=0;
        if(iKey==KEY_S)
            g_ks=0;
        if(iKey==KEY_D)
            g_kd=0;

    }
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后,调用此函数
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName:发起碰撞的精灵名字
// 参数 szTarName:被碰撞的精灵名字
//
void dOnSpriteColSprite( const char *szSrcName, const char *szTarName )
{

    if(strcmp(szTarName,"VerticalSprite_Template")==0&&strcmp(szSrcName,s)==0)
    {

        //printf("1\n");
        float fPosX = dGetSpritePositionX("VerticalSprite_Template");
        float fPosY	= dGetSpritePositionY("VerticalSprite_Template");
        dPlayEffect("enemyExplode",0.2,fPosX,fPosY, 0.f );	//在爆炸位置播放特效
        g_score++;
    }
    if(strcmp(szSrcName,t)==0&&strcmp(szTarName,"ControlSprite")==0)
    {
        //printf("2\n");
        float fPosX = dGetSpritePositionX("ControlSprite");
        float fPosY	= dGetSpritePositionY("ControlSprite");
        dPlayEffect("playerExplode",0.1,fPosX,fPosY, 0.f );	//在爆炸位置播放特效
        g_last--;
    }


//    if()
    // 可以在此添加游戏需要的响应函数
    OnSpriteColSprite(szSrcName, szTarName);
}

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后,调用此函数.
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName:碰撞到边界的精灵名字
// 参数 iColSide:碰撞到的边界 0 左边,1 右边,2 上边,3 下边
//
void dOnSpriteColWorldLimit( const char *szName, const int iColSide )
{

    // 可以在此添加游戏需要的响应函数
    OnSpriteColWorldLimit(szName, iColSide);
}

10、坦克大战

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include <bits/stdc++.h>
float g_wleft, g_wright, g_wtop,g_wbottom;//世界边界值

int gamestate1=0,gamestate2=0,gamestate3=0;//关卡状态
int g1_scores=0;//关卡1的分
int g1_fail=0;//关卡1是否胜利
float g1_djs=10;//关卡1倒计时
float g1_tfall=0;
int is_bd0=0;
int is_bd1=0;
int is_g1_penzi=0;
int is_jieshao=0;
int is_kaishi=0;
int is_fanhui=0;
int is_g1_djs=0;
int is_g1_scores;
int is_xianjie01;
int g_show01=0;
int is_jieshaowenben;
int is_win=0;
int is_fail=0;

void create_bd0();
void create_bd1();
void create_g1_penzi();
void create_jieshao();
void create_kaishi();
void create_fanhui();
void create_g1_djs();
void create_g1_scores();
void create_xianjie01();
void create_jieshaowenben();
void create_win();//胜利界面
void create_fail();//失败界面
void g1_fall();
void g1_clearfall();//清除第一关下落
void create_page0();
void create_page1();
void delete_page0();
void delete_page1();
void init();
///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;
    create_page0();//初始化
    g_wleft=dGetScreenLeft();
    g_wright=dGetScreenRight();
    g_wtop=dGetScreenTop();
    g_wbottom=dGetScreenBottom();
    printf("初始化page0\n");
    dSetWindowTitle("Lesson");

    // 引擎主循环,处理屏幕图像刷新等工作
    while( dEngineMainLoop() )
    {
        // 获取两次调用之间的时间差,传递给游戏逻辑处理
        float	fTimeDelta	=	dGetTimeDelta();
        if(g1_fail==1){g1_clearfall(); continue;}
        //if(g_fail1==1) continue;
        if(g_show01==2&&gamestate1==1)//之前创建page1
        {
            g1_tfall-=fTimeDelta;//下落
            g1_djs-=fTimeDelta;
            dSetTextString("g1_djs",dMakeSpriteName("倒计时 ",int(g1_djs)));
            dSetTextString("g1_scores",dMakeSpriteName(" 得分 ",int(g1_scores)));
            if(g1_tfall<0)//控制第一关下落的
            {
                g1_fall();
                g1_tfall=4;
            }
            //是否过第一关
            if(g1_djs<=0&&gamestate1==1&&g1_fail==0)//获胜
            {
                g1_clearfall();
                printf("获胜界面\n");
                delete_page1();
                if(is_win!=0)
                    dDeleteSprite("win"),is_win=0;
                create_win();//创在win界面
                dSetSpritePosition("win",0,0);
                is_win=1;
                gamestate1=2;
                if(is_fanhui!=0)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();

            }
        }

        GameMainLoop( fTimeDelta );
    };

    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    if(gamestate1==0)
    {

        if(is_kaishi)
        {
            if(dIsPointInSprite("kaishi",fMouseX,fMouseY))
            {
                dSetSpriteScale("kaishi",1.2);
            }
            else
            {
                dSetSpriteScale("kaishi",1);
            }
        }
        if(is_jieshao)
        {
            if(dIsPointInSprite("jieshao",fMouseX,fMouseY))
            {
                dSetSpriteScale("jieshao",1.2);
            }
            else
            {
                dSetSpriteScale("jieshao",1);
            }
        }
    }
    if(is_fanhui)
    {
        if(dIsPointInSprite("fanhui",fMouseX,fMouseY))
        {
            dSetSpriteScale("fanhui",1.2);
        }
        else
        {
            dSetSpriteScale("fanhui",1);
        }
    }
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    if(gamestate1==0)//处理page0的按钮
    {
        if(!iMouseType&&is_kaishi)//左键
        {
            if(dIsPointInSprite("kaishi",fMouseX,fMouseY))
            {
                gamestate1=1;
                delete_page0();
                create_xianjie01();
                dSetSpritePosition("xianjie01",0,0);//xianjie01
                g_show01=1;//正在衔接页面
                if(is_fanhui) dDeleteSprite("fanhui");
                create_fanhui();
                dSetSpritePosition("fanhui",40,25);
            }
        }
    }
    if(gamestate1==0)
    {
        if(!iMouseType&&is_jieshao)//左键
        {
            if(dIsPointInSprite("jieshao",fMouseX,fMouseY))
            {
                printf("介绍作者\n");
                if(is_jieshaowenben)
                    dDeleteSprite("jieshaowenben"),is_jieshaowenben=0;
                create_jieshaowenben();
                dSetSpritePosition("jieshaowenben",0,0);
                if(is_fanhui)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
            }
        }
    }
    if(is_fanhui)
    {
        if(dIsPointInSprite("fanhui",fMouseX,fMouseY))
        {
            g1_clearfall();
            init();
            create_page0();
        }

    }


    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{

    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if(gamestate1==1&&g_show01==2)
    {
        if(iKey== KEY_LEFT )
        {
            dSetSpriteLinearVelocity("g1_penzi",-20,0);
            //printf("LEFT\n");
        }
        if(iKey== KEY_RIGHT )
        {
            dSetSpriteLinearVelocity("g1_penzi",20,0);
            // printf("RIGHT\n");
        }
    }
    if( g_show01==1&&gamestate1==1)
    {
        if(iKey==KEY_SPACE)
        {
            g_show01=2;//衔接的时候已经删除page0;
            dDeleteSprite("xianjie01"),is_xianjie01=0;
            create_page1();
        }
    }
    if(g1_fail==1&&gamestate1==1)//失败
    {
        if(iKey==KEY_SPACE)
        {
            dDeleteSprite("fail");
            delete_page1();
            create_page1();
            g1_djs=10;
            g1_scores=0;
            g1_fail=0;

        }
    }
    if(gamestate1==2&&gamestate2==0)
    {
        if(iKey==KEY_SPACE)
        {
            gamestate2=1;
            dDeleteSprite("win");
            delete_page1();
            //deletepage0();
        }
    }

    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    if(gamestate1==1)
    {
        if(iKey==KEY_LEFT||iKey==KEY_RIGHT)
        {
            dSetSpriteLinearVelocity("g1_penzi",0,0);
        }

    }
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后,调用此函数
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName:发起碰撞的精灵名字
// 参数 szTarName:被碰撞的精灵名字
//
void dOnSpriteColSprite( const char *szSrcName, const char *szTarName )
{
    for(int i=1; i<=8; i++)
    {
        if(strcmp("g1_penzi",szSrcName)==0&&strcmp(szTarName,dMakeSpriteName("g1m0",i))==0)//strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。
        {
            dDeleteSprite(szTarName);
            g1_scores++;
        }
    }
    if(strcmp("g1_penzi",szSrcName)==0&&(strstr(szTarName,"virus0")!=NULL))
    {
        printf("失败界面\n");
        g1_clearfall();
        delete_page1();
        if(is_fail)
            dDeleteSprite("fail"),is_fail=0;
        create_fail();
        dSetSpritePosition("fail",0,0);
        if(is_fanhui)
            dDeleteSprite("fanhui"),is_fanhui=0;
        create_fanhui();
        dSetSpritePosition("fanhui",40,33);
        g1_clearfall();

        g1_fail=1;
    }
    // 可以在此添加游戏需要的响应函数
    OnSpriteColSprite(szSrcName, szTarName);
}

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后,调用此函数.
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName:碰撞到边界的精灵名字
// 参数 iColSide:碰撞到的边界 0 左边,1 右边,2 上边,3 下边
//
void dOnSpriteColWorldLimit( const char *szName, const int iColSide )
{
    // 可以在此添加游戏需要的响应函数
    OnSpriteColWorldLimit(szName, iColSide);
}
void create_bd0()
{
    //bd0_muban
    char name[20];
    strcpy(name,"bd0");
    dCloneSprite("bd0_muban",name);
    is_bd0=1;
}
void create_bd1()
{
    char name[20];
    strcpy(name,"bd1");
    dCloneSprite("bd1_muban",name);
    is_bd1=1;
}
void create_g1_penzi()
{
    char name[20];
    strcpy(name,"g1_penzi");
    dCloneSprite("g1_penzi_muban",name);
    is_g1_penzi=1;
}
void create_jieshao()
{
    char name[20];
    strcpy(name,"jieshao");
    dCloneSprite("jieshao_muban",name);
    is_jieshao=1;
}
void create_kaishi()
{
    char name[20];
    strcpy(name,"kaishi");
    dCloneSprite("kaishi_muban",name);
    is_kaishi=1;
}
void create_fanhui()
{
    char name[20];
    strcpy(name,"fanhui");
    dCloneSprite("fanhui_muban",name);
    is_fanhui=1;
}
void create_g1_djs()
{
    char name[20];
    strcpy(name,"g1_djs");
    dCloneSprite("g1_djs_muban",name);
    is_g1_djs=1;
}
void create_g1_scores()
{
    char name[20];
    strcpy(name,"g1_scores");
    dCloneSprite("g1_scores_muban",name);
    is_g1_scores=1;
}
void create_xianjie01()
{
    char name[20];
    strcpy(name,"xianjie01");
    dCloneSprite("xianjie01_muban",name);
    is_xianjie01=1;
}
void create_jieshaowenben()
{
    char name[50];
    strcpy(name,"jieshaowenben");
    dCloneSprite("jieshaowenben_muban",name);
    is_jieshaowenben=1;

}

void g1_clearfall()
{
    for(int i=1; i<=8; i++)
    {
        dDeleteSprite(dMakeSpriteName("virus0",i));
        dDeleteSprite(dMakeSpriteName("g1m0",i));
    }
}
void create_page0()
{
     if(is_fanhui) dDeleteSprite("fanhui"),is_fanhui=0;
    create_bd0();//背景bd0
    dSetSpritePosition("bd0",0,0);
    create_jieshao();
    dSetSpritePosition("jieshao",25,20);
    create_kaishi();
    dSetSpritePosition("kaishi",-25,20);
}
void create_page1()
{
    if(is_bd1)
        dDeleteSprite("bd1");
    if(is_g1_penzi)
        dDeleteSprite("g1_penzi");
     if(is_g1_djs)
        dDeleteSprite("g1_djs");
    if(is_g1_scores)
         dDeleteSprite("g1_scores");
    if(is_fanhui)
         dDeleteSprite("fanhui");
    create_bd1();
    create_g1_penzi();
    create_g1_djs();
    create_g1_scores();
    create_fanhui();
    dSetSpritePosition("bd1",0,0);
    dSetSpritePosition("g1_penzi",0,g_wbottom+5);
    dSetSpritePosition("g1_djs",25,-28);
    dSetSpritePosition("g1_scores",25,-23);
    dSetSpritePosition("fanhui",40,33);
    g1_scores=0;//关卡1的得分
    g1_djs=10;
}
void delete_page0()
{
    dDeleteSprite("bd0");
    is_bd0=0;
    dDeleteSprite("jieshao");
    is_jieshao=0;
    dDeleteSprite("kaishi");
    is_kaishi=0;
}
void delete_page1()
{
    dDeleteSprite("bd1");
    is_bd1=0;
    dDeleteSprite("g1_penzi");
    is_g1_penzi=0;
    dDeleteSprite("g1_djs");
    is_g1_djs=0;
    dDeleteSprite("g1_scores");
    is_g1_scores=0;
    dDeleteSprite("fail");
    is_fail=0;
    dDeleteSprite("xianjie01");
    is_xianjie01=0;
    dDeleteSprite("fanhui");
    is_fanhui=0;
    g1_clearfall();
}
void create_win()
{
    char name[50];
    strcpy(name,"win");
    dCloneSprite("win_muban",name);
    is_win=1;
}
void create_fail()
{
    char name[50];
    strcpy(name,"fail");
    dCloneSprite("fail_muban",name);
    is_fail=1;
}
void g1_fall()
{
    for(int i=1; i<=8; i++)
    {
        char *s=dMakeSpriteName("g1m",i);
        char *t=dMakeSpriteName("g1m0",i);
        dCloneSprite(s,t);
        float dx=dRandomRange(g_wleft+5,g_wright-15);
        //float dy=dRandomRange(-40,-20);
        float dv=dRandomRange(20,25);
        dSetSpritePosition(t,dx,g_wtop-5);
        dSetSpriteLinearVelocity(t,0,dv);

    }
    for(int i=1; i<=8; i++)
    {
        char *t=dMakeSpriteName("virus0",i);
        dCloneSprite("virus_muban1",t);
        float dx=dRandomRange(g_wleft+5,g_wright-15);
        float dy=dRandomRange(-40,-20);
        float dv=dRandomRange(15,20);
        dSetSpritePosition(t,dx,dy);
        dSetSpriteLinearVelocity(t,0,dv);
        //virus_muban1
    }
}
void init()
{

    if(is_bd0)
        dDeleteSprite("bd0"),is_bd0=0;
    if(is_bd1)
        dDeleteSprite("bd1"),is_bd1=0;
    if(is_g1_penzi)
        dDeleteSprite("g1_penzi"),is_g1_penzi=0;
    if(is_jieshao)
        dDeleteSprite("jieshao"),is_jieshao=0;
    if(is_kaishi)
        dDeleteSprite("kaishi"),is_kaishi=0;
    if(is_fanhui)
        dDeleteSprite("fanhui"),is_fanhui=0;
    if(is_g1_djs)
        dDeleteSprite("g1_djs"),is_g1_djs=0;
    if( is_g1_scores)
        dDeleteSprite("g1_scores"), is_g1_scores=0;
    if(is_xianjie01)
        dDeleteSprite("xianjie01"), is_xianjie01=0;
    if(is_jieshaowenben)
        dDeleteSprite("jieshaowenben"),is_jieshaowenben=0;
    if(is_win)
        dDeleteSprite("win"),is_win=0;
    if(is_fail)
        dDeleteSprite("fail"),is_fail=0;
        gamestate1=0;
    gamestate2=0;
    gamestate3=0;//关卡状态

}

 

11、接下来,附上我的代码

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#include "CommonAPI.h"
#include "LessonX.h"
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include <bits/stdc++.h>
float g_wleft, g_wright, g_wtop,g_wbottom;//世界边界值
int a[10][10];
int gamestate1=0,gamestate2=0,gamestate3=0;//关卡状态
int g1_scores=0;//关卡1的分
int g1_fail,g2_fail;//关卡1是否胜利
float g1_djs=0;//关卡1倒计时
float g1_tfall=0;
int is_bangdan;
int is_bd_bangdan;
void create_bd_bangdan();
void create_bangdan();
int g3_fail=0;
int is_bd0=0;
int is_bd1=0;
int is_g1_penzi=0;
int is_jieshao=0;
int is_kaishi=0;
int is_fanhui=0;
int is_g1_djs=0;
int is_g1_scores;
int is_xianjie01;
int g_show01=0;
int g_show12=0;
int is_jieshaowenben;
int is_win=0;
int is_fail=0;
int g2_scores=0;

int is_story01=0;
int is_story12=0;

int g_show_story01=0;
int g_show_story12=0;
int g_scores=0;
void create_story12();
void create_story01();
void  create_page3();
void create_bian();
int is_bian=0;
int g1_bian;
float g1_bian_time;

///2222222222222222222222222222222222222
///22222222222222222222222222222222222222
void g2_zuai();
void  clear_g2_zuai();
void create_bd2a();
float g2_v=-20.f;
int g2_yaoji_count=0;
float g2_zuai_time;
int is_g2_zuai=0;
int g2_zuai_count=0;
float g2_yaoji_time=0;
int is_bd2=0;
int  is_bd2a=0;
int is_human=1;
int is_xianjie12=0;
int is_human_stay=0;
int g2_jump=0;
float g2_jumptime=2;
///33333333333333333333333333333333333333333333
///33333333333333333333333333333333333333333333
///33333333333333333333333333333333333333333333
const int g3_bolocks[35][35]=
{
    {0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},//入口
    {0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,2},
    {0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,2},
    {2,0,5,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,2},
    {2,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,2},
    {2,0,0,1,0,0,1,1,1,1,1,1,1,1,1,5,1,1,2},
    {2,0,0,1,0,0,1,1,5,1,0,0,0,0,0,0,0,0,2},
    {2,0,0,1,0,0,1,0,0,1,0,0,0,1,1,1,0,0,2},
    {2,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,2},
    {2,0,0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,2},
    {2,0,0,0,1,0,0,0,0,0,0,0,1,1,1,5,1,0,2},
    {2,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,2},
    {2,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,2},
    {2,0,0,1,0,5,0,0,0,5,0,0,1,0,0,1,1,1,2},
    {2,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,2},
    {2,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,2},
    {2,0,1,0,0,0,0,5,0,0,0,1,5,0,0,0,0,0,2},
    {2,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,2},
    {2,0,1,0,0,0,0,0,0,0,1,1,1,5,0,1,0,0,2},
    {2,1,1,1,5,0,1,1,1,1,1,0,0,1,1,1,0,0,2},
    {2,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,2},
    {2,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,2},
    {0,0,0,5,1,0,0,0,0,0,0,0,0,0,1,0,0,0,2},
    {0,0,0,0,0,0,0,0,0,0,5,0,0,0,1,0,0,0,2},
    {0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
};///出口


int is_last;
float g1_bianpang_time=0;
int g3_bumbnum1;
int g3_bumbnum2;
float g3_bumbtime1=0.5f;
float g3_bumbtime2=0.5f;
void create_last();
void create_edge();
void create_men2();

int is_men2;
void create_edge()
{
    for(int i=0; i<25; i++)
    {
        for(int j=0; j<19; j++)
        {
            if(g3_bolocks[i][j]!=0)//可消灭的
            {
                char name[20];//
                int t=g3_bolocks[i][j];
                strcpy(name, dMakeSpriteName(dMakeSpriteName("g3_block",t),i*25+j));
                dCloneSprite(dMakeSpriteName("virus_muban",t),name);
                dSetSpritePosition(name,(i-12)*4,(j-9)*4);
                float dx=dGetSpritePositionX(name);
                float dy=dGetSpritePositionY(name);
                printf("name:%s i:%d  j%d dx:%d dy:%d\n",name,i,j,int(dx),int(dy));
            }

        }
    }
}


//virus_muban1
//dongzhu_muban
float g3_js;
void create_chuansong();
void create_player1();
void create_player2();
void create_dongzhu();
void create_bd3();
void create_xianjie23();
void create_story23();
void create_player1();
void create_palyer2();//player1_muban
void create_player1_stay();
void create_player2_stay();
void create_men();
void clear_g3();
int is_men;
int is_chuansong;
int is_dongzhu;
int is_player1_stay=0;
int is_player2_stay=0;
int g_show_story23=0;
int is_story23;
int is_xianjie23;
int g_show23;
int is_player1;
int is_player2;
int is_bd3=0;
int g3_scores;
float g3_shouji_time2=5;
float g3_shouji_time1=5;///
int is_shouji1=0;
int is_shouji2=0;
float is_dongzhu_time2=0;
float is_dongzhu_time1=0;
int is_player1_dongzhu=0;
int is_player2_dongzhu=0;

///     music
int id1;
int id2=0;
///

void create_bd0();
void create_bd1();
void create_g1_penzi();
void create_jieshao();
void create_kaishi();
void create_fanhui();
void create_g1_djs();///
void create_g1_scores();
void create_xianjie01();
void create_jieshaowenben();
void create_human_stay();
void create_win();//胜利界面
void create_fail();//失败界面
void g1_fall();
void g1_clearfall();//清除第一关下落
void create_page0();
void create_page1();
void delete_page0();
void delete_page1();
void create_page2();
void delete_page2();
void init();
void  create_bd2();
void create_human();
void create_xianjie12();
void clearsceen();

int is_xunluo=0;
///巡逻部分代码
void create_xunluo();
//virus_muban4
void create_xunluo()
{
    char name[50];
    for(int i=1; i<=4; i++)
    {
        strcpy(name, dMakeSpriteName("xunluo0",i));
        dCloneSprite("virus_muban4",name);
    }
    is_xunluo=1;

}

///
///////////////////////////////////////////////////////////////////////////////////////////
//
// 主函数入口
//
//////////////////////////////////////////////////////////////////////////////////////////
int PASCAL WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR     lpCmdLine,
                   int       nCmdShow)
{
    // 初始化游戏引擎
    if( !dInitGameEngine( hInstance, lpCmdLine ) )
        return 0;

    create_page0();//初始化
    //  dDeleteSprite("g1_penzi");
    g_wleft=dGetScreenLeft();
    g_wright=dGetScreenRight();
    g_wtop=dGetScreenTop();
    g_wbottom=dGetScreenBottom();
    printf("初始化page0\n");
    dSetWindowTitle("抗疫记");
    id1= dPlaySound("Higher.wav",1,0.3);
    //is_music_rise=1;
    dDeleteSprite("g1_penzi");
    is_g1_penzi=0;
    // 引擎主循环,处理屏幕图像刷新等工作
    while( dEngineMainLoop() )
    {
        // 获取两次调用之间的时间差,传递给游戏逻辑处理
        float	fTimeDelta	=	dGetTimeDelta();
        if(g1_fail==1||g2_fail==1||g3_fail==1)
        {
            g1_clearfall();
            continue;
        }
        if(g_show01==2&&gamestate1==1)//之前创建page1
        {
            if(is_bian)
            {
                g1_bian_time-=fTimeDelta;
                if(g1_bian_time<0)
                {
                    dSetSpriteScale("g1_penzi",1);
                    is_bian=0;
                }
            }
            g1_tfall-=fTimeDelta;//下落
            g1_djs-=fTimeDelta;
            dSetTextString("g1_djs",dMakeSpriteName("倒计时 ",int(g1_djs)));
            dSetTextString("g1_scores",dMakeSpriteName(" 得分 ",int(g1_scores)));
            if(g1_tfall<0)//控制第一关下落的
            {
                g1_fall();
                g1_tfall=4;
            }
            //是否过第一关
            if(g1_djs<=0&&gamestate1==1&&g1_fail==0)//获胜
            {
                g1_clearfall();
                printf("g1 获胜界面\n");
                dStopSound(id1);
                dStopSound(id2);
                dStopAllSound();
                dPlaySound("success.ogg",0,1);//mouse music.wav
                printf("1 g1 %d",g1_scores);
                delete_page1();
                if(is_win!=0)
                    dDeleteSprite("win"),is_win=0;
                create_win();//创在win界面
                dSetSpritePosition("win",0,0);
                is_win=1;
                gamestate1=2;
                printf("1 g1 %d",g1_scores);
                if(is_fanhui!=0)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
            }
        }
        ///222222222222222222222222222222222222222222222
        ///2222222222222222222222222222222222222222222222222
        if(gamestate2==1&&g_show12==2)
        {
            g1_djs-=fTimeDelta;
            if(is_g1_scores)
                dDeleteSprite("g1_scores");
            create_g1_scores();
            if(is_g1_djs)
                dDeleteSprite("g1_djs");
            create_g1_djs();
            dSetSpritePosition("g1_djs",25,-28);
            dSetSpritePosition("g1_scores",25,-23);
            dSetTextString("g1_scores",dMakeSpriteName(" 得分 ",g1_scores+g2_scores));
            dSetTextString("g1_djs",dMakeSpriteName("倒计时 ",int(g1_djs)));
            if(g1_djs<0)
            {
                g1_djs=30;///
                printf("g2 获胜界面\n");
                dStopAllSound();
                dStopSound(id1);
                dStopSound(id2);
                dPlaySound("success.ogg",0,1);
                clearsceen();
                if(is_win!=0)
                    dDeleteSprite("win"),is_win=0;
                create_win();//创在win界面
                dSetSpritePosition("win",0,0);
                is_win=1;
                gamestate2=2;
                if(is_fanhui!=0)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
            }
            if(g2_jump==1)
            {
                g2_jump=2;
                dPlaySound("jump.wav",0,1);
                if(is_human_stay)
                    dDeleteSprite("human_stay");
                create_human_stay();
                dSetSpritePosition("human_stay",-42,5);
                if(is_human)
                    dDeleteSprite("human");
                is_human=0;
                dSetSpriteLinearVelocity("human_stay",0,-50);
                dSetSpriteConstantForceY("human_stay",60);
                g2_jumptime=50.0/60.0*2+0.4;
            }
            if(g2_jump==2)
            {
                g2_jumptime-=fTimeDelta;
                if(g2_jumptime<0)
                {
                    g2_jump=0;
                    if(is_human_stay)
                        dDeleteSprite("human_stay"),is_human_stay=0;
                    dSetSpriteVisible("human_stay",0);
                    printf("0");
                    if(is_human)
                        dDeleteSprite("human");
                    create_human();
                    dSetSpritePosition("human",-42,5);
                    g2_jumptime=50.0/60.0*2+0.4;
                }

            }
            if(is_g2_zuai==1)
            {
                g2_zuai_time-=fTimeDelta;
                if(g2_zuai_count>5)
                    g2_zuai_count=0;
                if(g2_zuai_time<0)
                {
                    float dy=dRandomRange(-1,5);
                    dSetSpritePosition(dMakeSpriteName("g2_virus",++g2_zuai_count),g_wright+5,dy);
                    dSetSpriteLinearVelocity(dMakeSpriteName("g2_virus",g2_zuai_count),g2_v,0);
                    g2_zuai_time=4;
                }
                g2_yaoji_time-=fTimeDelta;
                if(g2_yaoji_count>8)
                    g2_yaoji_count=0;
                if(g2_yaoji_time<0)
                {
                    printf("12345\n");
                    float dy=dRandomRange(-10,5);
                    dSetSpritePosition(dMakeSpriteName("g2m0",++g2_yaoji_count),g_wright+5,dy);
                    dSetSpriteLinearVelocity(dMakeSpriteName("g2m0",g2_yaoji_count),g2_v,0);
                    g2_yaoji_time=2;
                }

            }

        }
        ///33333333333333333333333333333333333333333
        ///33333333333333333333333333333333333333333
        ///33333333333333333333333333333333333333333
        if(gamestate3==1)
        {
            g3_js+=fTimeDelta;
            if(is_g1_scores)
                dDeleteSprite("g1_scores");
            create_g1_scores();
            if(is_g1_djs)
                dDeleteSprite("g1_djs");
            create_g1_djs();
            dSetSpritePosition("g1_djs",-5,-35);
            dSetSpritePosition("g1_scores",-5,-30);
            dSetTextString("g1_scores",dMakeSpriteName("得分 ",g3_scores));
            dSetTextString("g1_djs",dMakeSpriteName("计时 ",int(g3_js)));
            if(is_player1_dongzhu)
            {
                is_dongzhu_time1-=fTimeDelta;
                if(is_dongzhu_time1<0)
                {
                    is_player1_dongzhu=0;
                    dDeleteSprite("dongzhu");
                    is_dongzhu=0;
                }
            }
            if(is_player2_dongzhu)
            {
                is_dongzhu_time2-=fTimeDelta;
                if(is_dongzhu_time2<0)
                {
                    is_player2_dongzhu=0;
                    dDeleteSprite("dongzhu");
                    is_dongzhu=0;
                }
            }
            if(g3_bumbnum1!=0)
            {
                g3_bumbtime1-=fTimeDelta;
                if(g3_bumbtime1<0)
                {

                    float dx=dGetSpritePositionX(dMakeSpriteName("g1m0",g3_bumbnum1));
                    float dy=dGetSpritePositionY(dMakeSpriteName("g1m0",g3_bumbnum1));
                    int kx=(int)(dx/4.f)+12;
                    int ky=(int)(dy/4.f)+9;
                    dDeleteSprite(dMakeSpriteName("g1m0",g3_bumbnum1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+ky));//dMakeSpriteName("g3_block",t),i*25+j)
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25-25+ky));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+ky-1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+25+ky));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+ky+1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+25+ky+1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25-25+ky+1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+25+ky-1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25-25+ky-1));
                    printf("kx:%d  ky:%d %s\n",kx,ky,dMakeSpriteName("g3_block1",kx*25+ky));
                    printf("kx:%d  ky:%d %s\n",kx+1,ky,dMakeSpriteName("g3_block1",kx*25+25+ky));
                    printf("kx:%d  ky:%d %s\n",kx,ky+1,dMakeSpriteName("g3_block1",kx*25+1+ky));
                    printf("kx:%d  ky:%d %s\n",kx-1,ky,dMakeSpriteName("g3_block1",kx*25+ky-25));
                    printf("kx:%d  ky:%d %s\n",kx,ky-1,dMakeSpriteName("g3_block1",kx*25+ky-1));
                    g3_bumbtime1=0.5f;
                    g3_bumbnum1=0;
                }
            }
            if(g3_bumbnum2!=0)
            {
                g3_bumbtime2-=fTimeDelta;
                if(g3_bumbtime2<0)
                {
                    float dx=dGetSpritePositionX(dMakeSpriteName("g1m0",g3_bumbnum2));
                    float dy=dGetSpritePositionY(dMakeSpriteName("g1m0",g3_bumbnum2));
                    int kx=(int)(dx/4.f)+12;
                    int ky=(int)(dy/4.f)+9;
                    // printf("kx:%d  ky:%d %s\n",kx,ky,dMakeSpriteName("g3_block1",kx*25+ky));
                    dDeleteSprite(dMakeSpriteName("g1m0",g3_bumbnum2));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+ky));//dMakeSpriteName("g3_block",t),i*25+j)
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25-25+ky));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+ky-1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+25+ky));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+ky+1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+25+ky+1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25-25+ky+1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25+25+ky-1));
                    dDeleteSprite(dMakeSpriteName("g3_block1",kx*25-25+ky-1));
                    printf("kx:%d  ky:%d %s\n",kx,ky,dMakeSpriteName("g3_block1",kx*25+ky));
                    printf("kx:%d  ky:%d %s\n",kx+1,ky,dMakeSpriteName("g3_block1",kx*25+25+ky));
                    printf("kx:%d  ky:%d %s\n",kx,ky+1,dMakeSpriteName("g3_block1",kx*25+1+ky));
                    printf("kx:%d  ky:%d %s\n",kx-1,ky,dMakeSpriteName("g3_block1",kx*25+ky-25));
                    printf("kx:%d  ky:%d %s\n",kx,ky-1,dMakeSpriteName("g3_block1",kx*25+ky-1));
                    g3_bumbtime2=0.5f;
                    g3_bumbnum2=0;
                }
            }
            if(is_chuansong)
            {
                float dx,dy;
                if(is_player1)
                {
                    dx=dGetSpritePositionX("player1");
                    dy=dGetSpritePositionY("player1");
                }
                else if(is_player1_stay)
                {
                    dx=dGetSpritePositionX("player1_stay");
                    dy=dGetSpritePositionY("player1_stay");
                }
                if(is_shouji1)
                {
                    if(dIsPointInSprite("chuansong1",dx,dy))
                    {
                        is_shouji1=1;
                        g3_shouji_time1-=fTimeDelta;
                        if(g3_shouji_time1<0)
                        {
                            g3_shouji_time1=5;
                            g3_scores++;
                        }
                    }
                    else
                    {
                        g3_shouji_time1=5;
                        is_shouji1=0;
                    }
                }

                ///
                if(is_player2)
                {
                    dx=dGetSpritePositionX("player2");
                    dy=dGetSpritePositionY("player2");
                }
                else if(is_player2_stay)
                {
                    dx=dGetSpritePositionX("player2_stay");
                    dy=dGetSpritePositionY("player2_stay");
                }
                if(is_shouji2)
                {
                    if(dIsPointInSprite("chuansong2",dx,dy))
                    {
                        is_shouji2=1;
                        g3_shouji_time2-=fTimeDelta;
                        if(g3_shouji_time2<0)
                        {
                            g3_shouji_time2=5;
                            g3_scores++;
                        }
                    }
                    else
                    {
                        is_shouji2=0;
                        g3_shouji_time2=5;
                    }
                }
            }
            if(is_men&&is_men2)///成功
            {
                float dx=dGetSpritePositionX("player1_stay");
                float dy=dGetSpritePositionY("player1_stay");
                if(dIsPointInSprite("men",dx,dy))
                {
                    printf("11111111111111\n");
                    dx=dGetSpritePositionX("player2_stay");
                    dy=dGetSpritePositionY("player2_stay");
                    if(dIsPointInSprite("men2",dx,dy))
                    {
                        printf("222222222222\n");
                        dStopAllSound();
                        dStopSound(id1);
                        dStopSound(id2);
                        dPlaySound("success.ogg",0,1);
                        id1= dPlaySound("Higher.wav",1,0.3);
                        clearsceen();
                        gamestate3=2;
                        if(is_last)
                            dDeleteSprite("last");
                        create_last();
                        dSetSpritePosition("last",0,0);
                        if(is_fanhui)
                            dDeleteSprite("fanhui");
                        create_fanhui();
                        dSetSpritePosition("fanhui",40,33);
                        freopen("D:\\in.txt","r",stdin);
                        for(int i=1; i<=5; i++)
                        {
                            scanf("%d %d %d",&a[i][0],&a[i][1],&a[i][2]);
                        }
                        if(g3_scores>a[5][1])
                        {
                            a[5][1]=g3_scores;
                            a[5][2]=g3_js;
                        }
                        else   if(g3_scores==a[5][1])
                        {
                            if(g3_js<a[5][2])
                            {
                                a[5][1]=g3_scores;
                                a[5][2]=g3_js;
                            }
                        }
                        ///排名
                        for(int i=1; i<=5; i++)
                            for(int j=i+1; j<=5; j++)
                                if((a[j][1]>a[i][1])||((a[j][1]==a[i][1])&&a[j][2]<a[i][2]))
                                {
                                    int temp=a[j][1];
                                    a[j][1]=a[i][1];
                                    a[i][1]=temp;
                                    temp=a[j][2];
                                    a[j][2]=a[i][2];
                                    a[i][2]=temp;
                                }
                        freopen("D:\\in.txt","w",stdout);
                        for(int i=1; i<=5; i++)
                        {
                            printf("%d %d %d\n",i,a[i][1],a[i][2]);
                        }
                        // freopen("D:\\in.txt","w",stdout);
                        fclose(stdin);
                        fclose(stdout);

                    }

                }
            }




        }

        GameMainLoop( fTimeDelta );
    };
    // 关闭游戏引擎
    dShutdownGameEngine();
    return 0;
}

//==========================================================================
//
// 引擎捕捉鼠标移动消息后,将调用到本函数
// 参数 fMouseX, fMouseY:为鼠标当前坐标  我在找你的音频
//
void dOnMouseMove( const float fMouseX, const float fMouseY )
{
    if(gamestate1==0)
    {
        if(is_kaishi)
        {
            if(dIsPointInSprite("kaishi",fMouseX,fMouseY))
            {
                dSetSpriteScale("kaishi",1.2);
            }
            else
            {
                dSetSpriteScale("kaishi",1);
            }
        }
        if(is_jieshao)
        {
            if(dIsPointInSprite("jieshao",fMouseX,fMouseY))
            {
                dSetSpriteScale("jieshao",1.2);
            }
            else
            {
                dSetSpriteScale("jieshao",1);
            }
        }
    }
    if(is_fanhui)
    {
        if(dIsPointInSprite("fanhui",fMouseX,fMouseY))
        {
            dSetSpriteScale("fanhui",1.2);
        }
        else
        {
            dSetSpriteScale("fanhui",1);
        }
    }
    if(is_bangdan)
    {
        if(dIsPointInSprite("bangdan",fMouseX,fMouseY))
        {
            dSetSpriteScale("bangdan",1.2);
        }
        else
        {
            dSetSpriteScale("bangdan",1);
        }

    }
    // 可以在此添加游戏需要的响应函数
    OnMouseMove(fMouseX, fMouseY );
}
//==========================================================================
//
// 引擎捕捉鼠标点击消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseClick( const int iMouseType, const float fMouseX, const float fMouseY )
{
    if(gamestate1==0)
    {
        if(!iMouseType&&is_bangdan)//左键
        {
            if(dIsPointInSprite("bangdan",fMouseX,fMouseY))
            {
                dPlaySound("mouse music.wav",0,1);
                if(is_bd_bangdan)
                    dDeleteSprite("bd_bangdan");
                create_bd_bangdan();
                dSetSpritePosition("bd_bangdan",0,0);
                if(is_fanhui)
                    dDeleteSprite("fanhui");
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
                freopen("D:\\in.txt","r",stdin);
                dCloneSprite("paimin_muban","paimin0");
                dSetTextString("paimin0","排名 成绩 时间");
                dSetSpritePosition("paimin0",0,-15);
                for(int i=1; i<=5; i++)
                {
                    for(int j=1; j<=3; j++)
                    {
                        scanf("%d",&a[i][j]);
                    }
                }
                for(int i=0; i<15; i++)
                {
                    dCloneSprite("paimin_muban",dMakeSpriteName("paimin",i+1));

                    dSetTextValue(dMakeSpriteName("paimin",i+1),a[i/3+1][i%3+1]);
                    // printf("%d ",a[(i-1)/3+1][i%3]);
                    dSetSpritePosition(dMakeSpriteName("paimin",i+1),i%3*10-10,(i/3+1)*8-15);
                }
                fclose(stdin);

            }
        }
    }
    if(gamestate1==0)//处理page0的按钮
    {
        if(!iMouseType&&is_kaishi)//左键
        {
            if(dIsPointInSprite("kaishi",fMouseX,fMouseY))
            {
                dPlaySound("mouse music.wav",0,1);
                printf("游戏开始\n");
                gamestate1=1;
                delete_page0();
                if(is_story01)
                    dDeleteSprite("story01");
                create_story01();
                dSetSpritePosition("story01",0,0);
                g_show_story01=1;
                if(is_fanhui)
                    dDeleteSprite("fanhui");
                create_fanhui();
                dSetSpritePosition("fanhui",40,25);

            }
        }
    }
    if(gamestate1==0)
    {
        if(!iMouseType&&is_jieshao)//左键
        {
            if(dIsPointInSprite("jieshao",fMouseX,fMouseY))
            {
                printf("介绍作者\n");
                dPlaySound("mouse music.wav",0,1);
                if(is_jieshaowenben)
                    dDeleteSprite("jieshaowenben"),is_jieshaowenben=0;
                create_jieshaowenben();
                dSetSpritePosition("jieshaowenben",0,0);
                if(is_fanhui)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
            }
        }
    }
    if(is_fanhui)
    {
        if(dIsPointInSprite("fanhui",fMouseX,fMouseY))
        {

            dDeleteSprite("fail");
            dStopAllSound();
            dStopSound(id1);
            dStopSound(id2);
            dPlaySound("mouse music.wav",0,1);
            id1= dPlaySound("Higher.wav",1,0.3);
            g1_clearfall();
            init();
            create_page0();
        }
    }
    OnMouseClick(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉鼠标弹起消息后,将调用到本函数
// 参数 iMouseType:鼠标按键值,见 enum MouseTypes 定义
// 参数 fMouseX, fMouseY:为鼠标当前坐标
//
void dOnMouseUp( const int iMouseType, const float fMouseX, const float fMouseY )
{

    // 可以在此添加游戏需要的响应函数
    OnMouseUp(iMouseType, fMouseX, fMouseY);

}
//==========================================================================
//
// 引擎捕捉键盘按下消息后,将调用到本函数
// 参数 iKey:被按下的键,值见 enum KeyCodes 宏定义
// 参数 iAltPress, iShiftPress,iCtrlPress:键盘上的功能键Alt,Ctrl,Shift当前是否也处于按下状态(0未按下,1按下)
//
void dOnKeyDown( const int iKey, const int iAltPress, const int iShiftPress, const int iCtrlPress )
{
    if(gamestate1==1&&g_show01==2&&g_show_story01==2)
    {
        if(is_g1_penzi)
        {
            if(iKey== KEY_LEFT )
            {
                dSetSpriteLinearVelocity("g1_penzi",-20,0);
            }
            if(iKey== KEY_RIGHT )
            {
                dSetSpriteLinearVelocity("g1_penzi",20,0);
            }

        }
    }
    if(g_show01==1&&gamestate1==1&&g_show_story01==2)
    {
        if(iKey==KEY_SPACE)
        {
            printf("385\n");
            g_show01=2;//衔接的时候已经删除page0;
            dStopSound(id1);
            dStopSound(id2);
            dStopAllSound();
            dPlaySound("one1.wav",0,0.3);
            dDeleteSprite("xianjie01"),is_xianjie01=0;
            create_page1();
            dSetSpritePosition("bd1",0,0);
            dSetSpritePosition("g1_penzi",0,g_wbottom-5);
            dSetSpritePosition("g1_djs",25,-28);
            dSetSpritePosition("g1_scores",25,-23);
            dSetSpritePosition("fanhui",40,33);
            if(is_bian)dDeleteSprite("bian01"),dDeleteSprite("bian02"),dDeleteSprite("bian03"),dDeleteSprite("bian04");
                create_bian();
        }
    }
    if(g_show01==0&&gamestate1==1&&g_show_story01==1)
    {
        if(iKey==KEY_SPACE)
        {
            //  printf("394\n");
            dDeleteSprite("story01");//story01_muban
            is_story01=0;
            create_xianjie01();
            printf("xianjie01\n");
            dSetSpritePosition("xianjie01",0,0);
            g_show01=1;
            g_show_story01=2;

            if(is_fanhui)
                dDeleteSprite("fanhui");
            create_fanhui();
            dSetSpritePosition("fanhui",40,25);
        }
    }
    if(g1_fail==1&&gamestate1==1)///失败
    {
        if(iKey==KEY_SPACE)
        {

            dDeleteSprite("fail");
            delete_page1();
            dDeleteSprite("bian01"),dDeleteSprite("bian02");

            create_page1();
            dSetSpritePosition("bd1",0,0);
            dSetSpritePosition("g1_penzi",0,g_wbottom-5);
            dSetSpritePosition("g1_djs",25,-28);
            dSetSpritePosition("g1_scores",25,-23);
            dSetSpritePosition("fanhui",40,33);
            create_bian();
            g1_djs=30;///
            g1_scores=0;
            g1_fail=0;
            dStopAllSound();
            dStopSound(id1);
            dStopSound(id2);
            dPlaySound("one1.wav",0,0.3);

        }
    }
    if(g2_fail==1&&gamestate2==1)///失败
    {
        if(iKey==KEY_SPACE)
        {
            if(is_fail)
                dDeleteSprite("fail"),is_fail=0;
            delete_page2();
            create_page2();
            g2_fail=0;
            clear_g2_zuai();
            g2_zuai();///创建好阻碍了
            is_g2_zuai=1;
            g2_yaoji_time=0;
            g2_zuai_time=0;
            g2_scores=0;
            dStopAllSound();
            dStopSound(id1);
            dStopSound(id2);
            dPlaySound("two2.wav",0,0.3);
        }
    }

    ///2222222222222222222222222222222222222222222222222222222222
    ///2222222222222222222222222222222222222222222222222222222222
    ///2222222222222222222222222222222222222222222222222222222222
    ///第二关开始设置
    if(gamestate2==1&&g_show12==2&&g2_jump==0&&g2_fail==0)
    {
        if(iKey==KEY_SPACE)
        {
            printf("jump\n");
            g2_jump=1;
        }
    }
    else if(gamestate1==2&&gamestate2==0&&g_show12==1&&g2_fail==0&& g_show_story12==2&&g2_fail==0)
    {
        if(iKey==KEY_SPACE)
        {
            g_show12=2;
            clearsceen();
            printf("第二关开始\n");
            if(is_xianjie12)
                dDeleteSprite("xianjie12"),is_xianjie12=0;
            create_page2();
            clear_g2_zuai();
            g1_djs=30;///tttttttttttttttttttttttttttttttttttttttttttttttttttt

            g2_zuai();///创建好阻碍了
            is_g2_zuai=1;
            g2_scores=0;
            gamestate2=1;
            dStopAllSound();
            dStopSound(id1);
            dStopSound(id2);
            dPlaySound("two2.wav",0,0.3);
        }
    }
    else if(gamestate1==2&&gamestate2==0&&g_show12==0&&g_show_story12==0&&g2_fail==0)
    {
        if(iKey==KEY_SPACE)
        {
            clearsceen();
            dStopSound(id1);
            dStopSound(id2);
            dStopAllSound();
            id1= dPlaySound("Higher.wav",1,0.3);
            if(is_story12)
                dDeleteSprite("story12"),is_story12=0;
            create_story12();
            dSetSpritePosition("story12",0,0);
            if(is_fanhui)
                dDeleteSprite("fanhui"),is_fanhui=0;
            create_fanhui();
            dSetSpritePosition("fanhui",40,28);
            g_show_story12=1;
        }
    }
    else if(gamestate1==2&&gamestate2==0&&g_show12==0&&g_show_story12==1&&g2_fail==0)
    {
        if(iKey==KEY_SPACE)
        {
            clearsceen();
            if(is_xianjie12)
                dDeleteSprite("xianjie12"),is_xianjie12=0;
            create_xianjie12();
            dSetSpritePosition("xianjie12",0,0);
            if(is_fanhui)
                dDeleteSprite("fanhui"),is_fanhui=0;
            create_fanhui();
            dSetSpritePosition("fanhui",40,28);
            g_show12=1;
            g_show_story12=2;
            g1_djs=30;
        }
    }
    ///333333333333333333333333333333333333333333333333333
    ///333333333333333333333333333333333333333333333333333
    ///333333333333333333333333333333333333333333333333333
    ///333333333333333333333333333333333333333333333333333
    ///333333333333333333333333333333333333333333333333333
    if(g3_fail==1&&gamestate3==1)///第三关失败
    {
        if(iKey==KEY_SPACE)
        {
            if(is_fail)
                dDeleteSprite("fail"),is_fail=0;
            clearsceen();
            create_page3();
            printf("925第三关失败");
            g3_fail=0;
            g3_scores=g_scores;///scorscoresciresxicvhhdgsvcvgfhjgfdghjkjgfghgdfghjhgfcxggfd
            g3_js=0;
            gamestate3=1;
            dStopAllSound();
            dStopSound(id1);
            dStopSound(id2);
            id2=dPlaySound("g3_1.wav",1,0.3);

        }

    }
    else if(gamestate2==2&&gamestate3==0&&g_show23==0&&g_show_story23==0&&g3_fail==0)
    {
        if(iKey==KEY_SPACE)
        {
            clearsceen();
            create_story23();
            dSetSpritePosition("story23",0,0);
            g_show_story23=1;
            g3_scores=g1_scores+g2_scores;///scoresscorescosresssssssssssssssss
            g_scores=g1_scores+g2_scores;
            printf("g1_scores %d\n",g1_scores);
            printf("g2_scores %d\n",g2_scores);
            if(is_fanhui)
                dDeleteSprite("fanhui");
            create_fanhui();
            dSetSpritePosition("fanhui",40,33);
            dStopSound(id1);
            dStopSound(id2);
            dStopAllSound();
            id1= dPlaySound("Higher.wav",1,0.3);
        }
    }
    else if(gamestate2==2&&gamestate3==0&&g_show23==0&&g_show_story23==1&&g3_fail==0)
    {
        if(iKey==KEY_SPACE)
        {
            clearsceen();
            create_xianjie23();
            dSetSpritePosition("xianjie23",0,0);
            g_show_story23=2;
            g_show23=1;
            if(is_fanhui)
                dDeleteSprite("fanhui");
            create_fanhui();
            dSetSpritePosition("fanhui",40,33);
        }
    }
    else if(gamestate2==2&&gamestate3==0&&g_show23==1&&g_show_story23==2&&g2_fail==0)
    {
        if(iKey==KEY_SPACE)
        {
            clearsceen();
            dStopSound(id1);
            dStopSound(id2);
            dStopAllSound();
            id2=dPlaySound("g3_1.wav",1,0.3);
            create_page3();
            gamestate3=1;
            g_show23=2;
            //id=dPlaySound("rise.wav",1,1);
            ///
            ///播放音乐

        }
    }
    else if(gamestate2==2&&gamestate3==1&&g3_fail==0)///设置第三关移动 和放物资
    {
        if(iKey==KEY_SPACE&&g3_bumbnum2==0&&(g3_scores>0))//玩家2放物资
        {
            g3_scores--;
            float dx,dy;
            g3_bumbnum2=dRandomRange(1,8);
            dCloneSprite(dMakeSpriteName("g1m",g3_bumbnum2),dMakeSpriteName("g1m0",g3_bumbnum2));
            if(is_player2)
            {
                dx=dGetSpritePositionX("player2");
                dy=dGetSpritePositionY("player2");
            }
            else if(is_player2_stay)
            {
                dx=dGetSpritePositionX("player2_stay");
                dy=dGetSpritePositionY("player2_stay");
            }
            dSetSpritePosition(dMakeSpriteName("g1m0",g3_bumbnum2),dx,dy);
        }
        if(iKey==KEY_J&&g3_bumbnum1==0&&(g3_scores>0))//玩1放物资
        {
            ///g1m
            float dx,dy;
            g3_scores--;
            g3_bumbnum1=dRandomRange(1,8);
            dCloneSprite(dMakeSpriteName("g1m",g3_bumbnum1),dMakeSpriteName("g1m0",g3_bumbnum1));
            if(is_player1)
            {
                dx=dGetSpritePositionX("player1");
                dy=dGetSpritePositionY("player1");
            }
            else if(is_player1_stay)
            {
                dx=dGetSpritePositionX("player1_stay");
                dy=dGetSpritePositionY("player1_stay");
            }
            dSetSpritePosition(dMakeSpriteName("g1m0",g3_bumbnum1),dx,dy);
        }
        ///PLAYER1
        if(iKey==KEY_W||iKey==KEY_A||iKey==KEY_S||iKey== KEY_D)
        {
            float dx,dy;
            if(is_player1_stay)
            {
                dx=dGetSpritePositionX("player1_stay");
                dy=dGetSpritePositionY("player1_stay");
                dDeleteSprite("player1_stay"),is_player1_stay=0;
                if(is_player1)
                    dDeleteSprite("player1");
                create_player1();
                dSetSpritePosition("player1",dx,dy);
            }
        }
        if(is_player1_dongzhu==0)
        {
            float va=0.f,vw=0.f,vs=0.f,vd=0.f;
            if(iKey==KEY_W)
            {
                vw = -15.f;
                dSetSpriteLinearVelocity("player1",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player1", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player1", true);
            }
            else if(iKey==KEY_A)
            {
                va = -15.f;
                dSetSpriteLinearVelocity("player1",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player1", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player1", true);

            }
            else if( iKey==KEY_S)
            {
                vs = 15.f;
                dSetSpriteLinearVelocity("player1",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player1", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player1", true);
            }
            else if( iKey== KEY_D)
            {
                vd= 15.f;
                dSetSpriteLinearVelocity("player1",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player1", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player1", true);
            }
        }
        ///PLAYER2

        if(iKey==KEY_LEFT||iKey==KEY_RIGHT||iKey==KEY_UP||iKey== KEY_DOWN)
        {
            float dx,dy;
            if(is_player2_stay)
            {
                dx=dGetSpritePositionX("player2_stay");
                dy=dGetSpritePositionY("player2_stay");
                dDeleteSprite("player2_stay");
                is_player2_stay=0;
                if(is_player2)
                    dDeleteSprite("player2");
                create_player2();
                dSetSpritePosition("player2",dx,dy);
            }
        }
        if(!is_player2_dongzhu)
        {
            float va=0.f;
            float vw=0.f;
            float vs=0.f;
            float vd=0.f;
            if(iKey==KEY_UP)
            {
                vw = -15.f;
                dSetSpriteLinearVelocity("player2",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player2", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player2", true);
            }
            else if(iKey==KEY_LEFT)
            {
                va = -15.f;
                dSetSpriteLinearVelocity("player2",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player2", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player2", true);

            }
            else if( iKey==KEY_DOWN)
            {
                vs = 15.f;
                dSetSpriteLinearVelocity("player2",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player2", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player2", true);
            }
            else if( iKey== KEY_RIGHT)
            {
                vd= 15.f;
                dSetSpriteLinearVelocity("player2",va+vd,vw+vs);
                if((va + vd) > 0.f)
                    dSetSpriteFlipX("player2", false);
                else if((va + vd) < 0.f)
                    dSetSpriteFlipX("player2", true);
            }
        }
    }

    // 可以在此添加游戏需要的响应函数
    OnKeyDown(iKey, iAltPress, iShiftPress, iCtrlPress);
}
//==========================================================================
//
// 引擎捕捉键盘弹起消息后,将调用到本函数
// 参数 iKey:弹起的键,值见 enum KeyCodes 宏定义
//
void dOnKeyUp( const int iKey )
{
    if(gamestate1==1)
    {
        if(iKey==KEY_LEFT||iKey==KEY_RIGHT)
        {
            dSetSpriteLinearVelocity("g1_penzi",0,0);
        }

    }
    if(gamestate3==1)
    {
        if(iKey==KEY_LEFT||iKey==KEY_RIGHT||iKey==KEY_UP||iKey== KEY_DOWN||is_player2_dongzhu)
        {
            float dx;
            float dy;
            if(is_player2)
            {
                dx=dGetSpritePositionX("player2");
                dy=dGetSpritePositionY("player2");
                dDeleteSprite("player2");
                is_player2=0;
            }
            else if(is_player2_stay)
            {
                dx=dGetSpritePositionX("player2_stay");
                dy=dGetSpritePositionY("player2_stay");
                dDeleteSprite("player2_stay");
                is_player2_stay=0;
            }
            if(is_player2_stay)
                dDeleteSprite("player2_stay");
            create_player2_stay();
            dSetSpritePosition("player2_stay",dx,dy);

        }
        if(iKey==KEY_W||iKey==KEY_A||iKey==KEY_S||iKey== KEY_D||is_player1_dongzhu)
        {
            float dx;
            float dy;
            if(is_player1)
            {
                dx=dGetSpritePositionX("player1");
                dy=dGetSpritePositionY("player1");
                dDeleteSprite("player1");
                is_player1=0;
            }
            else if(is_player1_stay)
            {
                dx=dGetSpritePositionX("player1_stay");
                dy=dGetSpritePositionY("player1_stay");
                dDeleteSprite("player1_stay"),is_player1_stay=0;
            }
            if(is_player1_stay)
                dDeleteSprite("player1_stay");
            create_player1_stay();
            dSetSpritePosition("player1_stay",dx,dy);
        }

    }
    // 可以在此添加游戏需要的响应函数
    OnKeyUp(iKey);
}

//===========================================================================
//
// 引擎捕捉到精灵与精灵碰撞之后,调用此函数
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵发送及接受碰撞
// 参数 szSrcName:发起碰撞的精灵名字
// 参数 szTarName:被碰撞的精灵名字
//
void dOnSpriteColSprite( const char *szSrcName, const char *szTarName )
{
    if(gamestate1==1)
    {
        for(int i=1; i<=8; i++)
        {
            if(strcmp("g1_penzi",szSrcName)==0&&strcmp(szTarName,dMakeSpriteName("g1m0",i))==0)//strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。
            {
                dDeleteSprite(szTarName);
                g1_scores++;
            }
        }
        if(strcmp("g1_penzi",szSrcName)==0&&(strstr(szTarName,"virus0")!=NULL))
        {
            dStopAllSound();
            dStopSound(id1);
            dStopSound(id2);
            dPlaySound("fail.ogg",0,1);
            printf("失败界面\n");
            g1_clearfall();
            delete_page1();
            if(is_fail)
                dDeleteSprite("fail"),is_fail=0;
            create_fail();
            dSetSpritePosition("fail",0,0);
            if(is_fanhui)
                dDeleteSprite("fanhui"),is_fanhui=0;
            create_fanhui();
            dSetSpritePosition("fanhui",40,33);
            g1_fail=1;
        }
         if(strcmp("g1_penzi",szSrcName)==0&&(strstr(szTarName,"bian0")!=NULL))
         {
             g1_bian=1;
             g1_bian_time=5.f;
             dSetSpriteScale("g1_penzi",1.5);
         }
    }
    ///2222222222222222222222222222222222222222222222
    ///
    ///
    ///
    ///22222222222222222222222222222222222222222222222222
    if(gamestate2==1)
    {
        if(is_human_stay)
        {
            if(strcmp("human_stay",szTarName)==0&&(strstr(szSrcName,"g2_virus")!=NULL))
            {
                clearsceen();
                if(is_fail)
                    dDeleteSprite("fail"),is_fail=0;
                create_fail();
                dSetSpritePosition("fail",0,0);
                if(is_fanhui)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
                dStopAllSound();
                dStopSound(id1);
                dStopSound(id2);
                dPlaySound("fail.ogg",0,1);
                printf("失败界面");
                g2_fail=1;
            }
            else  if(strcmp("human_stay",szTarName)==0&&(strstr(szSrcName,"g2m0")!=NULL))
            {
                g2_scores++;
                dDeleteSprite(szSrcName);
            }
        }
        if(is_human)//g2m0
        {
            if(strstr(szSrcName,"g2_virus")!=NULL&&(strcmp(szTarName,"human")==0))
            {
                clearsceen();
                if(is_fail)
                    dDeleteSprite("fail"),is_fail=0;
                create_fail();
                dSetSpritePosition("fail",0,0);
                if(is_fanhui)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
                printf("失败界面");
                dStopAllSound();
                dStopSound(id1);
                dStopSound(id2);
                dPlaySound("fail.ogg",0,1);
                //dPlaySound(const char *szName, const int iLoop, const float fVolume );
                g2_fail=1;
            }
            else  if(strcmp("human",szTarName)==0&&(strstr(szSrcName,"g2m0")!=NULL))
            {
                g2_scores++;
                dDeleteSprite(szSrcName);
            }
        }
    }
    ///333333333333333333333333333333333333333333333333333333
    ///333333333333333333333333333333333333333333333333333333
    ///333333333333333333333333333333333333333333333333333333
    if(gamestate3==1)
    {
        if(is_xunluo&&g3_fail==0)
        {
            if(((strstr(szSrcName,"player1")!=NULL)||(strstr(szSrcName,"player2")!=NULL))&&(strstr(szTarName,"xunluo0")!=NULL))
            {
                ///失败
                g3_fail=1;
                if(is_fail)
                    dDeleteSprite("fail");
                create_fail();
                is_fail=1;
                printf("第三关失败\n");
                dSetSpritePosition("fail",0,0);
                if(is_fanhui)
                    dDeleteSprite("fanhui"),is_fanhui=0;
                create_fanhui();
                dSetSpritePosition("fanhui",40,33);
                dStopAllSound();
                dStopSound(id1);
                dStopSound(id2);
                dPlaySound("fail.ogg",0,1);
            }
        }
        if(is_chuansong)
        {
            if(strstr(szSrcName,"player1")!=NULL&&(strcmp(szTarName,"chuansong1")==0))
            {
                is_shouji1=1;
                printf("is_shouji1\n");
            }
            if(strstr(szSrcName,"player2")!=NULL&&(strcmp(szTarName,"chuansong2")==0))
            {
                is_shouji2=1;
                printf("is_shouji2\n");
            }
        }
        if(is_player1)///碰到病毒 停下
        {
            printf("981\n");
            if(strcmp("player1",szSrcName)==0&&(strstr(szTarName,"g3_block")!=NULL))
            {
                printf("983\n");
                dSetSpriteLinearVelocity("player1",0,0);
            }
        }
        if(is_player2)///碰到病毒 停下
        {
            if(strstr(szSrcName,"player")!=NULL&&(strstr(szTarName,"g3_block")!=NULL))
            {
                dSetSpriteLinearVelocity("player2",0,0);
            }
        }
        if(!is_player1_dongzhu)
        {
            if(strstr(szTarName,"g3_block5")!=NULL&&(strcmp(szSrcName,"player1")||strcmp(szTarName,"player1_stay")))
            {
                is_player1_dongzhu=1;
                is_dongzhu_time1=5;
                float dx=dGetSpritePositionX(szTarName);
                float dy=dGetSpritePositionY(szTarName);
                if(is_dongzhu)
                    dDeleteSprite("dongzhu");
                create_dongzhu();
                dSetSpritePosition("dongzhu",dx,dy);
            }
        }
        if(!is_player2_dongzhu)
        {
            if(strstr(szTarName,"g3_block5")!=NULL&&(strcmp(szSrcName,"player2")||strcmp(szTarName,"player2_stay")))
            {
                is_player2_dongzhu=1;
                is_dongzhu_time2=5;
                if(is_dongzhu)
                    dDeleteSprite("dongzhu");
                create_dongzhu();
                float dx=dGetSpritePositionX(szTarName);
                float dy=dGetSpritePositionY(szTarName);
                dSetSpritePosition("dongzhu",dx,dy);
            }
        }
    }
    // 可以在此添加游戏需要的响应函数
    OnSpriteColSprite(szSrcName, szTarName);

}

//===========================================================================
//
// 引擎捕捉到精灵与世界边界碰撞之后,调用此函数.
// 精灵之间要产生碰撞,必须在编辑器或者代码里设置精灵的世界边界限制
// 参数 szName:碰撞到边界的精灵名字
// 参数 iColSide:碰撞到的边界 0 左边,1 右边,2 上边,3 下边
//
void dOnSpriteColWorldLimit( const char *szName, const int iColSide )
{
    //if(is_g1_penzi)//dSetSpriteWorldLimitMode( const char *szName, const EWorldLimit Limit );
    //dSetSpriteWorldLimit( const char *szName, const EWorldLimit Limit, const float fLeft, const float fTop, const float fRight, const float fBottom );

    // 可以在此添加游戏需要的响应函数//-40,-30
    OnSpriteColWorldLimit(szName, iColSide);
}
void create_bd0()
{
    //bd0_muban
    char name[20];
    strcpy(name,"bd0");
    dCloneSprite("bd0_muban",name);
    is_bd0=1;
}
void create_bd1()
{
    char name[20];
    strcpy(name,"bd1");
    dCloneSprite("bd1_muban",name);
    is_bd1=1;
}
void create_g1_penzi()
{
    char name[20];
    strcpy(name,"g1_penzi");
    dCloneSprite("g1_penzi_muban",name);
    is_g1_penzi=1;
    dSetSpriteWorldLimitMode( "g1_penzi",	WORLD_LIMIT_STICKY );

}
void create_jieshao()
{
    char name[20];
    strcpy(name,"jieshao");
    dCloneSprite("jieshao_muban",name);
    is_jieshao=1;
}
void create_kaishi()
{
    char name[20];
    strcpy(name,"kaishi");
    dCloneSprite("kaishi_muban",name);
    is_kaishi=1;
}
void create_fanhui()
{
    char name[20];
    strcpy(name,"fanhui");
    dCloneSprite("fanhui_muban",name);
    is_fanhui=1;
}
void create_story01()
{
    char name[20];
    strcpy(name,"story01");
    printf("create story01\n");
    dCloneSprite("story01_muban",name);
    is_story01=1;
}
void create_story12()
{
    //story12_muban
    char name[20];
    strcpy(name,"story12");
    printf("create story12\n");
    dCloneSprite("story12_muban",name);
    is_story12=1;
}
void create_g1_djs()
{
    char name[20];
    strcpy(name,"g1_djs");
    dCloneSprite("g1_djs_muban",name);
    is_g1_djs=1;
}
void create_g1_scores()
{
    char name[20];
    strcpy(name,"g1_scores");
    dCloneSprite("g1_scores_muban",name);
    is_g1_scores=1;
}
void create_xianjie01()
{
    char name[20];
    strcpy(name,"xianjie01");
    dCloneSprite("xianjie01_muban",name);
    is_xianjie01=1;
}
void create_jieshaowenben()
{
    char name[50];
    strcpy(name,"jieshaowenben");
    dCloneSprite("jieshaowenben_muban",name);
    is_jieshaowenben=1;

}

void g1_clearfall()
{
    for(int i=1; i<=13; i++)
    {
        dDeleteSprite(dMakeSpriteName("virus0",i));
        dDeleteSprite(dMakeSpriteName("g1m0",i));
    }
}
void create_page0()
{
    dDeleteSprite("g1_penzi");
    dDeleteSprite("fail");
    is_g1_penzi=0;
    if(is_fanhui)
        dDeleteSprite("fanhui"),is_fanhui=0;
    create_bd0();//背景bd0
    dSetSpritePosition("bd0",0,0);
    create_jieshao();
    dSetSpritePosition("jieshao",25,20);
    create_kaishi();
    dSetSpritePosition("kaishi",-25,20);
    if(is_bangdan)
        dDeleteSprite("bangdan");
    create_bangdan();
    dSetSpritePosition("bangdan",40,-33);
}
void create_page1()
{
    if(is_bd1)
        dDeleteSprite("bd1");
    if(is_g1_penzi)
        dDeleteSprite("g1_penzi");
    if(is_g1_djs)
        dDeleteSprite("g1_djs");
    if(is_g1_scores)
        dDeleteSprite("g1_scores");
    if(is_fanhui)
        dDeleteSprite("fanhui");
    create_bd1();
    create_g1_penzi();
    create_g1_djs();
    create_g1_scores();
    create_fanhui();

    g1_scores=0;//关卡1的得分
    g1_djs=30;///ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt
}
void delete_page0()
{
    dDeleteSprite("bd0");
    is_bd0=0;
    dDeleteSprite("jieshao");
    is_jieshao=0;
    dDeleteSprite("kaishi");
    is_kaishi=0;
}
void delete_page1()
{
    dDeleteSprite("bd1");
    is_bd1=0;
    dDeleteSprite("g1_penzi");
    is_g1_penzi=0;
    dDeleteSprite("g1_djs");
    is_g1_djs=0;
    dDeleteSprite("g1_scores");
    is_g1_scores=0;
    dDeleteSprite("fail");
    is_fail=0;
    dDeleteSprite("xianjie01");
    is_xianjie01=0;
    dDeleteSprite("fanhui");
    is_fanhui=0;
    g1_clearfall();
}
void create_win()
{
    char name[50];
    strcpy(name,"win");
    dCloneSprite("win_muban",name);
    is_win=1;
}
void create_human()
{
    char name[50];
    strcpy(name,"human");
    dCloneSprite("human_muban",name);
    is_human=1;
}
void create_xianjie12()
{
    char name[50];
    strcpy(name,"xianjie12");
    dCloneSprite("xianjie12_muban",name);
    is_xianjie12=1;
}
void create_fail()
{
    char name[50];
    strcpy(name,"fail");
    dCloneSprite("fail_muban",name);
    is_fail=1;
}
void  create_bd2()
{
    char name[50];
    strcpy(name,"bd2");
    dCloneSprite("bd2_muban",name);
    is_bd2=1;
}
void create_bd2a()
{
    char name[50];
    strcpy(name,"bd2a");
    dCloneSprite("bd2a_muban",name);//bd2a_muban
    is_bd2a=1;
}
void g1_fall()
{
    for(int i=1; i<=8; i++)
    {
        char *s=dMakeSpriteName("g1m",i);
        char *t=dMakeSpriteName("g1m0",i);
        dCloneSprite(s,t);
        float dx=dRandomRange(g_wleft+5,g_wright-15);
        //float dy=dRandomRange(-40,-20);
        float dv=dRandomRange(20,25);
        dSetSpritePosition(t,dx,g_wtop-5);
        dSetSpriteLinearVelocity(t,0,dv);

    }
    for(int i=1; i<=8; i++)
    {
        char *t=dMakeSpriteName("virus0",i);
        dCloneSprite("virus_muban1",t);
        float dx=dRandomRange(g_wleft+5,g_wright-15);
        float dy=dRandomRange(-40,-20);
        float dv=dRandomRange(15,20);
        dSetSpritePosition(t,dx,dy);
        dSetSpriteLinearVelocity(t,0,dv);
    }

}

void init()
{
    clearsceen();
    ///222222222222222222222
    clear_g2_zuai();
    g1_clearfall();

    g_show12=0;
    g_show01=0;
    g_show23=0;
    g_show_story01=0;
    g_show_story12=0;
    g_show_story23=0;
    gamestate1=0;
    gamestate2=0;
    gamestate3=0;//关卡状态
    g1_fail=0;
    g2_fail=0;
    g3_fail=0;

}

void create_page2()
{
    if(is_bd2)
        dDeleteSprite("bd2");
    create_bd2();
    if(is_human)
        dDeleteSprite("human");
    create_human();
    if(is_fanhui)
        dDeleteSprite("fanhui"),is_fanhui=0;
    create_fanhui();
    if(is_g1_djs)
        dDeleteSprite("g1_djs"),is_fanhui=0;
    create_g1_djs();

    g1_djs=30;
    g2_scores=0;
    dSetSpritePosition("g1_djs",25,-28);
    dSetSpritePosition("bd2",0,0);
    dSetSpritePosition("human",-42,5);
    dSetSpritePosition("fanhui",40,33);
    dSetSpritePosition("g1_scores",25,-23);
}
void delete_page2()
{
    if(is_bd2)
        dDeleteSprite("bd2");
    //create_bd2();
    if(is_human)
        dDeleteSprite("human");
    //create_human();
    if(is_fanhui)
        dDeleteSprite("fanhui"),is_fanhui=0;
    //create_fanhui();
    if(is_g1_djs)
        dDeleteSprite("g1_djs"),is_g1_djs=0;
    if(is_g1_scores)
        dDeleteSprite("g1_scores"),is_g1_scores=0;
}
void clearsceen()
{
    if(is_bangdan)
        dDeleteSprite("bangdan"),is_bangdan=0;
    if(is_bd_bangdan)
        dDeleteSprite("bd_bangdan"),is_bd_bangdan=0;
    if(is_bd0)
        dDeleteSprite("bd0"),is_bd0=0;
    if(is_bd1)
        dDeleteSprite("bd1"),is_bd1=0;
    if(is_g1_penzi)
        dDeleteSprite("g1_penzi"),is_g1_penzi=0;
    if(is_jieshao)
        dDeleteSprite("jieshao"),is_jieshao=0;
    if(is_kaishi)
        dDeleteSprite("kaishi"),is_kaishi=0;
    if(is_fanhui)
        dDeleteSprite("fanhui"),is_fanhui=0;
    if(is_g1_djs)
        dDeleteSprite("g1_djs"),is_g1_djs=0;
    if( is_g1_scores)
        dDeleteSprite("g1_scores"), is_g1_scores=0;
    if(is_xianjie01)
        dDeleteSprite("xianjie01"), is_xianjie01=0;
    if(is_jieshaowenben)
        dDeleteSprite("jieshaowenben"),is_jieshaowenben=0;
    if(is_win)
        dDeleteSprite("win"),is_win=0;
    if(is_fail)
        dDeleteSprite("fail"),is_fail=0;
    if(is_bd2)
        dDeleteSprite("bd2"), is_bd2=0;
    if(is_human)
        dDeleteSprite("human"),is_human=0;
    if(is_xianjie12)
        dDeleteSprite("xianjie12"),is_xianjie12=0;
    if(is_human_stay)
        dDeleteSprite("human_stay"),is_human_stay=0;
    if(is_story12)
        dDeleteSprite("story12"),is_story12=0;
    if(is_story01)
        dDeleteSprite("story01"),is_story01=0;
    if(is_bd2a)
        dDeleteSprite("bd2a"),is_bd2a=0;
    if(is_bd3)
        dDeleteSprite("bd3"),is_bd3=0;
    if(is_xianjie23)
        dDeleteSprite("xianjie23"),is_xianjie23=0;
    if(is_story23)
        dDeleteSprite("story23"),is_story23=0;
    if(is_player1)
        dDeleteSprite("player1"),is_player1=0;
    if(is_player2)
        dDeleteSprite("player2"),is_player2=0;
    if(is_men)
        dDeleteSprite("men"),is_men=0;
    if(is_dongzhu)
        dDeleteSprite("dongzhu"),is_dongzhu=0;
    if(is_player1_stay)
        dDeleteSprite("player1_stay"),is_player1_stay=0;
    if(is_player2_stay)
        dDeleteSprite("player2_stay"),is_player2_stay=0;
    if(is_last)
        dDeleteSprite("last"),is_last=0;
    dDeleteSprite("bian01");dDeleteSprite("bian02");
    if(is_chuansong)
    {
        dDeleteSprite("chuansong1");
        dDeleteSprite("chuansong2");
        is_chuansong=0;

    }
    if(is_xunluo)
    {
        dDeleteSprite("xunluo01");
        dDeleteSprite("xunluo02");
        dDeleteSprite("xunluo03");
        dDeleteSprite("xunluo04");
        is_xunluo=0;
    }
    if(is_men2)
        dDeleteSprite("men2"),is_men2=0;
    for(int i=0; i<=15; i++)
        dDeleteSprite(dMakeSpriteName("paimin",i));
    clear_g3();
    clear_g2_zuai();
    g1_clearfall();

}

void create_human_stay()
{
    char name[50];
    strcpy(name,"human_stay");
    dCloneSprite("human_stay_muban",name);
    is_human_stay=1;
}
void g2_zuai()
{
    char name[20];
    for(int i=1; i<=5; i++)
    {
        strcpy(name,dMakeSpriteName("g2_virus",i));
        if(i%2==1)
            dCloneSprite("g2m1",name);
        if(i%2==0)
            dCloneSprite("g2m2",name);
    }
    for(int i=1; i<=8; i++)
    {
        char *s=dMakeSpriteName("g1m",i);
        char *t=dMakeSpriteName("g2m0",i);
        dCloneSprite(s,t);
    }
}
void clear_g2_zuai()
{
    char name[20];
    for(int i=1; i<=5; i++)
    {
        strcpy(name,dMakeSpriteName("g2_virus",i));
        if(i%2==1)
            dDeleteSprite(name);
        if(i%2==0)
            dDeleteSprite(name);
    }
    for(int i=1; i<=8; i++)
    {
        // char *s=dMakeSpriteName("g1m",i);
        char *t=dMakeSpriteName("g2m0",i);
        dDeleteSprite(t);
    }
}


void create_bd3()
{
    char name[50];
    strcpy(name,"bd3");
    dCloneSprite("bd3_muban",name);
    is_bd3=1;
}
void create_story23()
{
    char name[50];
    strcpy(name,"story23");
    dCloneSprite("story23_muban",name);
    is_story23=1;
}
// create_xianjie23();
void create_xianjie23()
{
    char name[50];
    strcpy(name,"xianjie23");
    dCloneSprite("xianjie23_muban",name);
    is_xianjie23=1;
}
void create_player1()
{
    char name[50];
    strcpy(name,"player1");
    dCloneSprite("player1_muban",name);
    is_player1=1;
    dSetSpriteWorldLimitMode( "player1",	WORLD_LIMIT_STICKY );
}
void create_player2()
{
    char name[50];
    strcpy(name,"player2");
    dCloneSprite("player2_muban",name);
    is_player2=1;
    dSetSpriteWorldLimitMode( "player2",	WORLD_LIMIT_STICKY );
}
void create_player1_stay()
{
    char name[50];
    strcpy(name,"player1_stay");
    dCloneSprite("player1_stay_muban",name);
    is_player1_stay=1;
}
void create_player2_stay()
{
    char name[50];
    strcpy(name,"player2_stay");
    dCloneSprite("player2_stay_muban",name);
    is_player2_stay=1;
}

void create_men()
{
    char name[50];
    strcpy(name,"men");
    dCloneSprite("men_muban",name);
    is_men=1;

}
//chuansong_muban
void create_chuansong()
{
    char name[50];
    strcpy(name,"chuansong1");
    dCloneSprite("chuansong_muban",name);
    strcpy(name,"chuansong2");
    dCloneSprite("chuansong_muban",name);
    is_chuansong=1;
}
void create_dongzhu()
{
    char name[50];
    strcpy(name,"dongzhu");
    dCloneSprite("dongzhu_muban",name);
    is_dongzhu=1;
}
void clear_g3()
{
    for(int i=0; i<25; i++)
    {
        for(int j=0; j<19; j++)
        {
            if(g3_bolocks[i][j]!=0)//可消灭的
            {
                char name[50];
                int t=g3_bolocks[i][j];
                strcpy(name, dMakeSpriteName(dMakeSpriteName("g3_block",t),i*25+j));
                dDeleteSprite(name);
            }

        }
    }
}
void create_last()
{
    char name[50];
    strcpy(name,"last");
    dCloneSprite("last_muban",name);
    is_last=1;
}
void create_men2()
{
    char name[50];
    strcpy(name,"men2");
    dCloneSprite("men_muban",name);
    is_men2=1;
}
void create_bd_bangdan()
{
    char name[50];
    strcpy(name,"bd_bangdan");
    dCloneSprite("bd_bangdan_muban",name);
    is_bd_bangdan=1;
}
void create_bangdan()
{
    char name[50];
    strcpy(name,"bangdan");
    dCloneSprite("bangdan_muban",name);
    is_bangdan=1;
}
void create_page3()
{
    dDeleteSprite("fail");
    if(is_bd3)
        dDeleteSprite("bd3");
    create_bd3();
    dSetSpritePosition("bd3",0,0);
    create_edge();

    if(is_men)
        dDeleteSprite("men");
    create_men();
    dSetSpritePosition("men",46,-33);
    if(is_men2)
        dDeleteSprite("men2");
    create_men2();
    dSetSpritePosition("men2",-46,-33);
    if(is_xunluo)
        dDeleteSprite("xunluo01"),dDeleteSprite("xunluo02"),dDeleteSprite("xunluo03"),dDeleteSprite("xunluo04"),is_xunluo=0;
    create_xunluo();
    dSetSpritePosition("xunluo01",-40,-32);
    dSetSpritePosition("xunluo02",32,-30);
    dSetSpritePosition("xunluo03",15,30);
    dSetSpritePosition("xunluo04",-8,10);
    dSetSpriteLinearVelocity("xunluo01",10,0);
    dSetSpriteWorldLimit("xunluo01",	WORLD_LIMIT_BOUNCE,-40,-35, 10, -25);
    dSetSpriteLinearVelocity("xunluo02",0,15);
    dSetSpriteWorldLimit("xunluo02",	WORLD_LIMIT_BOUNCE,25,-30, 35,10);
    dSetSpriteLinearVelocity("xunluo03",-10,0);//            左,上,右,下
    dSetSpriteWorldLimit("xunluo03",	WORLD_LIMIT_BOUNCE,-30,-50, 20,40);
    dSetSpriteLinearVelocity("xunluo04",0,-5);//            左,上,右,下
    dSetSpriteWorldLimit("xunluo04",	WORLD_LIMIT_BOUNCE,-50,-15, 50,10);
    if(is_player1_stay)
        dDeleteSprite("player1_stay");
    create_player1_stay();
    if(is_player2_stay)
        dDeleteSprite("player2_stay");
    create_player2_stay();

    dSetSpritePosition("player1_stay",-42,30);
    dSetSpritePosition("player2_stay",-42,18);
    if(is_fanhui)
        dDeleteSprite("fanhui");
    create_fanhui();
    dSetSpritePosition("fanhui",40,33);
    if(is_chuansong)
    {
        dDeleteSprite("chuansong1");
        dDeleteSprite("chuansong2");
    }
    create_chuansong();
    dSetSpritePosition("chuansong1",-38,2);
    dSetSpritePosition("chuansong2",38,2);
}

void create_bian()
{
    is_bian=1;
    for(int i=1; i<=2; i++)
    {
        char name[50];
        strcpy(name,dMakeSpriteName("bian0",i));
        dCloneSprite("bian_muban",name);
        dSetSpriteWorldLimitMode( name,	WORLD_LIMIT_BOUNCE);
    }
    dSetSpritePosition("bian01",20,30);
        dSetSpriteLinearVelocity("bian01",-3,5);
    dSetSpritePosition("bian02",-10,-20);
        dSetSpriteLinearVelocity("bian02",5,-3);
}

 

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部