void CS60TestEngine::ConstructL()
{
  CTimer::ConstructL();
  CActiveScheduler::Add(this);
  After(iInterval);
  iState=ERunning;
}

void CS60TestEngine::KeyLeft()
{
  iDoc->MoveBlock(iDoc->iBlockPos-TPoint(1, 0));
}

void CS60TestEngine::KeyRight()
{
  iDoc->MoveBlock(iDoc->iBlockPos+TPoint(1, 0));
}

void CS60TestEngine::KeyDrop()
{
  while (iDoc->MoveBlock(iDoc->iBlockPos+TPoint(0, 1)))
    ;
}

void CS60TestEngine::KeyRotate(int dir)
{
  iDoc->RotateBlock(dir);
}

void CS60TestEngine::Reset()
{
  if (iState==ERunning)
    Cancel();
  iState=ERunning;
  After(iInterval);
}

void CS60TestEngine::RunL()
{
  if (!iDoc->MoveBlock(iDoc->iBlockPos+TPoint(0, 1)))
  {
    if (!iDoc->FixBlock())
    {
      // Game over
      TBuf<64> message;
      CEikonEnv::Static()->ReadResource(message, R_NOTE_GAME_OVER);
      CAknInformationNote *informationNote=new(ELeave) CAknInformationNote;
      informationNote->ExecuteLD(message);
      iState=EGameOver;
      return;
    }
    iDoc->CheckRows();

    if (iDoc->iLevel<=(iDoc->iLines/10))
    {
      iInterval*=3;
      iInterval/=4;
      iDoc->iLevel++;
    }

    iDoc->NewBlock();
  }
  iBeginTime.HomeTime();
  After(iInterval);
}

#ifndef __S60TEST_DOCUMENT_H__
#define __S60TEST_DOCUMENT_H__
#include <akndoc.h>
#include "grid.h"
#include "block.h"
// Forward references
class CEikAppUi;
class CEikApplication;
class CS60TestAppUi;
class CS60TestDocument : public CAknDocument
{
public:
  static CS60TestDocument* NewL(CEikApplication& aApp);
  static CS60TestDocument* NewLC(CEikApplication& aApp);
  ~CS60TestDocument();
  void GetRowContent(int nr, TFixedArray<TInt8, KGridX> &row) const;
  int CheckRows();
  void NewBlock();
  void Reset();
  bool IsBlock(const TPoint &p) const;
  bool MoveBlock(const TPoint &p);
  bool RotateBlock(int dir);
  bool FixBlock();

  TGrid iGrid;
  TBlock iCurrBlock;
  TPoint iBlockPos;
  TInt32 iScore;
  TInt16 iLines;
  TInt16 iLevel;
  CS60TestAppUi *iAppUi;
  TInt64 seed;
public: // from CAknDocument
  CEikAppUi* CreateAppUiL();
private:
  void ConstructL();
  CS60TestDocument(CEikApplication& aApp);
};
#endif
#include "S60TestAppUi.h"
#include "S60TestDocument.h"
// Standard Symbian OS construction sequence
CS60TestDocument *CS60TestDocument::NewL(CEikApplication& aApp)
{
  CS60TestDocument *self=NewLC(aApp);
  CleanupStack::Pop(self);
  return self;
}

CS60TestDocument *CS60TestDocument::NewLC(CEikApplication& aApp)
{
  CS60TestDocument *self=new(ELeave) CS60TestDocument(aApp);
  CleanupStack::PushL(self);
  self->ConstructL();
  return self;
}

void CS60TestDocument::ConstructL()
{
  TTime time;
  time.HomeTime();
  seed=time.Int64();
  Reset();
}

CS60TestDocument::CS60TestDocument(CEikApplication& aApp)
:CAknDocument(aApp),
 iGrid(),
 iCurrBlock(),
 iBlockPos(3, -4)
{
}

CS60TestDocument::~CS60TestDocument()
{
}

void CS60TestDocument::Reset()
{
  iGrid.Clear();
  iBlockPos=TPoint(3, -4);
  iScore=0;
  iLines=0;
  iLevel=1;
  iCurrBlock=TBlock::RandomBlock(seed);
}

