rpsgamescreens.cpp

roids60 game symbian os application development

// Copyright (c) Symbian Ltd 2008. All rights reserved.

// INCLUDE FILES
#include <eikenv.h>
#include <coemain.h>
#include <rps_0xA00054BC.mbg>
#include "common.hrh" 
#include "rps.hrh"
#include "rpsGameScreens.h" 
#include "rpsPlayTimer.h"
#include "rpsgameengine.h"
#include "bluetoothmanager.h"

_LIT(KRPSVersionString, "1.0");

_LIT(KRock, "Rock");
_LIT(KPaper, "Paper");
_LIT(KScissors, "Scissors");

//----------------------------------------------------
CGameScreenManager* CGameScreenManager::NewL(CRpsGameEngine& aEngine)
	{
	CGameScreenManager* me = new (ELeave) CGameScreenManager(aEngine);
	CleanupStack::PushL(me);
	me->ConstructL();
	CleanupStack::Pop(me);
	return (me);
	}
CGameScreen::CGameScreen(CGameScreenManager& aGameScreenMgr)
:	iGameScreenMgr(aGameScreenMgr)
	{}

CGameScreen::~CGameScreen()
{}

//----------------------------------------------------

CGameScreenManager::CGameScreenManager(CRpsGameEngine& aEngine)
: iGameState(ESplashScreen), iPlayMode(ESinglePlayer), iEngine(aEngine)
{}

void CGameScreenManager::ConstructL()
	{
	iGameScreens[ESplashScreen] = CSplashScreen::NewL(*this);	
	iGameScreens[EMainScreen] = CMainScreen::NewL(*this);	
	iGameScreens[EPausedScreen] = CPauseScreen::NewL(*this);
	iGameScreens[EPlayScreen] = CPlayScreen::NewL(*this);
	iGameScreens[EWaitOpponentScreen] = CWaitOpponentScreen::NewL(*this);
	iGameScreens[EResultScreen] = CResultScreen::NewL(*this);
	iGameScreens[EControlScreen] = CControlScreen::NewL(*this);
	iGameScreens[ENotifierScreen] = CNotifierScreen::NewL(*this);
	iGameScreens[EConnectingScreen] = CConnectingScreen::NewL(*this);
	iGameScreens[EStartScreen] = CStartScreen::NewL(*this);
	iGameScreens[EWaitStartScreen] = CWaitStartScreen::NewL(*this);
	iGameScreens[EWaitConnScreen] = CWaitConnScreen::NewL(*this);
	iGameScreens[EErrorScreen] = CErrorScreen::NewL(*this);	
	iGameScreens[EAboutScreen] = CAboutScreen::NewL(*this);
	
	// Bluetooth manager
	iBTManager = CBluetoothManager::NewL(*this);
	}

CGameScreenManager::~CGameScreenManager()
	{
	for (TInt index = 0; index < EGameScreensTotal;  index++)
		delete iGameScreens[index];
	
	delete iBTManager;
	}

void CGameScreenManager::SetGameState(TGameState aNewGameState)
	{
	CGameScreen* currentScreen = iGameScreens[iGameState];
	ASSERT(currentScreen);
	currentScreen->DeActivate(); // Processing required before screen is deactivated
	
	iGameState = aNewGameState;
	CGameScreen* newScreen = iGameScreens[iGameState];
	ASSERT(newScreen);
	newScreen->PreActivate(); // Processing required before screen is displayed
	}
// -------------------------------------------------------------------------------

TGameScreenItem::TGameScreenItem(RPS::TMenuOption aOption, const TDesC& aText)	
: iOption(aOption), iHighlighted(EFalse), iX(0), iY(0), iText(aText)
{}

// -------------------------------------------------------------------------------

CMenuScreen::CMenuScreen(CGameScreenManager& aGameScreenMgr)
: 	CGameScreen(aGameScreenMgr),
	iItems(_FOFF(TGameScreenItem, iDlink)),
	iIterator(iItems)
		{
		}	

CMenuScreen::~CMenuScreen()
	{
	TGameScreenItem* anyItem;
	iIterator.SetToFirst();
	while ((anyItem = iIterator++) != NULL)
	    {
	    anyItem->iDlink.Deque();
	    delete anyItem;
	    };
	}
	
