frontend.cpp

一个在brew 平台下开发的摩托车程序源代码

//	m_pSplashPNG = NULL;
	m_pVi2LPNG = NULL;
//	m_pEsrbPNG = NULL;

//	if (m_tinyFontBMP)
//	{
//		IIMAGE_Release(m_tinyFontBMP);
//		m_tinyFontBMP = NULL;
//		m_pGraph->deleteTinyFont();
//	}

	for (i=0; i<5; i++)
	{
		if (m_BikeImg[i])
		{	
			delete m_BikeImg[i];
			m_BikeImg[i] = NULL;
		}
	}

}

///////////////////////////////////////////////////////////////////////////////////////////////////
/*===============================================================================
METHOD: ProcessFE
=============================================================================== */
int Frontend::ProcessFE()
{
	int doneFE=0;

	ProcessTheirScreens();

	if(m_currentScreen==STATUS_STARTGAME)
		doneFE=1;
	else if(m_currentScreen==STATUS_INTRO && m_currentIntroScreen==8)
		doneFE=-1;
	return doneFE;
}

/*===============================================================================
METHOD: InitFE
=============================================================================== */
void Frontend::InitFE()
{

	m_fontSmallBold = AEE_FONT_BOLD;
	m_fontSmall = AEE_FONT_NORMAL;


	//m_tinyFontBMP = ISHELL_LoadResImage(m_pIShell, DUCATI_RES_FILE, BM_TINY_FONT);
//	if (m_tinyFontBMP) m_pGraph->initTinyFont(m_tinyFontBMP);
	m_pGraph->SetMaxFontHeight(m_canvasH/8);
	m_menuHeight=m_pGraph->GetFontHeight(m_fontSmallBold) + 5;
	m_champStage=-1;
	m_myBettor=-1;

	m_backdropShadowTop=m_pGraph->GetFontHeight(m_fontSmallBold) + 4;

	m_backdropShadowTop--;

	m_backdropShadowBottom=m_canvasH-m_backdropShadowTop;
	m_backdropShadowHeight=m_backdropShadowBottom-m_backdropShadowTop;
	m_backdropShadowCentre=m_backdropShadowTop+(m_backdropShadowHeight>>1);

	isNoFile=false;
	isNoFile=!ReadRecords();
	SetCurrentScreen(STATUS_INTRO,0);
}