void CS60TestDocument::NewBlock()
{
  iCurrBlock=TBlock::RandomBlock(seed);
  iBlockPos=TPoint(3, -4);
}

bool CS60TestDocument::MoveBlock(const TPoint &p)
{
  if (iGrid.DoesCollide(iCurrBlock, p)) return false;
  iBlockPos=p;
  iAppUi->UpdateBoard();
  return true;
}

bool CS60TestDocument::FixBlock()
{
  int i;
  // check if it is outside the board
  for (i=0; i<-iBlockPos.iY; i++)
    if (iCurrBlock.RowMask(i))
      return false;

  iGrid.PutBlock(iCurrBlock, iBlockPos);
  return true;
}

int CS60TestDocument::CheckRows()
{
  int offset=0, i, j;
  for (i=KGridY-1; i>=0; i--)
  {
    if (iGrid.iMask[i]==0xffffU)
    {
      offset++;
      iScore++;
      iLines++;
      continue;
    }

    if (offset>0)
    {
      iGrid.iMask[i+offset]=iGrid.iMask[i];
      for (j=0; j<KGridX; j++)
        iGrid.iContent[i+offset][j]=iGrid.iContent[i][j];
    }
  }

  for (i=0; i<offset; i++)
  {
    iGrid.iMask[i]=0x003f;
    for (j=0; j<KGridX; j++)
      iGrid.iContent[i][j]=0;
  }

  if (offset>0) iAppUi->UpdateBoard();
  return offset;
}

bool CS60TestDocument::RotateBlock(int dir)
{
  iCurrBlock.Rotate(dir);
  if (iGrid.DoesCollide(iCurrBlock, iBlockPos))
  {
    iCurrBlock.Rotate(-dir);
    return false;
  }
  iAppUi->UpdateBoard();
  return true;
}

bool CS60TestDocument::IsBlock(const TPoint &p) const
{
  if (p.iX>=iBlockPos.iX && p.iX<iBlockPos.iX+4 &&
      p.iY>=iBlockPos.iY && p.iY<iBlockPos.iY+4)
    return (iCurrBlock.RowMask(p.iY-iBlockPos.iY)&(1<<(3-p.iX+iBlockPos.iX)))>0;
  return false;
}

void CS60TestDocument::GetRowContent(int nr, TFixedArray<TInt8, KGridX> &row) const
{
  int i;
  for (i=0; i<KGridX; i++)
  {
    if (IsBlock(TPoint(i, nr))) row[i]=iCurrBlock.Color();
      else row[i]=iGrid.iContent[nr][i];
  }
}

CEikAppUi *CS60TestDocument::CreateAppUiL()
{
  // Create the application user interface, and return a pointer to it,
  // the framework takes ownership of this object
  iAppUi=new(ELeave) CS60TestAppUi(this);
  return iAppUi;
}
#ifndef __S60TEST_APPVIEW_H__
#define __S60TEST_APPVIEW_H__
#include <coecntrl.h>
class CS60TestDocument;
class CS60TestEngine;
class CS60TestAppView : public CCoeControl
{
public:
  static CS60TestAppView* NewL(const TRect& aRect, CS60TestDocument *aDoc, CS60TestEngine *aEngine);
  static CS60TestAppView* NewLC(const TRect& aRect, CS60TestDocument *aDoc, CS60TestEngine *aEngine);
  ~CS60TestAppView();

  static const TUint32 KColors[10];

public:  // from CCoeControl
  void Draw(const TRect& aRect) const;

private:
  void ConstructL(const TRect& aRect);
  CS60TestAppView(CS60TestDocument *aDoc, CS60TestEngine *aEngine);
  CS60TestDocument *iDoc;
  CS60TestEngine *iEngine;
};
#endif

