gameframe.cpp

这是一个用BREW和VC++开发的暴力摩托游戏,与大家一同分享.

//////////////////////////////////////////////////////////////////////
//FILE: GameFrame.cpp
//Gameplay
//////////////////////////////////////////////////////////////////////

#include "GameFrame.h"
//#include "Data.h"

/*===============================================================================
METHOD: GameFrame
Constructor
=============================================================================== */
GameFrame::GameFrame( Ducati* pAppInterface, IShell* pIShell )
{
	// pAppInterface is used for quit and stuff, check RedDwarf
	m_pIShell = pIShell;
	m_pIDisplay = NULL;
	m_pIGraphics = NULL;
	m_pGraph = NULL;
	m_pFrontend = NULL;
	m_pData = NULL;

	m_pKscUtil =NULL;

	m_pRandom = NULL;

	m_canvasW = 0;
	m_canvasH = 0;

	m_bRunning = FALSE;
	m_frameTime = 0;
	m_frameStart = 0;
	m_frameEnd = 0;
	m_frameSkip = 0;

	m_raceStartTime = 0;
	m_currentMillisecs = 0;

	m_bRainning = FALSE;

	m_isCliff = 0;

	m_bRace_over = TRUE;
	m_numberOfLaps = 0;
	m_trackLength = 0;

	m_bendIdx = 0;
	m_bendPos = 0;
	m_bendEndPos = 0;
	m_bendLength = 0;
	m_bendAngle = 0;

	m_hillIdx = 0;
	m_hillPos = 0;
	m_hillLength = 0;
	m_hillAngle = 0;

	m_cliffY = 0;

	m_tunnelIdx = 0;
	m_tunnelZPos = 0;
	m_tunnelLength = 0;

	m_backdropXPos = 0;
	m_backdropWidth = 0;

	m_skyXPos = 0;
	m_skyWidth = 0;

	m_lean = 0;
	m_drag = 0;
	m_revs = 0;
	m_topSpeed = 0;
	m_bWobbledLastTime = FALSE;

	m_bCrashing = FALSE;
	m_crashTime = 0;
	m_crashSpeed = 0;
	m_crashX = 0;
	m_crashY = 0;

	m_maxSpeed = 0;
	m_handling = 0;
	m_acceleration = 0;

	m_bDoingPowerSlide = FALSE;
	m_powerSlideCount = 0;
	m_powerSlideStart = 0;
	
	m_lapStartTime = 0;
	m_lastLapTime = 0;
	m_bestLapTime = 0;
	m_raceTime = 0;

	m_pTreeRandom = NULL;
	m_firstTree = 0;

	m_numSceneryObjects = 0;
	m_lastSceneryItem = 0;

	m_numBikes = 0;

	m_padData=0;
	m_lastPad=0;
	m_debouncePad=0;

	m_pausedTime = 0;
	m_bPaused = FALSE;	

	m_leftCanyonIdx = 0;
	m_rightCanyonIdx = 0;
	m_drawIdx = 0;
}

/*===============================================================================
METHOD: ~GameFrame
Destructor
=============================================================================== */
GameFrame::~GameFrame()
{
	if(m_pTreeRandom)
		delete m_pTreeRandom;

	if(m_pRandom)
		delete m_pRandom;

	if(m_pFrontend)
		delete m_pFrontend;

	if(m_pData)
		delete m_pData;

	if(m_pGraph)
		delete m_pGraph;

	if(m_pKscUtil)
		delete m_pKscUtil;

	m_pTreeRandom = NULL;
	m_pRandom = NULL;
	m_pData = NULL;
	m_pFrontend = NULL;
	m_pGraph = NULL;

	m_pKscUtil =NULL;

	m_pTrackData = NULL;

	FREE(m_pTrackTable);
	FREE(m_pTrackSceneryTable);
	FREE(m_pTreeVtxTable);
	FREE(m_pTreePolyTable);

	if(m_pIGraphics)
		IGRAPHICS_Release(m_pIGraphics);

	if(m_pIDisplay)
		IDISPLAY_Release(m_pIDisplay);

}