#define SAVE_FILE		"ducati.sav"
/*===============================================================================
METHOD: OpenSaveFile
=============================================================================== */
boolean Frontend::OpenSaveFile(boolean bForWrite)
{
	if(m_pDataFile != NULL)
		return FALSE;	

	if(m_pFileMgr != NULL)
	{	
		// create mode should only be used in
		// the emulator to help create our data file.
		m_pDataFile = IFILEMGR_OpenFile(m_pFileMgr, SAVE_FILE, (bForWrite ? _OFM_READWRITE : _OFM_READ) );
		if(m_pDataFile == NULL && bForWrite)
		{
			m_pDataFile = IFILEMGR_OpenFile(m_pFileMgr, SAVE_FILE, _OFM_CREATE );
		}
	
	}

	return (m_pDataFile != NULL);
}
/*===============================================================================
METHOD: CloseSaveFile
=============================================================================== */
void Frontend::CloseSaveFile()
{
	if(m_pDataFile != NULL)
		IFILE_Release(m_pDataFile);

	m_pDataFile = NULL;

}
/*===============================================================================
METHOD: DeleteSaveFile
=============================================================================== */
void Frontend::DeleteSaveFile()
{
  ResetRecords();
	WriteRecords();

	m_myWorth=m_pData->bikePrices[m_currentBike];
	m_pGame->m_topSpeed=m_pData->engineData[m_currentBike][m_partsOwned[3]][0];
	m_myWorth+=m_pData->engineData[m_currentBike][m_partsOwned[3]][1];
	m_pGame->m_handling=m_pData->engineData[m_currentBike][m_partsOwned[3]][2];
	m_pGame->m_acceleration=m_pData->engineData[m_currentBike][m_partsOwned[3]][3];
	for(int i=0;i<3;i++)
	{
		m_pGame->m_topSpeed+=m_pData->partsData[i][m_partsOwned[i]][1];
		m_myWorth+=m_pData->partsData[i][m_partsOwned[i]][0];
	}
	m_pGame->m_handling+=m_pData->partsData[1][m_partsOwned[1]][3];
	m_pGame->m_acceleration+=m_pData->partsData[2][m_partsOwned[2]][3];
	m_pGame->m_maxSpeed=m_pGame->m_topSpeed;
	m_pGame->RecalcTopSpeed();

}
/*===============================================================================
METHOD: ReadRecords
=============================================================================== */
void Frontend::ResetRecords() 
{
	m_myCash=100;
//	m_bSoundFlag = TRUE;
	m_bPrevSoundOption = m_bSoundFlag;
	m_pSoundPlayer->setSoundStatus(m_bSoundFlag);
	m_difficultyLevel = 0;
	m_myCharacter=-1;
	m_currentBike=0;
	m_curcol = 0;		
	m_champStage=-1;
	
	int i;
	for(i=0;i<NUM_PARTS;i++)
	{
		m_partsOwned[i]=0;
		m_pGame->m_partsWear[i]=0;
	}
	for(i=0;i<NUM_TRACKS;i++)
	{
		m_recordLaps[i]=0;
		m_recordTimes[i]=0;
	}
	for(i=0;i<NUM_BIKES;i++)
	{
		m_pGame->m_score[i]=0;
		m_pGame->m_speed[i]=0;
	}
}
bool Frontend::ReadRecords()
{
	bool ret=true;
	
	if(OpenSaveFile(FALSE))
	{

		IFILE_Read(m_pDataFile, &m_myCash, sizeof(m_myCash));
		IFILE_Read(m_pDataFile, &m_bSoundFlag, sizeof(m_bSoundFlag));
		IFILE_Read(m_pDataFile, &m_difficultyLevel, sizeof(m_difficultyLevel));
		IFILE_Read(m_pDataFile, &m_myCharacter, sizeof(m_myCharacter));
		IFILE_Read(m_pDataFile, &m_currentBike, sizeof(m_currentBike));
		IFILE_Read(m_pDataFile, &m_curcol, sizeof(m_curcol));

		int i;
		for(i=0;i<NUM_PARTS;i++)
		{
			IFILE_Read(m_pDataFile, &m_partsOwned[i], sizeof(m_partsOwned[i]));
			IFILE_Read(m_pDataFile, &m_pGame->m_partsWear[i], sizeof(m_pGame->m_partsWear[i]));
		}
		for(i=0;i<NUM_TRACKS;i++)
		{
			IFILE_Read(m_pDataFile, &m_recordLaps[i], sizeof(m_recordLaps[i]));
			IFILE_Read(m_pDataFile, &m_recordTimes[i], sizeof(m_recordTimes[i]));
		}
		for(i=0;i<NUM_BIKES;i++)
		{
			IFILE_Read(m_pDataFile, &m_pGame->m_score[i], sizeof(m_pGame->m_score[i]));
			IFILE_Read(m_pDataFile, &m_pGame->m_speed[i], sizeof(m_pGame->m_speed[i]));
		}

		int n=IFILE_Read(m_pDataFile, &m_champStage, sizeof(m_champStage));
    CloseSaveFile();

		if (n<sizeof(m_champStage)) {
			ResetRecords();
			ret=WriteRecords(0);
		}
		else {
			//failsafe for dodgy save
			if(m_champStage>=NUM_TRACKS)
				m_champStage=-1;

			m_bPrevSoundOption = m_bSoundFlag;
			m_pSoundPlayer->setSoundStatus(m_bSoundFlag);
			m_pGame->GenCPUCharacters(m_myCharacter);
		}
	}
	else { //No saved file, or something went wrong
		ResetRecords();
		ret=WriteRecords(0);
	}

	m_myWorth=m_pData->bikePrices[m_currentBike];
	m_pGame->m_topSpeed=m_pData->engineData[m_currentBike][m_partsOwned[3]][0];
	m_myWorth+=m_pData->engineData[m_currentBike][m_partsOwned[3]][1];
	m_pGame->m_handling=m_pData->engineData[m_currentBike][m_partsOwned[3]][2];
	m_pGame->m_acceleration=m_pData->engineData[m_currentBike][m_partsOwned[3]][3];
	for(int i=0;i<3;i++)
	{
		m_pGame->m_topSpeed+=m_pData->partsData[i][m_partsOwned[i]][1];
		m_myWorth+=m_pData->partsData[i][m_partsOwned[i]][0];
	}
	m_pGame->m_handling+=m_pData->partsData[1][m_partsOwned[1]][3];
	m_pGame->m_acceleration+=m_pData->partsData[2][m_partsOwned[2]][3];
	m_pGame->m_maxSpeed=m_pGame->m_topSpeed;
	m_pGame->RecalcTopSpeed();
 
	return ret;
}
/*===============================================================================
METHOD: WriteRecords
=============================================================================== */