#include <coemain.h>
#include <eikenv.h>
#include "S60TestAppView.h"
#include "S60TestDocument.h"
#include "S60TestEngine.h"
const TUint32 CS60TestAppView::KColors[10]=
  {0xffffff, 0xff0000, 0x00ff00, 0x0000ff, 0xff00ff,
   0xcc00dd, 0xadbeef, 0x000000, 0xffff00, 0xaaaaaa};
CS60TestAppView *CS60TestAppView::NewL(const TRect& aRect, CS60TestDocument *aDoc, CS60TestEngine *aEngine)
{
  CS60TestAppView *self=CS60TestAppView::NewLC(aRect, aDoc, aEngine);
  CleanupStack::Pop(self);
  return self;
}

CS60TestAppView* CS60TestAppView::NewLC(const TRect& aRect, CS60TestDocument *aDoc, CS60TestEngine *aEngine)
{
  CS60TestAppView *self=new(ELeave) CS60TestAppView(aDoc, aEngine);
  CleanupStack::PushL(self);
  self->ConstructL(aRect);
  return self;
}

CS60TestAppView::CS60TestAppView(CS60TestDocument *aDoc, CS60TestEngine *aEngine)
{
  iDoc=aDoc;
  iEngine=aEngine;
}

CS60TestAppView::~CS60TestAppView()
{
}

void CS60TestAppView::ConstructL(const TRect& aRect)
{
  CreateWindowL();
  SetRect(aRect);
  ActivateL();
}

const int KCellSize=7;
const int KBoardOffset=2;

void CS60TestAppView::Draw(const TRect& /*aRect*/) const
{
  CWindowGc &gc=SystemGc();
  TRect rect=Rect();
  gc.Clear(rect);

  int i, j;
  TFixedArray<TInt8, KGridX> arr;
  gc.SetPenColor(TRgb(0));
  gc.SetBrushStyle(CWindowGc::ESolidBrush);

  for (i=0; i<=KGridY; i++)
    gc.DrawLine(TPoint(KBoardOffset, KBoardOffset+KCellSize*i),
                TPoint(KBoardOffset+KGridX*KCellSize, KBoardOffset+KCellSize*i));

  for (i=0; i<=KGridX; i++)
    gc.DrawLine(TPoint(KBoardOffset+KCellSize*i, KBoardOffset),
                TPoint(KBoardOffset+KCellSize*i, KBoardOffset+KGridY*KCellSize));

  for (i=0; i<KGridY; i++)
  {
    iDoc->GetRowContent(i, arr);
    for (j=0; j<KGridX; j++)
    {
      gc.SetBrushColor(KColors[arr[j]]);
      if (arr[j])
        gc.DrawRect(TRect(KBoardOffset+KCellSize*j, KBoardOffset+KCellSize*i,
              KBoardOffset+KCellSize*(j+1)+1, KBoardOffset+KCellSize*(i+1)+1));
    }
  }
}

#ifndef __S60TEST_APPUI_H__
#define __S60TEST_APPUI_H__
#include <aknappui.h>
#include "s60testengine.h"
class CS60TestDocument;
// Forward reference
class CS60TestAppView;

class CS60TestAppUi : public CAknAppUi
{
public:
  void ConstructL();
  CS60TestAppUi(CS60TestDocument *aDoc);
  ~CS60TestAppUi();
  void UpdateBoard();

public: // from CAknAppUi
  void HandleCommandL(TInt aCommand);
  TKeyResponse HandleKeyEventL(const TKeyEvent& /*aKeyEvent*/,
    TEventCode /*aType*/);

private:
  CS60TestEngine *iEngine;
  CS60TestAppView *iAppView;
  CS60TestDocument *iDoc;
};
#endif
#include <coemain.h>
#include <eikenv.h>

#include "S60TestAppView.h"
#include "S60TestDocument.h"
#include "S60TestEngine.h"

const TUint32 CS60TestAppView::KColors[10]=
  {0xffffff, 0xff0000, 0x00ff00, 0x0000ff, 0xff00ff,
   0xcc00dd, 0xadbeef, 0x000000, 0xffff00, 0xaaaaaa};