/*===============================================================================
METHOD: Init
=============================================================================== */
boolean GameFrame::Init()
{

	ISHELL_CreateInstance( m_pIShell, AEECLSID_DISPLAY, ( void ** ) &m_pIDisplay );
	if(!m_pIDisplay)
		return FALSE;

	ISHELL_CreateInstance( m_pIShell, AEECLSID_GRAPHICS, ( void ** ) &m_pIGraphics );
	if(!m_pIGraphics)
		return FALSE;

	ISHELL_GetDeviceInfo( m_pIShell, &m_DeviceInfo );
	m_canvasW = m_DeviceInfo.cxScreen;
	m_canvasH = m_DeviceInfo.cyScreen;
	if(m_canvasW < 100 || m_canvasH < 100)	// screen on device is too small
		return FALSE;

	m_pGraph = new Graphics(m_pIGraphics, m_pIDisplay);
	if(!m_pGraph)
		return FALSE;

	m_pKscUtil = new KSCUtil(m_pIDisplay);
	if(!m_pKscUtil)
		return FALSE;

	//YingZ: MUST initialise Data before frontend
	m_pData = new Data();
	if(!m_pData)
		return FALSE;
	m_pData->Init();
	m_pData->Init2();
	m_pData->Init3();
	m_pData->Init4();

	m_pFrontend = new Frontend(this);
	if(!m_pFrontend)
		return FALSE;
	m_pFrontend->InitFE();

	//YingZ: A floater debugger point for getting code to run on actual device
	//return TRUE;

	m_pRandom = new Random();
	if(!m_pRandom)
		return FALSE;

	m_pTreeRandom = new Random();
	if(!m_pTreeRandom)
		return FALSE;

	m_gameState = GS_FRONTEND;

	//YingZ: A Rather clumsy way to initalise data for array of arrays (2D array)
	//blame it on Brew don't support static pointer arrays.
	//Investigate to see if there's more elegant solution
	//and remember to free up the memory upon quit!
	m_pTrackTable = ( int** )( MALLOC( sizeof( int* ) * NUM_TRACKS ) );
	m_pTrackTable[0] = m_pData->track1;
	m_pTrackTable[1] = m_pData->track2;
	m_pTrackTable[2] = m_pData->track3;
	m_pTrackTable[3] = m_pData->track4;
	m_pTrackTable[4] = m_pData->track5;
	m_pTrackTable[5] = m_pData->track6;
	m_pTrackTable[6] = m_pData->track7;
	m_pTrackTable[7] = m_pData->track8;
	m_pTrackTable[8] = m_pData->canyonTrack;

	m_pTrackSceneryTable = ( int** )( MALLOC( sizeof( int* ) * NUM_TRACKS ) );
	m_pTrackSceneryTable[0] = m_pData->track1Scenery;
	m_pTrackSceneryTable[1] = m_pData->track2Scenery;
	m_pTrackSceneryTable[2] = m_pData->track3Scenery;
	m_pTrackSceneryTable[3] = m_pData->track4Scenery;
	m_pTrackSceneryTable[4] = m_pData->track5Scenery;
	m_pTrackSceneryTable[5] = m_pData->track6Scenery;
	m_pTrackSceneryTable[6] = m_pData->track7Scenery;
	m_pTrackSceneryTable[7] = m_pData->track5Scenery;
	m_pTrackSceneryTable[8] = NULL;

	m_pTreeVtxTable = ( short** )( MALLOC( sizeof( short* ) * NUM_TREETYPE ) );
	m_pTreeVtxTable[0] = m_pData->tree1Vtx;
	m_pTreeVtxTable[1] = m_pData->tree2Vtx;
	m_pTreeVtxTable[2] = m_pData->tree3Vtx;
	m_pTreeVtxTable[3] = m_pData->tree4Vtx;
	m_pTreeVtxTable[4] = m_pData->tree5Vtx;
	m_pTreeVtxTable[5] = m_pData->tree6Vtx;
	m_pTreeVtxTable[6] = m_pData->cactiVtx;
	m_pTreeVtxTable[7] = m_pData->cacti2Vtx;

	m_pTreePolyTable = ( short** )( MALLOC( sizeof( short* ) * NUM_TREETYPE ) );
	m_pTreePolyTable[0] = m_pData->tree1Polys;
	m_pTreePolyTable[1] = m_pData->tree1Polys;
	m_pTreePolyTable[2] = m_pData->tree3Polys;
	m_pTreePolyTable[3] = m_pData->tree4Polys;
	m_pTreePolyTable[4] = m_pData->tree5Polys;
	m_pTreePolyTable[5] = m_pData->tree6Polys;
	m_pTreePolyTable[6] = m_pData->cactiPolys;
	m_pTreePolyTable[7] = m_pData->cactiPolys;

	m_roadColourL[0] = 0x9AC65D;
	m_roadColourL[1] = 0x667737;
	m_roadColourL[2] = 0x9AC65D;
	m_roadColourL[3] = 0xAC9976;
	m_roadColourL[4] = 0x667737;
	m_roadColourL[5] = 0x9AC65D;
	m_roadColourL[6] = 0x667737;
	m_roadColourL[7] = 0x697A38;
	m_roadColourL[8] = 0xAC9976;

	m_roadColourD[0] = 0x86B04C;
	m_roadColourD[1] = 0x5F6F2F;
	m_roadColourD[2] = 0x8EB854;
	m_roadColourD[3] = 0xA38D66;
	m_roadColourD[4] = 0x5C6C2E;
	m_roadColourD[5] = 0x8EB854;
	m_roadColourD[6] = 0x5F6F2F;
	m_roadColourD[7] = 0x637432;
	m_roadColourD[8] = 0xA38D66;

	m_SkyColour[0] = 0xA1B1C9;
	m_SkyColour[1] = 0xADBAC9;
	m_SkyColour[2] = 0x5D9FD9;
	m_SkyColour[3] = 0xFD6706;
	m_SkyColour[4] = 0xC6AE8D;
	m_SkyColour[5] = 0x4FA2FF;
	m_SkyColour[6] = 0xADBAC9;
	m_SkyColour[7] = 0xE7F6F6;
	m_SkyColour[8] = 0xE7F6F6;

	m_TarmacColour[0] = 0x888888;
	m_TarmacColour[1] = 0x707070;
	m_TarmacColour[2] = 0x8295A0;
	m_TarmacColour[3] = 0x7B7168;
	m_TarmacColour[4] = 0x7D6056;
	m_TarmacColour[5] = 0x888888;
	m_TarmacColour[6] = 0x707070;
	m_TarmacColour[7] = 0x707070;
	m_TarmacColour[8] = 0x606060;

	pSlide=m_pFrontend->PowerSlide;
	// Kick start the game tick
	m_bRunning = TRUE;
	m_frameTime = m_pFrontend->GameFrameDelay;
	GameTick(m_frameTime);

	

	return TRUE;
}
/*===============================================================================
METHOD: GameTick
Game Ticker
=============================================================================== */
void GameFrame::GameTick(int timerDelta)
{
	ISHELL_SetTimer(m_pIShell, timerDelta, GameFrame::GameLoop, this);
}