bool Frontend::WriteRecords(bool showMessage)
{
	//!!!!Do it here for now, possibly forever :0)
	m_pGame->CalcGearSpeeds(0);

  if(showMessage && isNoFile) return false;
	if(OpenSaveFile(TRUE))
	{
		if (showMessage) {
			// displaying message here
			m_pGraph->SetFont(m_fontSmall);
			m_pGraph->SetScreenClip(0,0,m_canvasW,m_canvasH);
			m_pGraph->SetBitmapClip(0,0,m_canvasW,m_canvasH);
			//int w=m_pGraph->GetTextWidth(m_pData->stringSaving3)+8;
			int w=m_pGraph->GetTextWidth(m_pData->stringSaving2)+16;
			int	fh=m_pGraph->GetFontHeight() +2;
			int h=fh*2+12;
			int x=(m_canvasW-w)/2;
			int y=(m_canvasH-h)/2;
			m_pGraph->SetFillColor(0);
			m_pGraph->FillRect(x,y,w,h);
			m_pGraph->SetColor(WHITE);
			m_pGraph->DrawRect(x,y,w,h);
			m_pGraph->SetTextColor(WHITE);
			m_pGraph->DrawString(m_pData->stringSaving1,m_halfScreenWidth,y+4,topcentre);
			m_pGraph->DrawString(m_pData->stringSaving2,m_halfScreenWidth,y+fh+6,topcentre);
			m_pGraph->DrawString(m_pData->stringSaving3,m_halfScreenWidth,y+fh*2+8,topcentre);
			IDISPLAY_UpdateEx(m_pIDisplay,FALSE);
		}

    unsigned char Data[256]; int ptr=0;
		StoreData(Data, &ptr, &m_myCash, sizeof(m_myCash));
		StoreData(Data, &ptr, &m_bSoundFlag, sizeof(m_bSoundFlag));
		StoreData(Data, &ptr, &m_difficultyLevel, sizeof(m_difficultyLevel));
		StoreData(Data, &ptr, &m_myCharacter, sizeof(m_myCharacter));
		StoreData(Data, &ptr, &m_currentBike, sizeof(m_currentBike));
		StoreData(Data, &ptr, &m_curcol, sizeof(m_curcol));

		int i;
		for(i=0;i<NUM_PARTS;i++)
		{
			StoreData(Data, &ptr, &m_partsOwned[i], sizeof(m_partsOwned[i]));
			StoreData(Data, &ptr, &m_pGame->m_partsWear[i], sizeof(m_pGame->m_partsWear[i]));
		}
		for(i=0;i<NUM_TRACKS;i++)
		{
			StoreData(Data, &ptr, &m_recordLaps[i], sizeof(m_recordLaps[i]));
			StoreData(Data, &ptr, &m_recordTimes[i], sizeof(m_recordTimes[i]));
		}
		for(i=0;i<NUM_BIKES;i++)
		{
			StoreData(Data, &ptr, &m_pGame->m_score[i], sizeof(m_pGame->m_score[i]));
			StoreData(Data, &ptr, &m_pGame->m_speed[i], sizeof(m_pGame->m_speed[i]));
		}
		StoreData(Data, &ptr, &m_champStage, sizeof(m_champStage));

		int ret = IFILE_Write(m_pDataFile, Data, ptr);

 		CloseSaveFile();
		return (ret < ptr) ? false : true;
	}
	else return false;
}


/*===============================================================================
METHOD: SetText
=============================================================================== */
void Frontend::SetText(JString st, int allowedwidth, JString** paragraph, int* counter)
{
	//return NULL;
	//YingZ: because of the clumsy way C++ handles arrays, we have to use
	//pointers and MALLOC to emulate it's behavior. It's a bit finicky as the
	//text block we MALLOC here will be used and refrenced to else where
	//so make SURE to delete and free the memory block AFTER it's being used.
	int index;
	int textCounter;

	JString tmpStr;

	int blockIndex = 0;

	if((index=st.indexOf("~",0))>= 0)
	{
		if(index==0)
		{
			SetText(st.substring(1,st.length()-1),allowedwidth,paragraph,&textCounter);		
			*counter = textCounter;
			return;

		}
		else if(index==(int)st.length()-1)
		{
			//last character
			st=st.substring(0,st.length()-1);
		}
		else
		{
			int t1Counter;
			int t2Counter;

			JString**	t1=( JString** )( MALLOC( sizeof( JString* ) * MAX_STRING ) );;
			JString**	t2=( JString** )( MALLOC( sizeof( JString* ) * MAX_STRING ) );;

			int i;
			for (i = 0; i < MAX_STRING; i++)
			{
				t1[i] = NULL;
				t2[i] = NULL;
			}


			SetText(st.substring(0,index),allowedwidth,t1,&t1Counter);
			SetText(st.substring(index+1),allowedwidth,t2,&t2Counter);

			if(t1Counter + t2Counter >= MAX_STRING)
			{
				assert(0);
				DBGPRINTF("combined string exceeds MAX_STRING");
			}

			for (i = 0; i < t1Counter; i++)
				paragraph[i] = t1[i];

			for (i = t1Counter; i < (t1Counter + t2Counter); i++)
				paragraph[i] = t2[i-t1Counter];

			*counter = t1Counter + t2Counter;
			t1Counter = 0;
			t2Counter = 0;

			FREE(t1);
			FREE(t2);

			return;

		}
	}

///////////////////////////////////////////////////////////////////////////////////
	if(m_pGraph->GetTextWidth(st)<allowedwidth)
	{
		paragraph[0]=new JString(st);
		*counter = 1;
		return;
	}
	st+=" ";

	//YingZ: No Vector (storage class) in C++, have to allocate a JString array with a fixed size
	//with enough number of elements for possible situations, and use an index and a warning if we run out slots.
	int lastindex=0;

	while((index=st.indexOf(" ",lastindex+1))>0)
	{
		if(blockIndex >= MAX_STRING)
		{
			assert(0);
			DBGPRINTF("Not enough strings allocated for splitting text, increase MAX_STRING");