* Map accessor
* @return the map
*/
const CSkiMap& CSkiEngine::Map() const
    {
    return *iMap;
    }

/**
* skier accessor
* @return the skier
*/
CSkier& CSkiEngine::Skier()
    {
    return *iSkier;
    }

/**
* skier accessor
* @return the map gallery
*/
const CSkier& CSkiEngine::Skier() const
    {
    return *iSkier;
    }

/**
* Map gallery accessor
* @return the map gallery
*/
CMapGallery& CSkiEngine::MapGallery()
    {
    return *iMapGallery;
    }

/**
* Map gallery accessor
* @return the map gallery
*/
const CMapGallery& CSkiEngine::MapGallery() const
    {
    return *iMapGallery;
    }

/**
* Screen attributes acessor
* @return the screen attributes
*/
TSkiScreenAttribs& CSkiEngine::ScreenAttribs()
    {
    return iScrAttribs;
    }

/**
* Screen attributes acessor
* @return the screen attributes
*/
const TSkiScreenAttribs& CSkiEngine::ScreenAttribs() const
    {
    return iScrAttribs;
    }

/**
* Key handler accessor
* @return the key handler
*/
TKeyHandler& CSkiEngine::KeyHandler()
    {
    return iKeyHandler;
    }

/**
* Key handler accessor
* @return the key handler
*/
const TKeyHandler& CSkiEngine::KeyHandler() const
    {
    return iKeyHandler;
    }

/**
* Scroll driver accessor
* @return the scrll driver
*/
TScrollDriver& CSkiEngine::ScrollDriver()
    {
    return iScrollDriver;
    }

/**
* Scroll driver accessor
* @return the scrll driver
*/
const TScrollDriver& CSkiEngine::ScrollDriver() const
    {
    return iScrollDriver;
    }

//
// SkiBitmapLoader::
//

/**
* Loads a bitmap from an id
* @param aName The filename of the mbm
* @param aId the id of the image wanted for the created bitmap
* @return the newly created bitmap, on ther cleanup stack
*/
CFbsBitmap* SkiBitmapLoader::CreateBitmapLC(const TDesC& aName,TInt aId)
    {
	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();
	CleanupStack::PushL(bitmap);
	User::LeaveIfError(bitmap->Load(aName, aId));
	return bitmap;
    }

/**
* Adds the skier sprites to a gallery
* @param aGallery the gallery to add the skier sprites to
*/
void SkiBitmapLoader::AddSkierSpritesToGalleryL(CGameGallery& aGallery)
    {
    TFileName filename = KMultiBitmapFilename();
    CompleteWithAppPath(filename);  // don't need to handle error here - the path will be unchanged

    CFbsBitmap* bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesS7);
    CFbsBitmap* mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSm7);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkier0);
    CleanupStack::Pop(2, bitmap);

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesS6);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSm6);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkier30);
    CleanupStack::Pop(2, bitmap);

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesS5);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSm5);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkier60);
    CleanupStack::Pop(2, bitmap);

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesS4);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSm4);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkier90);
    CleanupStack::Pop(2, bitmap);

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesS3);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSm3);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkier120);
    CleanupStack::Pop(2, bitmap);

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesS2);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSm2);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkier150);
    CleanupStack::Pop(2, bitmap);

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesS1);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSm1);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkier180);
    CleanupStack::Pop(2, bitmap);

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSkiercrash);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSkiercrashm);

    aGallery.AddBitmapL(bitmap, mask, TSkierAttribs::ESkierFall);
    CleanupStack::Pop(2, bitmap);
    }

/**
* Adds the map sprites to a gallery
* @param aGallery the gallery to add the map sprites to
*/
void SkiBitmapLoader::AddMapSpritesToGalleryL(CGameGallery& aGallery)
    {
    TFileName filename = KMultiBitmapFilename();
    CompleteWithAppPath(filename);  // don't need to handle error here - the path will be unchanged
    //
    //blue flag

    CFbsBitmap* bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesFlagarrowleft);
    CFbsBitmap* mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesFlagm);

    aGallery.AddBitmapL(bitmap, mask, TMapPrimitive::ELeftFlag);
    CleanupStack::Pop(2, bitmap);

    //
    //red flag

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesFlagarrowright);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesFlagm);

    aGallery.AddBitmapL(bitmap, mask, TMapPrimitive::ERightFlag);
    CleanupStack::Pop(2, bitmap);

    //
    //log

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesLog);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesLogmask);

    aGallery.AddBitmapL(bitmap, mask, TMapPrimitive::ELog);
    CleanupStack::Pop(2, bitmap);

    //
    //tree

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesTree);
    mask = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesTreemask);

    aGallery.AddBitmapL(bitmap, mask, TMapPrimitive::ETree);
    CleanupStack::Pop(2, bitmap);

    //
    //bump

    bitmap = SkiBitmapLoader::CreateBitmapLC(filename,EMbmImagesSnowbump);
    aGallery.AddBitmapL(bitmap, NULL, TMapPrimitive::EBump);
    CleanupStack::Pop(bitmap);
    }

