gameframe.cpp

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

		m_pGraph->SetColor(128,128,0);
		m_pGraph->SetFillColor(128,128,0);
	}
	else
	{
		m_pGraph->SetColor(255,255,0);
		m_pGraph->SetFillColor(255,255,0);
	}
	m_pGraph->FillArc(5*(m_canvasW/8),y+m_canvasW/20,m_canvasW/10,m_canvasW/10);
	DrawLapNum();
}

/*===============================================================================
METHOD: InitRace
=============================================================================== */
void GameFrame::InitRace()
{
	InitialiseGame();

	m_raceStartTime=GETTIMEMS();
	m_lapStartTime=m_raceStartTime+4000;

	m_bPaused=FALSE;
	m_gameState=GS_RACING;

	m_frameSkip=1;

	InitPanel();
	StartSound();
}

/*===============================================================================
METHOD: UpdatePad
=============================================================================== */
void GameFrame::UpdatePad()
{
	m_debouncePad = (m_lastPad & m_padData) ^ m_padData;
	m_lastPad = m_padData;

	if((m_debouncePad & PAD_RIGHT_SOFT_KEY) != 0)
	{
		if(!m_bPaused)
		{
			boolean bStopSnd = FALSE;
			PauseGame(bStopSnd);
		}
		else
			UnpauseGame();
	}
}

/*===============================================================================
METHOD: ClearPad
=============================================================================== */
void GameFrame::ClearPad()
{
	m_padData = 0;
	m_lastPad = 0;
	m_debouncePad = 0;
}

/*===============================================================================
METHOD: PauseGame
=============================================================================== */
void GameFrame::PauseGame(boolean bSuspendSnd)
{
	m_gameState = GS_FRONTEND;
	m_bPaused = TRUE;
	m_pausedTime = m_currentMillisecs;
	m_pFrontend->InitPauseScreen(bSuspendSnd);
}

/*===============================================================================
METHOD: UnpauseGame
=============================================================================== */
void GameFrame::UnpauseGame()
{
	long diff;

	m_bPaused = FALSE;

	m_gameState = GS_RACING;

	diff = m_currentMillisecs - m_pausedTime;
	m_raceStartTime += diff;
	m_lapStartTime += diff;

	InitPanel();

	ClearPad();
}

/*===============================================================================
METHOD: StartSound - Resume
=============================================================================== */
void GameFrame::StartSound(bool load)
{
	m_pFrontend->ResumeTune();
}

/*===============================================================================
METHOD: StopSound
=============================================================================== */
void GameFrame::StopSound(bool unload)
{
	m_pFrontend->StopTune(unload);
}

/*===============================================================================
METHOD: KeyPressed
=============================================================================== */
void GameFrame::KeyPressed(uint16 wParam)
{
	if(wParam==AVK_SOFT2 || wParam==AVK_CLR)
		m_padData|=PAD_RIGHT_SOFT_KEY;
	else if(wParam==AVK_SOFT1 || wParam == AVK_SEND || wParam == AVK_5 || wParam == AVK_SELECT)
		m_padData|=PAD_LEFT_SOFT_KEY;
	else if(wParam == AVK_UP || wParam == AVK_2)
		m_padData|=PAD_UP;
	else if(wParam == AVK_DOWN || wParam == AVK_8)
		m_padData|=PAD_DOWN;
	else if(wParam == AVK_LEFT || wParam == AVK_4)
		m_padData|=PAD_LEFT;
	else if(wParam == AVK_RIGHT || wParam == AVK_6)
		m_padData|=PAD_RIGHT;

	if(m_gameState==GS_FRONTEND)
		m_pFrontend->DealKeyPress(wParam);
}