/*===============================================================================
METHOD: GameLoop
Game loop callback
=============================================================================== */
void GameFrame::GameLoop(void *user)
{
	 ISHELL_PostEvent(((GameFrame *)user)->m_pIShell, AEECLSID_DUCATIRACING, EVT_NEXT_FRAME, 0, 0);
	//((GameFrame *)user)->GameLoop();
}

/*===============================================================================
METHOD: GameLoop
The actual game loop
=============================================================================== */
void GameFrame::GameLoop()
{
	m_pFrontend->StartTune();

	m_frameStart = GETTIMEMS();

	if (m_bRunning)
	{

		GameTick(m_frameTime);
		Draw();

	}
	else
	{
		// Do quit stuff
	}

	m_frameEnd = GETTIMEMS() - m_frameStart;
	m_frameSkip = (int)(m_frameEnd/33);
	if (m_frameSkip > 9)
	{
		m_frameSkip = 9;
	}
}

/*===============================================================================
METHOD: InitialiseGame
=============================================================================== */
void GameFrame::InitialiseGame()
{
	InitRoad(m_pFrontend->m_currentTrack);
	InitPlayer();
	InitScenery();

	InitBikes();
	AddBike(0);		//player's bike
	for(int i = -3; i <= 3; i++)
	{
		if(i != 0)		//player bike
			AddBike(i * 20);
	}

	m_bRace_over = FALSE;

	ClearPad();
}