//
// CSkiFrameRenderer::
//

/**
* Standard Symbian 2 phase constructor
* @param aSize The size of the screen
* @param aEngineAttribs the engine attributes
*/
CSkiFrameRenderer* CSkiFrameRenderer::NewL(TSize aSize, CSkiEngine& aEngineAttribs)
    {
    CSkiFrameRenderer* self = NewLC(aSize, aEngineAttribs);
    CleanupStack::Pop(self);
    return self;
    }

/**
* Standard Symbian 2 phase constructor.  The object is left on the cleanup stack
* @param aSize The size of the screen
* @param aEngineAttribs the engine attributes
*/
CSkiFrameRenderer* CSkiFrameRenderer::NewLC(TSize aSize, CSkiEngine& aEngineAttribs)
    {
    CSkiFrameRenderer* self = new (ELeave) CSkiFrameRenderer(aEngineAttribs);
    CleanupStack::PushL(self);
    self->ConstructL(aSize);
    return self;
    }

/**
* Destructor
*/
CSkiFrameRenderer::~CSkiFrameRenderer()
    {
    delete iDBArea;
    }

/**
* Renders a game frame
* @return A bitmap containing a game frame
*/
const CFbsBitmap* CSkiFrameRenderer::RenderedFrameL() const
    {
    iDBArea->ClearBufferedArea();

    CSkiMap* map = iEngineAttribs.Map().IntersectsLC(iScrAttribs.Rect(), iEngineAttribs.MapGallery());

    CMapPrimitiveArray* bumps = map->TypeLC(TMapPrimitive::EBump);
    const TInt bumpCount = bumps->Count();

    for (TInt ii = 0; ii < bumpCount; ii++)
    	{
        DrawPrimitiveL(bumps->At(ii));
		}

    CleanupStack::PopAndDestroy(bumps);

    // Get scenery and find position of skier.  When we get passed the y position of the
    // skier we can draw the skier
    //

    TSkiVector posVect = iEngineAttribs.Skier().Attribs().Posn();
    TPoint skierPosn(static_cast<TInt>(posVect.iX), static_cast<TInt>(posVect.iY));
    TBool skierDrawn = EFalse;

    TInt type = TMapPrimitive::ETree | TMapPrimitive::ELeftFlag | TMapPrimitive::ERightFlag | TMapPrimitive::ELog;
    CMapPrimitiveArray* scenery = map->TypeLC(type);
    const TInt count = scenery->Count();

    for (TInt iii = 0; iii < count; iii++)
        {
        TMapPrimitive primitive = scenery->At(iii);

        // So this doesn't mess up if we have a negative offset..
        //
        TInt primitiveYPos = primitive.Posn().iY;
        TInt skierYPos = skierPosn.iY;

        TBool primitiveInfront = EFalse;

        if ((primitiveYPos < 0 && skierYPos < 0) || (primitiveYPos >= 0 && skierYPos >= 0))
        	{
            primitiveInfront = primitiveYPos > skierYPos;
			}

        else if (primitiveYPos < 0) // && skierYPos >= 0
        	{
            primitiveInfront = EFalse;
			}

        else // if skierYPos <0 && primitiveYPos >= 0
        	{
            primitiveInfront = ETrue;
			}

        if (!skierDrawn &&  primitiveInfront)
            {
            DisplaySkierL();
            skierDrawn = ETrue;
            }

        DrawPrimitiveL(primitive);
        }

    if (!skierDrawn)
    	{
        DisplaySkierL();
		}

    CleanupStack::PopAndDestroy(2, map);

    return &(iDBArea->GetDoubleBufferedAreaBitmap());
    }

/**
* C++ constructor
* @param aEngineAtrbs the engine attributes
*/
CSkiFrameRenderer::CSkiFrameRenderer(CSkiEngine& aEngineAttribs) :
    iEngineAttribs(aEngineAttribs),
    iScrAttribs(aEngineAttribs.ScreenAttribs())
    {
    }


/**
* Standard SymbianOS 2nd phase constructor
* @param aSize The sze of the screen
*/
void CSkiFrameRenderer::ConstructL(TSize aSize)
    {
    iDBArea = CDoubleBufferedArea::NewL(aSize, EColor4K);
    }

/**
* Draw a map primitive to the back buffer
* @param aPrimitive the primitive to draw
*/
void CSkiFrameRenderer::DrawPrimitiveL(const TMapPrimitive& aPrimitive) const
    {
    CMapGallery& gallery = iEngineAttribs.MapGallery();
    CSkiSprite& sprite = gallery.SpriteL(aPrimitive.Type());

    // this obtains the sprite rectangle with absolute (map) coordinates
    TRect absoluteBounds = gallery.RectangleL(aPrimitive);
    // this converts to a screen coordinate
    TPoint scrPosn = absoluteBounds.iTl - iScrAttribs.Offset();

    DrawSpriteL(scrPosn, sprite);
    }

