---

CGameFramework.cpp

Go to the documentation of this file.

// Copyright 2002 Kenneth Guy,
// 
// You are free to take the source and do as you wish with it.
// However it would be nice if you let me know if the code was useful
// to you and give me an acknowledgement if you use a significant portion
// of the code in an application.
// 
// CGameFramework.cpp

//

#include <e32std.h>
#include "CGameFramework.h"
#include "CGame.h"
#include "TGamePanics.h"


CGameFramework* CGameFramework::NewL(){
  CGameFramework* self= new (ELeave) CGameFramework;
  return(self);
};

CGameFramework::~CGameFramework() {
  delete iLevel;
  delete iMap;
};

void CGameFramework::CancelL() {
  iData.iKeys |= TGameData::EQuit;
  RunL(EFalse);
}

TInt CGameFramework::GameThread(TAny* aGameData) {
  // create a cleanup stack
  CTrapCleanup* cleanup=CTrapCleanup::New();  
  if(cleanup==NULL)
    return KErrNoMemory;

  TInt error=KErrNone;

  TGameData& data= (*STATIC_CAST(TGameData*,aGameData));

  // look while we have lives, haven't got to the end of the level,
  // 'Q' hasn't been pressed, and haven't got an error creating the game.
  while(data.iLives!=0 && !(data.iKeys & TGameData::EQuit) &&
        data.iLevelCompleted==EFalse && error==KErrNone) {    
    // create a game and call play on it.
    CGame *game=NULL;
    TRAPD(error,game=CGame::NewL(data));
    if(error==KErrNone) {
      game->Play();
      delete game;
    }
  }
  delete cleanup;
  return error;
};

TInt CGameFramework::Score() {
  return(iData.iScore);
}


CGameFramework::TGameState CGameFramework::RunL(TBool aReset) {  
  // assert that LoadLevelL has been called and succeded in
  // loading a level
  __ASSERT_ALWAYS(iLevel!=NULL && iMap!=NULL,TGamePanics::Panic(TGamePanics::ENoLevelLoaded));

  // if this is a new game reset the score and lives
  if(aReset!=EFalse) {
    iData.iLives=3;
    iData.iScore=0;
  }

  // connect to the window server.
  RWsSession winSession;
  User::LeaveIfError(winSession.Connect());
  CleanupClosePushL(winSession);
  
  // these can be whatever we like, as long as they are unique,
  // as we have only one window and one windowgroup we don't
  // actually use them.
  const TUint32 KWindowHandle=1;
  const TUint32  KWindowGroupHandle=2;

  // create a window group so we can create a window
  RWindowGroup winGroup(winSession);
  User::LeaveIfError(winGroup.Construct(KWindowGroupHandle));
  CleanupClosePushL(winGroup);
  
  // create a blank window, blank windows can't be drawn on,
  // however as the game code writes directly to the screen this
  // isn't a problem.
  RBlankWindow window(winSession);
  User::LeaveIfError(window.Construct(winGroup,KWindowHandle));
  CleanupClosePushL(window);
  window.Activate();
  window.SetSize(TSize(640,200));
  // request focus events so we can pause the game thread when
  // we move to the background, this stops us writing over some other
  // apps screen.
  window.EnableFocusChangeEvents();

  // first time in we want want to redraw everything,
  iData.iForceRedraw=ETrue;

  // logon to the thread so we get informed when it exits.
  iGameThread.Logon(iGameStatus);
  iGameThread.Resume();

  // play the game
  TBool finished=Play(winSession);

  // cancel any outstanding request for key strokes/focus changes etc
  winSession.EventReadyCancel();
  // and watching the state of the thread
  iGameThread.LogonCancel(iGameStatus);

  // I think this is the EventReady completing.
  User::WaitForAnyRequest();

  // remove our window
  CleanupStack::PopAndDestroy(3,&winSession); //winGroup, window
  

  if(finished==EFalse) {
    // this is the thread notifying that it has suspended
    User::WaitForAnyRequest();
    // we have just paused the thread/game
    return EPaused;
  } else {
    // game finished, so close the thread, and delete the level
    iGameThread.Close();
    delete iLevel;
    iLevel=NULL;
    delete iMap;
    iMap=NULL;

    User::Heap().Compress();

    // did the player complete the level or die
    if(iData.iLevelCompleted==EFalse) {
      return EDied;
    } else {
      return ELevelCompleted;
    }
  }    
};


