rpsgamescreens.cpp

roids60 game symbian os application development

		{ // Multiplayer mode code here
		TRoshambo::TElement element(TRoshambo::ENone);
		switch (aSelected)
			{
			case(RPS::ERock):
				element = TRoshambo::ERock;
				break;
			case (RPS::EPaper):
				element = TRoshambo::EPaper;
				break;
			case (RPS::EScissors):
				element = TRoshambo::EScissors;
				break;
					
			default:
				ASSERT(EFalse);
			}
		iGameScreenMgr.BluetoothManager().SendData(element);
		}
	}

// -------------------------------------------------------------
// About Screen
// -------------------------------------------------------------
CGameScreen* CAboutScreen::NewL(CGameScreenManager& aScreenMgr)
	{
	CAboutScreen* me = new (ELeave) CAboutScreen(aScreenMgr);
	CleanupStack::PushL(me);
	me->ConstructL();
	CleanupStack::Pop(me);
	return (static_cast<CGameScreen*>(me));
	}

CAboutScreen::CAboutScreen(CGameScreenManager& aScreenMgr)
: CMenuScreen(aScreenMgr)
{}

void CAboutScreen::ConstructL()
	{
	_LIT(KBack, "Back");
	
	TGameScreenItem* item = new (ELeave) TGameScreenItem(RPS::EReturnToMainScreen, KBack);
	item->iX = KRPSScreensHAlignment;
	item->iY = 8*gScreenHeight/9;
	item->iHighlighted = ETrue;
	iItems.AddFirst(*item);
	iIterator.SetToFirst();	
	}

// Handles item selection (in this case, returns to the main menu)
void CAboutScreen::DoProcessInput(RPS::TMenuOption aSelected)
	{
	switch (aSelected)
		{
		case(RPS::EReturnToMainScreen):
			iGameScreenMgr.SetGameState(CGameScreenManager::EMainScreen);
			break;
		default:
			ASSERT(EFalse);
		}
	}

void CAboutScreen::DrawGameScreen()
	{
	CWindowGc& gc = CCoeEnv::Static()->SystemGc();
	gc.SetPenStyle(CGraphicsContext::ENullPen);	
	gc.UseFont(CCoeEnv::Static()->NormalFont());
	gc.SetPenColor(KRgbGray);
	
	_LIT(KVersion, "Rock ");
	_LIT(KCreatedBy, "Paper");
	_LIT(KMS, "Scissor ");
	_LIT(KJCS, " Game");
	_LIT(KWithThanks, " (RPS)");
	_LIT(KSymsource, ".");
	
	TBuf<KMaxRpsTextElement> versionText(KVersion);
	versionText.Append(KRPSVersionString());
	
	gc.DrawText(versionText, TPoint(KRPSScreensHAlignment, gScreenHeight/9)); 
   	gc.DrawText(KCreatedBy, TPoint(KRPSScreensHAlignment, 2*gScreenHeight/9));    
   	gc.DrawText(KMS, TPoint(KRPSScreensHAlignment, gScreenHeight/3));   	
   	gc.DrawText(KJCS, TPoint(KRPSScreensHAlignment, 4*gScreenHeight/9)); 
   	gc.DrawText(KWithThanks, TPoint(KRPSScreensHAlignment, 5*gScreenHeight/9)); 
   	gc.DrawText(KSymsource, TPoint(KRPSScreensHAlignment, 2*gScreenHeight/3)); 
	
   	CMenuScreen::DrawGameScreen();
	}

// -----------------------------------------------------------------------------		
// Pause Screen	
// -----------------------------------------------------------------------------		
	
CGameScreen* CPauseScreen::NewL(CGameScreenManager& aScreenMgr)
	{
	CPauseScreen* me = new (ELeave) CPauseScreen(aScreenMgr);
	CleanupStack::PushL(me);
	me->ConstructL();
	CleanupStack::Pop(me);
	return (static_cast<CGameScreen*>(me));
	}

void CPauseScreen::DrawGameScreen()
	{
	ASSERT(iBmp);
	CWindowGc& gc = CCoeEnv::Static()->SystemGc();
	gc.BitBlt(iPos, iBmp);
	}

void CPauseScreen::ProcessInput(TUint& aKeyState)
	{
	if (aKeyState & KKey5)
		{// The '5' key has been pressed, return to the main screen
		iGameScreenMgr.SetGameState(CGameScreenManager::EMainScreen);
		aKeyState &= ~KKey5; // Clear the input now it's been handled
		}
	}