CS60TestAppView *CS60TestAppView::NewL(const TRect& aRect, CS60TestDocument *aDoc, CS60TestEngine *aEngine)
{
  CS60TestAppView *self=CS60TestAppView::NewLC(aRect, aDoc, aEngine);
  CleanupStack::Pop(self);
  return self;
}

CS60TestAppView* CS60TestAppView::NewLC(const TRect& aRect, CS60TestDocument *aDoc, CS60TestEngine *aEngine)
{
  CS60TestAppView *self=new(ELeave) CS60TestAppView(aDoc, aEngine);
  CleanupStack::PushL(self);
  self->ConstructL(aRect);
  return self;
}

CS60TestAppView::CS60TestAppView(CS60TestDocument *aDoc, CS60TestEngine *aEngine)
{
  iDoc=aDoc;
  iEngine=aEngine;
}

CS60TestAppView::~CS60TestAppView()
{
}

void CS60TestAppView::ConstructL(const TRect& aRect)
{
  CreateWindowL();
  SetRect(aRect);
  ActivateL();
}

const int KCellSize=7;
const int KBoardOffset=2;

void CS60TestAppView::Draw(const TRect& /*aRect*/) const
{
  CWindowGc &gc=SystemGc();
  TRect rect=Rect();
  gc.Clear(rect);

  int i, j;
  TFixedArray<TInt8, KGridX> arr;
  gc.SetPenColor(TRgb(0));
  gc.SetBrushStyle(CWindowGc::ESolidBrush);

  for (i=0; i<=KGridY; i++)
    gc.DrawLine(TPoint(KBoardOffset, KBoardOffset+KCellSize*i),
                TPoint(KBoardOffset+KGridX*KCellSize, KBoardOffset+KCellSize*i));

  for (i=0; i<=KGridX; i++)
    gc.DrawLine(TPoint(KBoardOffset+KCellSize*i, KBoardOffset),
                TPoint(KBoardOffset+KCellSize*i, KBoardOffset+KGridY*KCellSize));

  for (i=0; i<KGridY; i++)
  {
    iDoc->GetRowContent(i, arr);
    for (j=0; j<KGridX; j++)
    {
      gc.SetBrushColor(KColors[arr[j]]);
      if (arr[j])
        gc.DrawRect(TRect(KBoardOffset+KCellSize*j, KBoardOffset+KCellSize*i,
              KBoardOffset+KCellSize*(j+1)+1, KBoardOffset+KCellSize*(i+1)+1));
    }
  }
}

#ifndef __S60TEST_APPLICATION_H__
#define __S60TEST_APPLICATION_H__
#include <aknapp.h>
class CS60TestApplication : public CAknApplication
{
public:  // from CAknApplication
  TUid AppDllUid() const;
protected: // from CAknApplication
  CApaDocument* CreateDocumentL();
};#endif // __S60TEST_APPLICATION_H__

#include "S60TestDocument.h"
#include "S60TestApplication.h"

// UID for the application, this should correspond to the uid defined in the mmp file
static const TUid KUidS60TestApp = {0x04545FF4};

CApaDocument* CS60TestApplication::CreateDocumentL()
{ 
  CApaDocument* document = CS60TestDocument::NewL(*this);
  return document;
}

TUid CS60TestApplication::AppDllUid() const
{
  return KUidS60TestApp;
}


#ifndef __S60TEST_HRH__
#define __S60TEST_HRH__

#include "S60TestApplication.h"

// DLL entry point, return that everything is ok
GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
{
  return KErrNone;
}
// Create an application, and return a pointer to it
EXPORT_C CApaApplication* NewApplication()
{
  return (new CS60TestApplication);
} 

enum TS60TestIds
{
  ES60TestNewGame = 1,  // start value must not be 0
  ES60TestPause
};#endif

文件.pan

#ifndef __S60TEST_PAN__
#define __S60TEST_PAN__

enum TS60TestPanics
{
  ES60TestBasicUi = 1,
  ES60TestAssert = 2
  // add further panics here
};

inline void Panic(TS60TestPanics aReason)
{
  _LIT(applicationName, "S60Test");
  User::Panic(applicationName, aReason);
}

#endif