void CMenuScreen::DrawGameScreen()
	{
	CWindowGc& gc = CCoeEnv::Static()->SystemGc();
	gc.SetPenStyle(CGraphicsContext::ENullPen);	
	gc.UseFont(CCoeEnv::Static()->NormalFont());
	gc.SetPenColor(KRgbGray);
	
	TGameScreenItem* item=NULL;
	iIterator.SetToFirst();
	while((item = iIterator++) != NULL)
        {
        if (item->iHighlighted)
        	{
        	gc.SetPenColor(KRgbRed);
        	gc.DrawText(item->iText, TPoint(item->iX, item->iY));
        	gc.SetPenColor(KRgbGray);
        	}
        else	
        	gc.DrawText(item->iText, TPoint(item->iX, item->iY));        
        };     
	}


void CMenuScreen::ProcessInput(TUint& aKeyState)
	{
	iIterator.SetToFirst();
	TGameScreenItem* item=iIterator;
	
	while(item!= NULL)
        {
        if (!item->iHighlighted)
        	{
        	iIterator++; // No pre-increment operator is available
        	item = iIterator;
        	}
        else // Found the currently highlighted item
        	{ 
        	if (aKeyState & KControllerUp)
        		{// The up key was pressed
        		if (iItems.IsFirst(iIterator)) // At the first in the list 
        			iIterator.SetToLast(); // Roll around
        		else
        			iIterator--; // No pre-decrement operator is available
        		
        		TGameScreenItem* previous = iIterator;
        		ASSERT(previous);
        		if(previous != item)//only one item in the double list?
	        		{	        			
	        		previous->iHighlighted = ETrue;
	        		item->iHighlighted = EFalse;
	        		}
	        		
        		aKeyState &= ~KControllerUp; // Clear the input now it's been handled
        		}
        	else if (aKeyState & KControllerDown)
        		{// The down key was pressed
        		if (iItems.IsLast(iIterator)) // At the end of the list
        			iIterator.SetToFirst(); // Roll around to the first
        		else
        			iIterator++; // No preincrement operator is available
        		
        		TGameScreenItem* next = iIterator;
        		ASSERT(next);
        		if(next != item)//only one item in the double list?
	        		{
	        		next->iHighlighted = ETrue;
	        		item->iHighlighted = EFalse;
	        		}
	        			
        		aKeyState &= ~KControllerDown;  // Clear the input now it's been handled
        		} 
        	else if (aKeyState & KControllerCentre)
        		{
        		DoProcessInput(item->iOption);
        		aKeyState &= ~KControllerCentre;
        		}        	
        	break; // Input has been handled or is not relevant to this screen
        	}
        } 	
	}

// ---------------------------------

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

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

void CMainScreen::ConstructL()
	{
	_LIT(KSingle, "Single Player");
	_LIT(KTwo, "Two Players");
	_LIT(KAbout, "About");
	
	TGameScreenItem* item = new (ELeave) TGameScreenItem(RPS::ESinglePlayer, KSingle);
	item->iX = KRPSScreensHAlignment;
	item->iY = gScreenHeight/3;
	item->iHighlighted = ETrue;
	iItems.AddFirst(*item);
	iIterator.SetToFirst();
	
	item = new (ELeave) TGameScreenItem(RPS::ETwoPlayers, KTwo);
	item->iX = KRPSScreensHAlignment;
	item->iY = gScreenHeight/2;
	TGameScreenItem* current = iIterator;
	ASSERT(current);
	item->iDlink.Enque(&current->iDlink);
	iIterator.Set(*item);

	item = new (ELeave) TGameScreenItem(RPS::EAbout, KAbout);
	item->iX = KRPSScreensHAlignment;
	item->iY = 2*gScreenHeight/3;
	current = iIterator;
	ASSERT(current);
	item->iDlink.Enque(&current->iDlink);
	}