void CPauseScreen::DeActivate()
	{
	if (iGameScreenMgr.PlayMode()==CGameScreenManager::ETwoPlayerShortlink)
		iGameScreenMgr.BluetoothManager().QuitMultiplayerGame();
	
	iGameScreenMgr.GameEngine().UnpauseGame();
	}

CPauseScreen::CPauseScreen(CGameScreenManager& aScreenMgr)
: CGameScreen(aScreenMgr)
	{}

CPauseScreen::~CPauseScreen()
	{
	delete iBmp;
	}

void CPauseScreen::ConstructL()
	{
	_LIT(KRpsBmps, "\\resource\\apps\\rps_0xA00054BC.mbm");
	CEikonEnv* eikonEnv = CEikonEnv::Static();
	iBmp = eikonEnv->CreateBitmapL(KRpsBmps, EMbmRps_0xa00054bcPausemenu);
	
	TSize size = iBmp->SizeInPixels();
	TInt width = size.iWidth;
	TInt height = size.iHeight;
	iPos = TPoint(0,0);
	if (gScreenWidth > width)
		iPos.iX = (gScreenWidth - width)/2;
		
	if (gScreenHeight > height)
		iPos.iY = (gScreenHeight - height)/2;
	}

// -----------------------------------------------------------------------------		
// Splash Screen	
// -----------------------------------------------------------------------------		
	
CGameScreen* CSplashScreen::NewL(CGameScreenManager& aScreenMgr)
	{
	CSplashScreen* me = new (ELeave) CSplashScreen(aScreenMgr);
	CleanupStack::PushL(me);
	me->ConstructL();
	CleanupStack::Pop(me);
	return (static_cast<CGameScreen*>(me));
	}

void CSplashScreen::DrawGameScreen()
	{
	// Game ticks at between 20 and 30 fps
	// Display splash screen for 150 ticks (approx 6 seconds)
	const TInt KSplashTimeout = 150;
	
	if (++iSplashCounter<KSplashTimeout)
		{
		ASSERT(iBmp);
		CWindowGc& gc = CCoeEnv::Static()->SystemGc();
		gc.BitBlt(iPos, iBmp);
		}
	else
		{
		iGameScreenMgr.SetGameState(CGameScreenManager::EMainScreen);
		}
	}

CSplashScreen::CSplashScreen(CGameScreenManager& aScreenMgr)
: CGameScreen(aScreenMgr)
	{}

CSplashScreen::~CSplashScreen()
	{
	delete iBmp;
	}

void CSplashScreen::ConstructL()
	{
	_LIT(KRpsBmps, "\\resource\\apps\\rps_0xA00054BC.mbm");
	CEikonEnv* eikonEnv = CEikonEnv::Static();
	iBmp = eikonEnv->CreateBitmapL(KRpsBmps, EMbmRps_0xa00054bcSplashscreen);
	
	TSize size = iBmp->SizeInPixels();
	TInt width = size.iWidth;
	TInt height = size.iHeight;
	iPos = TPoint(0,0);
	if (gScreenWidth > width)
		iPos.iX = (gScreenWidth - width)/2;
	else
		iPos.iX =(width = gScreenWidth)/2;
		
	if (gScreenHeight > height)
		iPos.iY = (gScreenHeight - height)/2;
	else
		iPos.iY = (height - gScreenHeight)/2;
	}

CResultScreen* CResultScreen::NewL(CGameScreenManager& aScreenMgr)
	{
	CResultScreen* me = new (ELeave) CResultScreen(aScreenMgr);
	return (me);
	}