TBool CGameFramework::Play(RWsSession &aWindSession) {
  TRequestStatus normalEvent;

  // listen for key strokes/focus changes etc.
  aWindSession.EventReady(&normalEvent);

  for(;;) {
    User::WaitForAnyRequest();
    if(normalEvent!=KRequestPending) {
      TWsEvent event;
      aWindSession.GetEvent(event);
      aWindSession.EventReady(&normalEvent);        
      switch(event.Type()) {
      case EEventKeyDown: {
        TKeyEvent *key=event.Key();
        switch(key->iScanCode) {            
        case EStdKeyLeftArrow:   iData.iKeys |= TGameData::ELeft;    break;
        case EStdKeyRightArrow:  iData.iKeys |= TGameData::ERight;   break;
        case EStdKeyUpArrow:     iData.iKeys |= TGameData::EUp;      break;
        case EStdKeyDownArrow:   iData.iKeys |= TGameData::EDown;    break;
        case 'Q':                iData.iKeys |= TGameData::EQuit;    break;
        case 'A':                iData.iKeys |= TGameData::EAction1; break;
        case EStdKeySpace:       iData.iKeys |= TGameData::EAction2; break;
        case EStdKeyLeftShift:   iData.iKeys |= TGameData::EAction3; break;
        case EStdKeyEnter:       iData.iKeys |= TGameData::EAction4; break;
        case 'P': {
          iGameThread.Suspend();
          return EFalse;
        }
        }
      }
      break;
      case EEventKeyUp: {
        TKeyEvent *key=event.Key();
        switch(key->iScanCode) {            
        case EStdKeyLeftArrow:   iData.iKeys &= ~TGameData::ELeft;    break;
        case EStdKeyRightArrow:  iData.iKeys &= ~TGameData::ERight;   break;
        case EStdKeyUpArrow:     iData.iKeys &= ~TGameData::EUp;      break;
        case EStdKeyDownArrow:   iData.iKeys &= ~TGameData::EDown;    break;
        case 'A':                iData.iKeys &= ~TGameData::EAction1; break;
        case EStdKeySpace:       iData.iKeys &= ~TGameData::EAction2; break;
        case EStdKeyLeftShift:   iData.iKeys &= ~TGameData::EAction3; break;
        case EStdKeyEnter:       iData.iKeys &= ~TGameData::EAction4; break;
        }
      }        
      break;   
      case EEventFocusLost:
        // pause game if we go into the background
        iGameThread.Suspend();
        return EFalse;
        break;
      }
    } else if(iGameStatus!=KRequestPending) {
      // thread ended
      return ETrue;
    } else { 
      // event meant for active scheduler if there is one
      // I don't think it should never get here
      CActiveScheduler *sched=CActiveScheduler::Current();
      if(sched!=NULL) {
        TInt error;
        sched->RunIfReady(error,0);
      }
    }
  }
}

void CGameFramework::LoadLevelL(const TDesC& aLevelName,const TDesC& aMapName, TBool aResetShip) {
  __ASSERT_ALWAYS(iLevel==NULL && iMap==NULL,TGamePanics::Panic(TGamePanics::ELoadLevelWithLevelLoaded));
  
  RFs fs;
  User::LeaveIfError(fs.Connect());  
  CleanupClosePushL(fs);


  // load level file
  RFile levelFile;
  User::LeaveIfError(levelFile.Open(fs,aLevelName,EFileRead));  
  CleanupClosePushL(levelFile);                    

  TInt size;
  User::LeaveIfError(levelFile.Size(size));
  size-=16; //skip uids on front of file
  HBufC8 *levelDes= HBufC8::NewLC(size);
  TPtr8 levelPtr=levelDes->Des();
  User::LeaveIfError(levelFile.Read(16,levelPtr,size));


  // load map file
  RFile mapFile;
  User::LeaveIfError(mapFile.Open(fs,aMapName,EFileRead));
  CleanupClosePushL(mapFile);

  User::LeaveIfError(mapFile.Size(size));
  size-=16; //skip uids on front of file
  HBufC8 *mapDes= HBufC8::NewLC(size);
  TPtr8 mapPtr=mapDes->Des();
  User::LeaveIfError(mapFile.Read(16,mapPtr,size));




  // create a thread within which to run the game,
  _LIT(KGameThread,"RealGame");
  // 4k stack,
  const TInt KStackSize=4*1024;
  
  // create but don't resume as the iData isn't set up yet.
  User::LeaveIfError(iGameThread.Create(KGameThread,GameThread,KStackSize,NULL,&iData));
  // as we want to respond to key presses the game thread
  // has a lower priority than getting events
  iGameThread.SetPriority(EPriorityLess);
  



  
  CleanupStack::Pop(mapDes);
  iMap=mapDes;
  CleanupStack::PopAndDestroy(&mapFile);
  CleanupStack::Pop(levelDes);
  iLevel=levelDes;
  CleanupStack::PopAndDestroy(2,&fs); // levelFile


  // setup level data
  TInt32* level= (TInt32*) (iLevel->Ptr());
  TInt32* map= (TInt32*) (iMap->Ptr());
  
  iData.iKeys=0;
  iData.iLevelCompleted=EFalse;

  iData.iLevel.iMapData=(TInt16*) (iMap->Ptr()+map[0]);
  iData.iLevel.iPaths=(TInt16*) (iMap->Ptr()+map[1]);

  iData.iLevel.iBackgrounds=(TUint16*) (iLevel->Ptr()+level[0]);
  iData.iLevel.iSprites=(TUint16*) (iLevel->Ptr()+level[1]);
  iData.iLevel.iStatus=(TUint16*) (iLevel->Ptr()+level[2]);

  iData.iLevel.iShipSprite=(TInt16) map[2];
  iData.iLevel.iShipDeathStartSprite=(TInt16) map[3];
  iData.iLevel.iShipDeathEndSprite=(TInt16) map[4];
  iData.iLevel.iBadGuyDeathStartSprite=(TInt16) map[5];
  iData.iLevel.iBadGuyDeathEndSprite=(TInt16) map[6];
  iData.iLevel.iBulletPower1_StartSprite=(TInt16) map[7];
  iData.iLevel.iBulletPower2_StartSprite=(TInt16) map[8];
  iData.iLevel.iBulletPower3_StartSprite=(TInt16) map[9];
  iData.iLevel.iBulletPower4_StartSprite=(TInt16) map[10];
  iData.iLevel.iShipStartXPos=(TInt16) map[11];
  iData.iLevel.iShipStartYPos=(TInt16) map[12];
  iData.iLevel.iShipStartHealth=(TInt16) map[13];
  if(aResetShip!=EFalse) {
    iData.iLevel.iShipPowerups=(TInt16) map[14];
  }
}

---