专业学习之路 的 第一个长文博客 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);
}
5069
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