// Handles item selection according to menu
// Here, the next appropriate screen is displayed
void CMainScreen::DoProcessInput(RPS::TMenuOption aSelected)
	{
	switch (aSelected)
		{
		case(RPS::ESinglePlayer):
			iGameScreenMgr.SetPlayMode(CGameScreenManager::ESinglePlayer);
			iGameScreenMgr.SetGameState(CGameScreenManager::EPlayScreen);
			break;
		case (RPS::ETwoPlayers):
			iGameScreenMgr.SetPlayMode(CGameScreenManager::ETwoPlayerShortlink); 
			iGameScreenMgr.SetGameState(CGameScreenManager::EControlScreen);
			break;
		case (RPS::EAbout):
			iGameScreenMgr.SetGameState(CGameScreenManager::EAboutScreen);
			break;
		default:
			ASSERT(EFalse);
		}
	}

// ------------------------------------------------
//Play menu

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

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

CPlayScreen::~CPlayScreen()
	{
	delete iPlayTimer;
	}

void CPlayScreen::ConstructL()
	{
	iPlayTimer = CPlayTimer::NewL(10000000, *this); // 10 second timeout
	
	TGameScreenItem* item = new (ELeave) TGameScreenItem(RPS::ERock, KRock);
	item->iX = KRPSScreensHAlignment;
	item->iY = gScreenHeight/4;
	item->iHighlighted = ETrue;
	iItems.AddFirst(*item);
	iIterator.SetToFirst();
	
	item = new (ELeave) TGameScreenItem(RPS::EPaper, KPaper);
	item->iX = KRPSScreensHAlignment;
	item->iY = gScreenHeight/2;
	TGameScreenItem* current = iIterator;
	ASSERT(current);
	item->iDlink.Enque(&current->iDlink);
	iIterator.Set(*item);
	
	item = new (ELeave) TGameScreenItem(RPS::EScissors, KScissors);
	item->iX = KRPSScreensHAlignment;
	item->iY = 3*gScreenHeight/4;
	current = iIterator;
	ASSERT(current);
	item->iDlink.Enque(&current->iDlink);
	}

void CPlayScreen::PreActivate()
	{
	iGameScreenMgr.Roshambo().ResetPlayers();
	iPlayTimer->Start();
	}

void CPlayScreen::DeActivate()
	{
	// Cancel the play timer
	iPlayTimer->Cancel();
	
	// If the game is moving to pause because of inactivity, make sure to  
    // send a response to the opponent in a multiplayer game (no selection)
	if (iGameScreenMgr.GameData().iRpsError == KErrTimedOut)
		{
		if (iGameScreenMgr.PlayMode()==CGameScreenManager::ETwoPlayerShortlink)
			{
			iGameScreenMgr.BluetoothManager().SendData(TRoshambo::ENone);
			}
		iGameScreenMgr.GameData().iRpsError = KErrNone;
		}
	}

// The play timer went off - the user didn't take a move within the time limit
void CPlayScreen::PlayTimeout()
	{
	if(iGameScreenMgr.PlayMode()==CGameScreenManager::ESinglePlayer)
		{			
		iGameScreenMgr.Roshambo().SinglePlayerGame(TRoshambo::ENone);
		iGameScreenMgr.SetGameState(CGameScreenManager::EResultScreen);
		}
	else
		{
		ASSERT(iGameScreenMgr.PlayMode()==CGameScreenManager::ETwoPlayerShortlink);
		iGameScreenMgr.BluetoothManager().SendData(TRoshambo::ENone);	
		}
	}

// Handles item selection according to menu
// Here, the next appropriate screen is displayed
void CPlayScreen::DoProcessInput(RPS::TMenuOption aSelected)
	{
	if (iGameScreenMgr.PlayMode()==CGameScreenManager::ESinglePlayer)
		{
		switch (aSelected)
			{
			case(RPS::ERock):
				iGameScreenMgr.Roshambo().SinglePlayerGame(TRoshambo::ERock);
				break;
			case (RPS::EPaper):
				iGameScreenMgr.Roshambo().SinglePlayerGame(TRoshambo::EPaper);
				break;
			case (RPS::EScissors):
				iGameScreenMgr.Roshambo().SinglePlayerGame(TRoshambo::EScissors);
				break;
					
			default:
				ASSERT(EFalse);
			}
		iGameScreenMgr.SetGameState(CGameScreenManager::EResultScreen);
		}
	else