/*===============================================================================
METHOD: KeyReleased
=============================================================================== */
void GameFrame::KeyReleased(uint16 wParam)
{
	if(wParam == AVK_UP || wParam == AVK_2)
		m_padData&=0xffff^PAD_UP;
	else if(wParam == AVK_DOWN || wParam == AVK_8)
		m_padData&=0xffff^PAD_DOWN;
	else if(wParam == AVK_LEFT || wParam == AVK_4)
		m_padData&=0xffff^PAD_LEFT;
	else if(wParam == AVK_RIGHT || wParam == AVK_6)
		m_padData&=0xffff^PAD_RIGHT;
	else if(wParam==AVK_SOFT1 || wParam == AVK_SEND || wParam == AVK_5 || wParam == AVK_SELECT)
		m_padData&=0xffff^PAD_LEFT_SOFT_KEY;
	else if(wParam==AVK_SOFT2 || wParam==AVK_CLR)
		m_padData&=0xffff^PAD_RIGHT_SOFT_KEY;
}


/*===============================================================================
METHOD: GetTimeString
=============================================================================== */
JString GameFrame::GetTimeString(long time)
{
	long mins;
	long seconds;
	long hundreths;
	JString str;

	mins=time/60000;
	seconds=(time%60000)/1000;
	hundreths=(time%1000)/10;

	str+=mins;
	str+=":";
	if(seconds<10)
		str+="0";
	str+=seconds;
	str+=":";
	if(hundreths<10)
		str+="0";
	str+=hundreths;

	return str;
}

/*===============================================================================
METHOD: DrawPanel
=============================================================================== */
void GameFrame::DrawPanel()
{
	int i;
	int	x;
	int y;

	int pos=6;
	x=2;

	int xx=4;
	m_pGraph->SetScreenClip(0,0,m_canvasW,m_canvasH);
	do
	{
		//go backwards so player is drawn first in tied situations
		
		for(i=NUM_BIKES-1;i>=0;i--)
		{
			if(pos==m_racePos[i]-1)
			{
				int c=m_character[i];
				if(m_lastFace[pos]!=c)
				{
					//draw box around player
					if(i==0)
					{
						m_pGraph->SetColor(0xffff00);
						m_pGraph->DrawRect(x-1,4,18,18);
					}
					else
					//if(m_lastFace[pos]==m_character[0])	//this was the player, remove box
					{
						m_pGraph->SetColor(236,27,45);
						m_pGraph->DrawRect(x-1,4,18,18);
					}
					m_lastFace[pos]=c;
					DrawFace(c,x,5);
					m_pGraph->SetBitmapClip(x,23,20,6);
					m_pGraph->DrawImage(m_pFrontend->m_pPng[PNG_PANEL],2+(x-xx),23);	
				}
				x+=26;
				xx+=18;
			}
		}
		pos--;
	}while(pos>=0);

	//race and lap time
	if(m_currentMillisecs-m_raceStartTime>4000)
	{
		DrawLapNum();
		if(!m_bRace_over)
		{
			DrawPanelTime(20,(int)(m_currentMillisecs-m_raceStartTime-4000));
			DrawPanelTime(70,(int)(m_currentMillisecs-m_lapStartTime));
		}
		else
		{
			DrawPanelTime(20,(int)m_raceTime);
			DrawPanelTime(70,(int)m_lastLapTime);
		}
	}
	else
	{
		DrawPanelTime(20,0);
		DrawPanelTime(70,0);
	}
	//speed
	int num=m_speed[0]>>18;
	int tenths=(num%100)/10;
	int units=num%10;
	
	m_pGraph->SetBitmapClip(133,85,8,12);
	if(num>99)
		m_pGraph->DrawImage(m_pFrontend->m_pNums,133-m_pData->panelNumOffsets[1],85);
	else
		m_pGraph->DrawImage(m_pFrontend->m_pNums,133-m_pData->panelNumOffsets[0],85);
	m_pGraph->SetBitmapClip(141,85,8,12);
	m_pGraph->DrawImage(m_pFrontend->m_pNums,141-m_pData->panelNumOffsets[tenths],85);
	m_pGraph->SetBitmapClip(149,85,8,12);
	m_pGraph->DrawImage(m_pFrontend->m_pNums,149-m_pData->panelNumOffsets[units],85);

	//YingZ: Added MPH to speedo meter
	//red Back
	//m_pGraph->SetColor(0xEC1B2D);
	//m_pGraph->SetFillColor(0xEC1B2D);
	//m_pGraph->FillRect(112,130,13,13);
	//numbers
	/*m_pGraph->SetBitmapClip(113,131,3,5);
	if(num>99)
		DrawImage(m_pFrontend->m_pPng[PNG_PANEL],113-m_pData->panelNumberOffsets[1],124);
	else
		DrawImage(m_pFrontend->m_pPng[PNG_PANEL],113-m_pData->panelNumberOffsets[0],124);
	m_pGraph->SetBitmapClip(117,131,3,5);
	DrawImage(m_pFrontend->m_pPng[PNG_PANEL],117-m_pData->panelNumberOffsets[tenths],124);
	m_pGraph->SetBitmapClip(121,131,3,5);
	DrawImage(m_pFrontend->m_pPng[PNG_PANEL],121-m_pData->panelNumberOffsets[units],124);*/
	
	//"MPH"
#define MPH_OFFSET  59
	//m_pGraph->SetBitmapClip(113,137,11,5);
	//DrawImage(m_pFrontend->m_pPng[PNG_PANEL],113-MPH_OFFSET,130);
	
		
	//speedo
	//rev counter line
	m_pGraph->ResetBitmapClip();
	//DrawImage(m_pFrontend->m_pTimes,0,40);
	m_pKscUtil->DrawImage(m_pFrontend->m_TimesImg,0,40);

	m_pGraph->DrawImage(m_pFrontend->m_pPng[PNG_SPEEDO],69,43);
	m_pGraph->SetColor(0xffff00);
	i=(m_revs*2844)>>16;		//2850 is 250 degrees in my angles
	i+=546;		//position 0 on rev counter is at 48 degrees
	x=Sin(i)/150;
	y=Cos(i)/150;
	m_pGraph->DrawLine(86,61,86-x*2,61+y*2);
	//m_pGraph->DrawLine(156,183,155-x*2,182+y*2);
	//gear number
	
	//DrawImage(m_pFrontend->m_pPng[PNG_PANEL],138-m_pData->panelNumberOffsets[m_gear[0]+1],183);
	m_pGraph->SetBitmapClip(83,64,8,11);
	m_pGraph->DrawImage(m_pFrontend->m_pNums,83-m_pData->panelNumOffsets[m_gear[0]+1],64);
}