/**
* Draw the skier to the back buffer
*/
void CSkiFrameRenderer::DisplaySkierL() const
    {
    CSkier& skier = iEngineAttribs.Skier();

    TSkiVector posVect = skier.Attribs().Posn();
    TPoint skierPosn(static_cast<TInt>(posVect.iX), static_cast<TInt>(posVect.iY));

    CFbsBitmap& bitmap = skier.SpriteL().Bitmap();

    // GET SKIER SPRITE ON SCREEN
    //
    //
    TSize skierSize = bitmap.SizeInPixels();
    TRect skiRect(skierPosn - iScrAttribs.Offset(), skierSize);
    // map position is bottom centre of object
    skiRect.Move(-skierSize.iWidth / 2, -skierSize.iHeight - skier.Attribs().Elevation());

    TPoint posn = skiRect.iTl;
    CFbsBitGc& gc = iDBArea->GetDoubleBufferedAreaContext();

    if (skier.Jumping())
        {
        //Draw shadow if the skier is jumping
		TPoint shadowPosn = skierPosn - iScrAttribs.Offset();
		shadowPosn.iY -= skierSize.iHeight;
        TRect shadow(shadowPosn, TSize(8,8));

        gc.SetBrushColor(KRgbBlack);
        gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
        gc.DrawEllipse(shadow);
        gc.SetBrushColor(KRgbWhite);
		gc.SetBrushStyle(CGraphicsContext::ENullBrush);

        // put the skier in the "air"
        posn.iY -= skier.Attribs().Elevation();
        }

	gc.BitBltMasked(posn, &(bitmap), bitmap.SizeInPixels(), skier.SpriteL().Mask(), ETrue);

    }


/**
* Draw a sprite to the back buffer
* @param aPosn the screen position to draw to
* @param aSprite the sprite to draw
*/
void CSkiFrameRenderer::DrawSpriteL(TPoint aPosn, const CSkiSprite& aSprite) const
    {
    const CFbsBitmap* mask = aSprite.Mask();
    const CFbsBitmap& bitmap = aSprite.Bitmap();
    CFbsBitGc& gc = iDBArea->GetDoubleBufferedAreaContext();
	gc.Reset();

    if (mask)
    	{
		gc.BitBltMasked(aPosn, &bitmap, bitmap.SizeInPixels(), mask, ETrue);
		}
    else
        {
        CFbsBitmap* copy = new (ELeave) CFbsBitmap;
        CleanupStack::PushL(copy);
        User::LeaveIfError(copy->Duplicate(bitmap.Handle()));
        gc.BitBlt(aPosn, copy);
        CleanupStack::PopAndDestroy(copy);
        }
    }

//
// CSkiGameLoop::
//

/**
* Standard SymbianOS 2-phase constructor
* @param aEngine the game engine
* @param aRenderer the frame rederer
* @aam aDSA direct screen access
*/
CSkiGameLoop* CSkiGameLoop::NewL(CSkiEngine& aEngine, CSkiFrameRenderer& aRenderer, CDSAWrapper& aDSA)
    {
    CSkiGameLoop* self = NewLC(aEngine, aRenderer, aDSA);
    CleanupStack::Pop(self);
    return self;
    }

/**
* Standard SymbianOS 2-phase constructor.  The object is left on the cleanup stack
* @param aEngine the game engine
* @param aRenderer the frame rederer
* @aam aDSA direct screen access
*/
CSkiGameLoop* CSkiGameLoop::NewLC(CSkiEngine& aEngine, CSkiFrameRenderer& aRenderer, CDSAWrapper& aDSA)
    {
    CSkiGameLoop* self = new (ELeave) CSkiGameLoop(aEngine, aRenderer, aDSA);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

/**
* Desructor
*/
CSkiGameLoop::~CSkiGameLoop()
    {
    }

/**
* Kicks off the timer
* @param anInterval the time in miliseconds between timer events
*/
void CSkiGameLoop::Start(TTimeIntervalMicroSeconds32 anInterval)
    {
    Cancel();
    iInterval = anInterval;
    After(iInterval);
    }

/**
* C++ constructor
* @param aEngine the game engine
* @param aRenderer the frame rederer
* @aam aDSA direct screen access
*/
CSkiGameLoop::CSkiGameLoop(CSkiEngine& aEngine, CSkiFrameRenderer& aRenderer, CDSAWrapper& aDSA) :
    CTimer(EPriorityHigh),
    iEngine(aEngine),
    iRenderer(aRenderer),
    iDSA(aDSA),
    iPaused(EFalse)
    {
    }

/**
* From CActive.  Updates the game engine and screen
*/
void CSkiGameLoop::RunL()
    {
    if (!iPaused)
        {
        // instantiates DSA if not already p