專業學習之路 的 第一個長文博客 hhhhh，可是出師不利，網很差，致使我寫完的文章直接消失了，因而我又來了一遍。python
以前怕python查重，我把全部的python文章都刪了，如今腸子都悔青了，只怪當時的我太過單純。不事後期應該會繼續寫python，哎，雖然我對python已經沒有感情了。大概會關於圖形圖像識別與處理方面。c++接下來說講個人funcode實習過程心得，hhh，第一個給老師驗收的隊伍，第一次一我的打了2000+行代碼，大概花了4天吧，其實後面幾天更可能是花在優化遊戲玩法。代碼框架部分我也另闢蹊徑，畢竟一我的搞會很自由hhhh，在我眼裏看這個代碼真的很笨，受限與funcode自己，我也不知道爲何不少庫都用不上，致使重複工做量很大。除此，funcode不能支持聯機，
在此很是感謝大佬幫我測試。雖然老師說咱們的遊戲作的挺不錯的，可是確實和一個4399一些經典遊戲相比，少了些趣味性。固然外行看熱鬧，內行看門道，感謝老師的鼓勵hhhh數組最後，其實有2個bug我一直沒改出來，其中一個bug是精靈跳躍部分，雖然我還有不少其餘思路來改，可是因爲本身的懶惰hhh就混過了這個小小的bug，雖然原理沒錯，可是參數不許確。另外一個bug是我到如今都沒有找到緣由，原理是絕對沒有錯的，可是座標就是不許確，（我printf出來也是正確的），我的認爲是funcode裏面的座標參數，以及精靈的中心點這個兩個點沒有很好匹配上。可是後面這個bug成了一個咱們隊很好的一個「有寓意的點」。不得不說我太能編了hhhh。cors
首先附上我修改好的十個提升案例
導入地圖，修改精靈名後直接用。框架
一、 海底世界
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
二、拼圖遊戲
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
三、桌球
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
四、 迷你高爾夫球
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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當前靜止，能夠移動，一、二、三、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
*/
五、彈彈堂
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
六、拍飛蟲
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
七、黃金礦工
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
八、打飛碟
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
九、太空戰機
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}
十、坦克大戰
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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;//關卡狀態
}
十一、接下來，附上個人代碼
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#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);
}