/*===============================================================================
METHOD: InitPanel
=============================================================================== */
void GameFrame::InitPanel()
{
	int	i;

	for(i=0;i<7;i++)
		m_lastFace[i]=-1;

	m_pGraph->SetColor(236,27,45);
	m_pGraph->SetFillColor(236,27,45);
	m_pGraph->FillRect(0,0,m_canvasW,36);
	m_pGraph->SetColor(242,96,108);
	m_pGraph->DrawLine(0,34,m_canvasW,34);
	m_pGraph->DrawLine(0,32,m_canvasW,32);
	m_pGraph->SetColor(246,145,154);
	m_pGraph->DrawLine(0,33,m_canvasW,33);

	//mph
	/*m_pGraph->SetBitmapClip(80,25,11,5);
	DrawImage(m_pFrontend->m_pPng[PNG_PANEL],21,18);
    
	m_pGraph->SetBitmapClip(5,24,45,8);
	DrawImage(m_pFrontend->m_pPng[PNG_PANEL],5,18);
	m_pGraph->SetBitmapClip(120,23,65,8);
	DrawImage(m_pFrontend->m_pPng[PNG_PANEL],48,18);*/

//	DrawLapNum();
}
/*===============================================================================
METHOD: InitPlayer
=============================================================================== */
void GameFrame::InitPlayer()
{
	m_bDoingPowerSlide = FALSE;
	m_lean = 0;
	m_drag = 0;
	m_revs = 0;
	m_bestLapTime = (99 * 60 * 1000) + (59 * 1000);
	m_bCrashing = FALSE;
	m_bWobbledLastTime = FALSE;
	RecalcTopSpeed();
}