/*===============================================================================
METHOD: Draw
=============================================================================== */
void GameFrame::Draw()
{
	UpdateScreen();
	IDISPLAY_Update(m_pIDisplay);
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/*===============================================================================
METHOD: UpdateScreen
=============================================================================== */
void GameFrame::UpdateScreen()
{

	if(m_gameState == GS_RACING)
	{
		m_currentMillisecs = GETTIMEMS();
		UpdatePad();
		if(m_currentMillisecs - m_raceStartTime >= 4000)
		{
			ControlPlayer();
			Ai();
		}
		m_frameSkip--;

		if(m_pFrontend->m_currentTrack == 8)
			DrawCanyonRoad();
		else
		{
			//don't draw over panel
		//	m_pGraph->SetColor(0xEC1B2D);
		//	m_pGraph->SetFillColor(0xEC1B2D);
		//	m_pGraph->FillRect(0,36,m_canvasW,m_canvasH);
			//m_canvasW=170;
			m_pGraph->SetScreenClip(0, 36, m_canvasW, m_canvasH);

			if(m_pFrontend->m_currentTrack == 2)
				DrawCliffsideRight();
			else if(m_pFrontend->m_currentTrack == 5)
				DrawCliffsideLeft();
			else
				DrawRoad();

			DrawScenery();
		}
		DrawBikes();

		m_pGraph->SetScreenClip( 0, 36, m_canvasW, m_canvasH);

		DrawRain();

		DrawPanel();

		if(m_currentMillisecs - m_raceStartTime < 5000)
			DrawStartLights(m_currentMillisecs - m_raceStartTime);

		if(m_bRace_over && m_speed[0] == 0)
			m_pFrontend->RaceOver();

	}
	else if(m_gameState==GS_FRONTEND)
	{
		int	done;

		m_currentMillisecs=GETTIMEMS();

		done=m_pFrontend->ProcessFE();
		if(done==1)
			InitRace();
		else if(done==-1)
			m_bRunning = FALSE;
	}
}

/*===============================================================================
METHOD: DrawStartLights
=============================================================================== */
void GameFrame::DrawStartLights(long time)
{
	int	i;

	int	y=m_canvasH>>1;

	//draw outer box of start lights
	m_pGraph->SetColor(64,64,64);
	m_pGraph->DrawRect((m_canvasW/4)-3,y-1,(m_canvasW/2)+3,(m_canvasH/6)+2);
	m_pGraph->SetFillColor(0,0,0);
	m_pGraph->FillRect(m_canvasW/4-2,y,m_canvasW/2+1,m_canvasH/6);

	for(i=1;i<=3;i++)	//three red lights
	{
		if(time-(i*1000)<0)
		{
			m_pGraph->SetColor(128,0,0);
			m_pGraph->SetFillColor(128,0,0);
		}
		else
		{
			m_pGraph->SetColor(255,0,0);
			m_pGraph->SetFillColor(255,0,0);
		}
		m_pGraph->FillArc((i+1)*(m_canvasW/8),y+m_canvasW/20,m_canvasW/10,m_canvasW/10);
	}
	if(time<4000)
	{