// -----------------------------------------------------------------------------		
// Results Screen	
// -----------------------------------------------------------------------------		
void CResultScreen::DrawGameScreen()
	{
	CWindowGc& gc = CCoeEnv::Static()->SystemGc();
	gc.SetPenStyle(CGraphicsContext::ENullPen);	
	gc.UseFont(CCoeEnv::Static()->NormalFont());
	gc.SetPenColor(KRgbGray);
	
	TRoshambo roshambo = iGameScreenMgr.Roshambo();
	_LIT(KChoiceText, "You: ");
	_LIT(KNoChoice, " Nothing");
	
	TBuf<KMaxRpsTextElement> choiceText(KChoiceText);
	
	if (roshambo.LocalPlayer()==TRoshambo::ERock)
		{
		choiceText.Append(KRock());
		}
	else if (roshambo.LocalPlayer()==TRoshambo::EPaper)
		{
		choiceText.Append(KPaper());
		}
	else if (roshambo.LocalPlayer()==TRoshambo::EScissors)
		{
		choiceText.Append(KScissors());
		}
	else 
		{
		ASSERT(roshambo.LocalPlayer()==TRoshambo::ENone);
		choiceText.Append(KNoChoice());
		}

   	gc.DrawText(choiceText, TPoint(KRPSScreensHAlignment, gScreenHeight/6));    
   	
   	_LIT(KGameOppChoice, "Opponent: ");
   	TBuf<KMaxRpsTextElement> oppChoiceText(KGameOppChoice);
	
	if (roshambo.Opponent()==TRoshambo::ERock)
		{
		oppChoiceText.Append(KRock());
		}
	else if (roshambo.Opponent()==TRoshambo::EPaper)
		{
		oppChoiceText.Append(KPaper());
		}
	else if (roshambo.Opponent()==TRoshambo::EScissors)
		{
		oppChoiceText.Append(KScissors());
		}
	else 
		{
		ASSERT(roshambo.Opponent()==TRoshambo::ENone);
		oppChoiceText.Append(KNoChoice());
		}
	
   	gc.DrawText(oppChoiceText, TPoint(KRPSScreensHAlignment, gScreenHeight/3));    
   	
   	TRoshambo::TResult result = roshambo.CalculateResult();
   	
   	_LIT(KGameResult, "You ");
   	TBuf<KMaxRpsTextElement> resultText(KGameResult);
   	
   	if (result==TRoshambo::EWin)
   		{
   		_LIT(KWin, "Win!");
   		resultText.Append(KWin);
   		}
   	else if (result==TRoshambo::ELose)
   		{
   		_LIT(KLose, "Lose!");
   		resultText.Append(KLose);
   		}
   	else if (result==TRoshambo::EDraw)
   		{
   		_LIT(KDraw, "Drew!");
   		resultText.Append(KDraw);
   		}
   	else
   		{
   		ASSERT(result==TRoshambo::ENoContest);
   		_LIT(KAbandoned, "Game was abandoned");
   		resultText = KAbandoned();
   		}
   	
	//Draw the rps result
	gc.DrawText(resultText, TPoint(KRPSScreensHAlignment, gScreenHeight/2)); 
   	
   	_LIT(KPressKey, "Again? Press center key");
   	gc.DrawText(KPressKey, TPoint(KRPSScreensHAlignment, 2*gScreenHeight/3));
   	
   	_LIT(KPressQuit, "Quit? Press 5");
   	gc.DrawText(KPressQuit, TPoint(KRPSScreensHAlignment, 5*gScreenHeight/6));	
	}

void CResultScreen::ProcessInput(TUint& aKeyState)
	{
	if (aKeyState & KControllerCentre)
		{// The center  key has been pressed, return to the play screen
		if(iGameScreenMgr.PlayMode()==CGameScreenManager::ESinglePlayer)
			{			
			iGameScreenMgr.SetGameState(CGameScreenManager::EPlayScreen);
			}
		else
			{			
			iGameScreenMgr.BluetoothManager().ReplayGame();
			}
		aKeyState &= ~KControllerCentre; // Clear the input now it's been handled
		}
	else if (aKeyState & KKey5)
		{// The '5' key has been pressed to quit, return to the main screen
		iGameScreenMgr.SetGameState(CGameScreenManager::EMainScreen);
		iGameScreenMgr.BluetoothManager().QuitMultiplayerGame();
		aKeyState &= ~KKey5; // Clear the input now it's been handled
		}
	}


CResultScreen::CResultScreen(CGameScreenManager& aScreenMgr)
: CGameScreen(aScreenMgr)	
{}

// -----------------------------------
// CNotifierScreen 
// -----------------------------------

CNotifierScreen* CNotifierScreen::NewL(CGameScreenManager& aGameScreenMgr)
	{
	CNotifierScreen* me = new (ELeave) CNotifierScreen(aGameScreenMgr);
	return (me);
	}

CNotifierScreen::CNotifierScreen(CGameScreenManager& aGameScreenMgr)
:CGameScreen(aGameScreenMgr){}

CNotifierScreen::~CNotifierScreen()
{}

// This is a dummy screen that doesn't re-draw - thus allowing a notifier to be visible
void CNotifierScreen::DrawGameScreen()
	{
	
	}