/*===============================================================================
METHOD: ControlPlayer
=============================================================================== */
void GameFrame::ControlPlayer()
{
	if(m_bRace_over)
	{
		// Reset pose of the biker
		m_bDoingPowerSlide = FALSE;
		m_lean = 0;

		m_speed[0] -= m_speed[0] >> 4;
		if(m_speed[0] < 0x40000)
			m_speed[0] = 0;
		m_zPos[0] += m_speed[0] >> 16;
	}
	else	//Still Racing
	{
		if(m_bCrashing)
		{
			m_speed[0] -= m_speed[0] >> 4;
			if(m_speed[0] < 0x40000)
				m_speed[0] = 0;
		}
		else	//Running Smooth
		{
			if(((m_debouncePad & PAD_UP) != 0) && m_gear[0] < 5)	//Shift gear up
			{
				m_gear[0]++;
				if(m_speed[0] >= m_gearSpeeds[0][m_gear[0]])
					m_revs = 0x10000;
				else
					m_revs = m_speed[0] / (m_gearSpeeds[0][m_gear[0]] >> 16);
			}
			else if(((m_debouncePad & PAD_DOWN) != 0) && m_gear[0] > 0)	// Shift gear down
			{
				m_gear[0]--;
			}

			if((m_padData & PAD_LEFT) != 0)		//Turning Left
			{
				m_lean += (-MAX_LEAN - m_lean) >> 2;	//LEAN_ACCEL;

				if(m_powerSlideCount < 0)
				{
					if((m_debouncePad & PAD_LEFT) != 0)
					{
						if(m_lean < -(MAX_LEAN - pSlide) && m_speed[0] > m_gearSpeeds[0][3])
						{
							if(!m_bDoingPowerSlide)
							{
								m_bDoingPowerSlide = TRUE;
								m_powerSlideStart = m_currentMillisecs;
							}
						}
					}
				}
				else
				{
					m_bWobbledLastTime = FALSE;
					m_bDoingPowerSlide = FALSE;
				}

				m_powerSlideCount = -POWERSLIDE_TIME;
			}
			else if((m_padData & PAD_RIGHT) != 0)	//Turning Right
			{
				m_lean += (MAX_LEAN - m_lean) >> 2;

				if(m_powerSlideCount > 0)
				{
					if((m_debouncePad & PAD_RIGHT) != 0)
					{
						if(m_lean > MAX_LEAN - pSlide && m_speed[0] > m_gearSpeeds[0][3])
						{
							if(!m_bDoingPowerSlide)
							{
								m_bDoingPowerSlide = TRUE;
								m_powerSlideStart = m_currentMillisecs;
							}
						}
					}
				}
				else
				{
					m_bWobbledLastTime = FALSE;
					m_bDoingPowerSlide  =FALSE;
				}

				m_powerSlideCount = POWERSLIDE_TIME;
			}
			else        //Not turning, dampen lean
			{
				int temp = ABS(m_lean);
				if(temp < 0x800)
					m_lean = 0;
				else
					m_lean += (0 - m_lean) >> 2;	

				if(m_powerSlideCount > 0)
					m_powerSlideCount--;
				else if(m_powerSlideCount < 0)
					m_powerSlideCount++;

				m_bDoingPowerSlide = FALSE;
			}//end if((m_padData & PAD_LEFT) != 0)	
			
			m_xPos[0] += (m_lean - (m_drag / (m_topSpeed + m_handling))) << 2;
			if(m_bDoingPowerSlide)
				m_xPos[0] += m_lean >> 1;

			Collision();

			if(((m_isCliff & 2) == 2) && ((m_xPos[0] >> 16) > 86))		//edge of cliff?
				Crash(86 << 16);
			else if(((m_isCliff &1 ) == 1) && ((m_xPos[0] >> 16) < -86))		//edge of cliff?
				Crash(-86 << 16);
			else if(m_xPos[0] >> 16 < -128)
				Crash(-128 << 16);
			else if(m_xPos[0] >> 16 > 128)
				Crash(128 << 16);
			else
			{
				int diff = m_gearSpeeds[0][m_gear[0]] - m_speed[0];

				if(diff < 0)	//decelerate
				{
					m_speed[0] += diff >> 4;
					m_revs = 0x10000;
				}
				else
				{
					int acc = 40 - m_acceleration;
					int	g = m_gear[0] - 1;

					acc += m_gear[0] * 2;

					acc >>= 2;

					while(g >= 0 && m_gearSpeeds[0][g] - m_speed[0] > 0x100000)
					{