Subversion Repositories AndroidProjects

#pragma warning(disable:4244) 

#pragma warning(disable:4018)

#include "Board.h"

#include "GameApp.h"

#include "Res.h"

#include "LevelupEffect.h"

#include "GameOverEffect.h"

#include "OptionsDialog.h"

#include "SexyAppFramework/Graphics.h"

#include "SexyAppFramework/Color.h"

#include "SexyAppFramework/Rect.h"

#include "SexyAppFramework/ButtonWidget.h"

#include "SexyAppFramework/WidgetManager.h"

#include "SexyAppFramework/ImageFont.h"

#include "SexyAppFramework/SoundManager.h"

#include "SexyAppFramework/SoundInstance.h"

#include "SexyAppFramework/Buffer.h"

#include "SexyAppFramework/MusicInterface.h"

#define _USE_MATH_DEFINES

#include <math.h>

// VC6 workaround

#ifndef M_PI

#define M_PI 3.14159265358979323846

#endif

using namespace Sexy;

// How much faster the beam gets when you eat a planet

const float BEAM_INC_SPEED      =       0.05f;

// Fastest the beam can go

const float MAX_BEAM_SPEED      =       2.5f;

// Table of random planet names

const int NUM_PLANET_NAMES      =       28;

const SexyString PLANET_NAME[] =

{_S("Deev-z"), _S("SEN-Hen"), _S("Wallach IX"), _S("Salusa Secundus"), _S("Ridiculous Prime"), _S("Architekt V"),

_S("Robot Republica"), _S("Ix"), _S("XOLDOG4000"), _S("Kliprok"), _S("TR-909"), _S("TR-808"), _S("TB-303"),

_S("DTR011"), _S("dTech"), _S("Rotwang"), _S("Sukhtek"), _S("Romulox"), _S("Dob Reevz"), _S("Skull XII"),

_S("Beefy Prime"), _S("Haas"), _S("Reifenrath"), _S("Gehner Subulon"), _S("ACE-DOGG"), _S("Charolastra"), _S("Nixd"), _S("BASS")};

// Table of random planet exports:

const int NUM_PLANET_EXPORTS =  23;

const SexyString PLANET_EXPORTS[] =

{_S("Happiness"), _S("Donkeys"), _S("Rabies"), _S("AstroPop"), _S("Idiocy"), _S("Minimal Techno"),

_S("Citizens"), _S("Pain-relieving Pants"), _S("The Quad-Laser"), _S("Septic Systems"), _S("Video Games"),

_S("Robots"), _S("Plaid"), _S("Octagons"), _S("Gingivitis"), _S("Recognizers"), _S("Electro"), _S("Sauce"),

_S("Kindness"), _S("Bison"), _S("Saline"), _S("Cholera"), _S("TyperShark")};

//////////////////////////////////////////////////////////////////////////

//      Inline functions

//////////////////////////////////////////////////////////////////////////

// Given an X coordinate, returns the grid column it maps to

inline int GetCol(float x)

{

        return (int) ((x - GRID_START_X) / GRID_PIX_SIZE);

}

// Given a Y coordinate, returns the grid row it maps to

inline int GetRow(float y)

{

        return (int) ((y - GRID_START_Y) / GRID_PIX_SIZE);

}

// Given a grid column, returns the X pixel of the left edge of it

inline float GetColPix(int col)

{

        return col * GRID_PIX_SIZE + GRID_START_X;

}

// Given a grid row, returns the Y pixel of the top edge of it

inline float GetRowPix(int row)

{

        return row * GRID_PIX_SIZE + GRID_START_Y;

}

// Given an X coordinate, adjusts it so that it is aligned

// with the left edge of the grid square it's over

inline float GetAlignedX(float x)

{

        return (float)GetCol(x) * GRID_PIX_SIZE + GRID_START_X;

}

// Given a Y coordinate, adjusts it so that it is aligned

// with the top edge of the grid square it's over

inline float GetAlignedY(float y)

{

        return (float)GetRow(y) * GRID_PIX_SIZE + GRID_START_Y;

}

// Checks to see if the Y coordinate is in the grid's bounds.

// Needs to know if Hun-garr is oriented vertically or not

inline bool YCoordInBounds(float y, bool vertical)

{

        int h = IMAGE_HUNGARR_HORIZ->GetHeight() / 2;

        if ( (vertical && (y > GRID_START_Y + h) && (y < GRID_END_Y - h)) ||

                (!vertical && (y > GRID_START_Y + 7) && (y < GRID_END_Y - 4)) )

                return true;

        return false;

}

// Checks to see if the X coordinate is in the grid's bounds

inline bool XCoordInBounds(float x)

{

        if ((x > GRID_START_X + 9) && (x < GRID_END_X - 2))

                return true;

        return false;

}

// Checks to see if the column number points to a valid grid column

inline bool ValidCol(int col)

{

        return ((col >= 0) && (col < GRID_WIDTH));

}

// Checks to see if the row number points to a valid grid row

inline bool ValidRow(int row)

{

        return ((row >= 0) && (row < GRID_HEIGHT));

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

Board::Board(GameApp* theApp)

{

        mApp = theApp;

        mHungarrIsVertical = true;     

        mLineSpeed = 1.0f;

        mNumPlanetsEaten = 0;

        mPercentComplete = 0;

        mBorderHue = 0;

        mFlashCount = 0;

        mLives = 3;

        mLevel = 1;

        mScore = 0;

        mBeamPulseAmt = 30;

        mBeamPulseVal = 128;

        // Put Hun-garr in a valid spot

        UpdateHungarrPosition(GetColPix(4), GetRowPix(4));

        // Create a 2D array to hold the grid fill state that's of size

        // GRID_WIDTH x GRID_HEIGHT

        mGridState = new GridTile* [GRID_HEIGHT];

        //vc6 workaround:

        int i;

        for (i = 0; i < GRID_HEIGHT; i++)

                mGridState[i] = new GridTile[GRID_WIDTH];

        mFillDirection = FILL_LEFT;

        mFillSpeed = 20.0f;

        mPlanetSpeed = 1.5f;

        mPopulationEaten = mTotalPopulationEaten = 0;

        mPauseLevel = 0;

        // Create our starfield

        for (i = 0; i < MAX_STARS; i++)

        {

                Star s;

                s.mX = Rand() % mApp->mWidth;

                s.mY = Rand() % mApp->mHeight;

                int r = Rand() % 3;

                switch (r)

                {

                        case 0: s.mSpeed = 0.5f; s.mColor = Color(200, 200, 200, 128); break;

                        case 1: s.mSpeed = 0.25f; s.mColor = Color(100, 100, 100, 128); break;

                        case 2: s.mSpeed = 0.1f; s.mColor = Color(50, 50, 50, 128); break;

                }

                mStarField[i] = s;

        }

        mLevelupEffect = new LevelupEffect();

        mGameOverEffect = new GameOverEffect();

        mOptionsBtn = NULL;

        // The shorting out, electrical sound of the beams moving. We use a SoundInstance pointer

        // because we want to loop the sound while the beam is moving, and stop it when done.

        // This is easiest done manually.

        mShortSound = mApp->mSoundManager->GetSoundInstance(SOUND_BEAM_MOVING);

        InitLevel(1);

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

Board::~Board()

{

        // Frees up the memory allocated to our manual SoundInstance pointer. Required.

        mShortSound->Release();

        for (int i = GRID_HEIGHT; i > 0; --i)

                delete[] mGridState[i - 1];

        delete[] mGridState;

        delete mLevelupEffect;

        delete mGameOverEffect;

        delete mOptionsBtn;

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::Update()

{

        // If paused, return and don't markdirty, whcih prevents drawing

        // and the stealing of CPU cycles

        if (mPauseLevel > 0)

                return;

        Widget::Update();

        // HSL is an alternative to specifying an RGB color format.

        // Using HSL lets us easily do the hyper blinking crazy weird

        // flashing effect commonly found in old games, such as Robotron.

        // Below, we increment the value by 6 per update. The &0xFF is an 

        // easy way to clamp the value between 0 and 255 instead of having to

        // do a separate if (mHue > 255) mHue -= 255. This lets the value

        // rollover and keep cycling.

        if (--mFlashCount > 0)

                mBorderHue = (mBorderHue + 6) % 0xFF;  

        if (mGameOverEffect->IsActive())

        {

                mGameOverEffect->Update();

                // If the game over effect is in the proper state, we will

                // be able to initialize the first level so that when it fades out,

                // the level will appear underneath it.

                if (mGameOverEffect->CanInitFirstLevel())

                {

                        //Reset the critical variables:

                        mBorderHue = 0;

                        mFlashCount = 0;

                        mLives = 3;

                        mLevel = 1;

                        mScore = 0;

                        mFillDirection = FILL_LEFT;

                        mFillSpeed = 20.0f;

                        mPlanetSpeed = 1.5f;

                        mPopulationEaten = mTotalPopulationEaten = 0;

                        mPauseLevel = 0;

                        mLineSpeed = 1.0f;

                        mPlanetIdxCount.clear();

                        mExportIdxCount.clear();

                        mOptionsBtn->SetVisible(true);

                        mApp->mMusicInterface->FadeIn(0);

                        InitLevel(1);

                }

        }

        // Make the beams that the player emits pulse with intensity

        mBeamPulseVal += mBeamPulseAmt;

        if (mBeamPulseVal >= 255)

        {

                mBeamPulseVal = 255;

                mBeamPulseAmt = -mBeamPulseAmt;

        }

        else if (mBeamPulseVal <= 0)

        {

                mBeamPulseVal = 0;

                mBeamPulseAmt = -mBeamPulseAmt;

        }

        MarkDirty();

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::UpdateF(float theFrac)

{

        if (mPauseLevel > 0)

                return;

        if (mFilling)

        {

                // If the beams have been released, update the filling of the grid

                float amt = mFillSpeed * theFrac;

                if (mFillDirection == FILL_RIGHT)

                        FillRight(amt);        

                else if (mFillDirection == FILL_LEFT)

                        FillLeft(amt);

                else if (mFillDirection == FILL_UP)

                        FillUp(amt);

                else if (mFillDirection == FILL_DOWN)

                        FillDown(amt);

                // Check what % full the filled regions are if it's done filling

                if (!mFilling)

                        UpdatePercentComplete();

        }

        // Make the bonus text float upwards and fade it out over time.

        std::vector<BonusText>::iterator it = mBonusText.begin();

        while (it != mBonusText.end())

        {

                BonusText* bt = &*it;

                bt->mY -= 1.00f * theFrac;

                bt->mHue = (bt->mHue + 5) % 0xFF;

                if (--bt->mAlpha <= 0)

                {

                        //Totally faded out, remove it 

                        it = mBonusText.erase(it);

                }

                else

                        ++it;

        }

        // Move the starfield. If a start gets beyond the screen,

        // randomly place it offscreen again

        int i;

        for (i = 0; i < MAX_STARS; i++)

        {

                Star* s = &mStarField[i];

                s->mX += s->mSpeed;

                if (s->mX > mWidth)

                {

                        s->mX = -5;

                        s->mY = Rand() % mHeight;

                }

        }

        if ((!mMovingLine1.mDone || !mMovingLine2.mDone) && !mGameOverEffect->IsActive())

                MoveLines(theFrac);

        // If we're allowed to show the planets and the game isn't paused and the game

        // over effect isn't playing, then we can move the planets around

        if ((!mLevelupEffect->HidePlanets() || (mPauseLevel > 0)) && !mGameOverEffect->IsActive())

        {

                // Move the planets

                int w = IMAGE_PLANETS->GetCelWidth();

                int h = IMAGE_PLANETS->GetCelHeight();

                // Instead of playing the explosion sound every time a planet gets destroyed, we'll

                // only play it once. That way, if you destroy more than 1 planet in one go, you won't

                // hear the same sound played multipled times at once, which would result in this loud,

                // hideous, flanging sound.

                bool playSound = false;

                for (int i = 0; i < mPlanets.size(); i++)

                {

                        Planet* p = &mPlanets[i];

                        // Again, the timer is used solely for incrementing the animation frames

                        ++p->mTimer;

                        if (!p->mExploding)

                        {

                                if (MovePlanet(p, theFrac))

                                        playSound = true;                       // Returns true if the planet is to explode

                        }

                        else

                        {

                                if ((p->mTimer % p->mExplodeSpeed) == 0)

                                {

                                        if (++p->mExplodeFrame >= IMAGE_BOMB_RADIAL_DEATH->mNumCols)

                                        {

                                                mPlanets.erase(mPlanets.begin() + i);

                                                --i;

                                        }

                                }

                        }

                }

                if (playSound)

                        mApp->PlaySample(SOUND_PLANET);

        }

        // update and move the particles. When they have reached

        // their last frame, remove them.

        for (i = 0; i < mParticles.size(); i++)

        {

                Particle* p = &mParticles[i];

                ++p->mTimer;

                p->mX += p->mVX * theFrac;

                p->mY += p->mVY * theFrac;

                p->mVY += 0.1f;

                if (p->mTimer % 6 == 0)

                {

                        if (++p->mFrame >= IMAGE_PARTICLE_LIGHTNING->mNumCols)

                        {

                                mParticles.erase(mParticles.begin() + i);

                                --i;

                        }

                }

        }

        if (mLevelupEffect->IsActive())

        {

                mLevelupEffect->Update(theFrac);

                // If the proper state is reached in the level up effect, then we can begin

                // setting up the next level.

                if (mLevelupEffect->StartNextLevel())

                {

                        // Just finished, start the next level

                        mOptionsBtn->SetVisible(true);

                        InitLevel(mLevel + 1);

                }

        }

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::FillRight(float amt)

{

        bool change = true;

        // Fill the entire line, moving rightward

        for (int y = mFillRegion.mTop; y <= mFillRegion.mBottom; y++)

        {

                GridTile* gt = &mGridState[y][mFillRegion.mLeft];

                // We only want to fill those pieces that are in the GRID_FILLING state

                if (gt->mFillState == GRID_FILLING)

                {

                        // This piece is filling up, expand its width

                        gt->mFillRect.mWidth += amt;

                        // If the width exceeds that of the grid piece, overflow the result

                        // into the tile next to it so that the filling appears continuous.

                        if (gt->mFillRect.mWidth >= GRID_PIX_SIZE)

                        {

                                float overflow = gt->mFillRect.mWidth - GRID_PIX_SIZE;

                                gt->mFillState = GRID_FILLED;

                                gt->mFillRect.mWidth = GRID_PIX_SIZE;

                                //overflow into next column, if the next column is within our

                                //fill region and if the piece is in the normal tile state.

                                if (mFillRegion.mLeft + 1 <= mFillRegion.mRight)

                                        if (mGridState[y][mFillRegion.mLeft + 1].mFillState == GRID_NORMAL)

                                                mGridState[y][mFillRegion.mLeft + 1].mFillRect.mWidth += overflow;

                        }

                        else

                                change = false;

                }              

        }

        //if "change" is true, then move one column right and begin filling in that column next

        //time this function is called. If there are no more columns to fill, we're done.

        if (change && (++mFillRegion.mLeft > mFillRegion.mRight))

                mFilling = false;

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::FillLeft(float amt)

{

        float leftX = GetColPix(mFillRegion.mRight);

        bool change = true;

        //This algorithm works just like FillRight except that it's filling

        //from the right side of the grid piece instead of the left, so there's

        //a couple extra calculations.

        for (int y = mFillRegion.mTop; y <= mFillRegion.mBottom; y++)

        {

                GridTile* gt = &mGridState[y][mFillRegion.mRight];

                if (gt->mFillState == GRID_FILLING)

                {

                        gt->mFillRect.mWidth += amt;

                        gt->mFillRect.mX -= amt;

                        if ((gt->mFillRect.mWidth >= GRID_PIX_SIZE) || (gt->mFillRect.mX < leftX))

                        {

                                float overflow = gt->mFillRect.mWidth - GRID_PIX_SIZE;

                                gt->mFillState = GRID_FILLED;

                                gt->mFillRect.mWidth = GRID_PIX_SIZE;

                                gt->mFillRect.mX = leftX;

                                //overflow into next column

                                if (mFillRegion.mRight - 1 >= mFillRegion.mLeft)

                                {

                                        if (mGridState[y][mFillRegion.mRight - 1].mFillState == GRID_NORMAL)

                                        {

                                                mGridState[y][mFillRegion.mRight - 1].mFillRect.mWidth += overflow;

                                                mGridState[y][mFillRegion.mRight - 1].mFillRect.mX -= overflow;

                                        }

                                }

                        }

                        else

                                change = false;

                }

        }

        if (change && (--mFillRegion.mRight < mFillRegion.mLeft))

                mFilling = false;

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::FillUp(float amt)

{

        bool change = true;

        float topY = GetRowPix(mFillRegion.mBottom);

        //This algorithm works just like FillRight except that it's filling

        //from the bottom side of the grid piece instead of the left, so there's

        //a couple extra calculations.

        for (int x = mFillRegion.mLeft; x <= mFillRegion.mRight; x++)

        {

                GridTile* gt = &mGridState[mFillRegion.mBottom][x];

                if (gt->mFillState == GRID_FILLING)

                {

                        gt->mFillRect.mHeight += amt;

                        gt->mFillRect.mY -= amt;

                        if ((gt->mFillRect.mHeight >= GRID_PIX_SIZE) || (gt->mFillRect.mY < topY))

                        {

                                float overflow = gt->mFillRect.mHeight - GRID_PIX_SIZE;

                                gt->mFillState = GRID_FILLED;

                                gt->mFillRect.mHeight = GRID_PIX_SIZE;

                                gt->mFillRect.mY = topY;

                                //overflow into next row

                                if (mFillRegion.mBottom - 1 > mFillRegion.mTop)

                                {

                                        if (mGridState[mFillRegion.mBottom - 1][x].mFillState == GRID_NORMAL)

                                        {

                                                mGridState[mFillRegion.mBottom - 1][x].mFillRect.mHeight += overflow;

                                                mGridState[mFillRegion.mBottom - 1][x].mFillRect.mY -= overflow;

                                        }

                                }

                        }

                        else

                                change = false;

                }

        }

        if (change && (--mFillRegion.mBottom < mFillRegion.mTop))

                mFilling = false;

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::FillDown(float amt)

{

        bool change = true;

        //This algorithm works just like FillRight except that it's filling

        //from the top side of the grid piece instead of the left.

        for (int x = mFillRegion.mLeft; x <= mFillRegion.mRight; x++)

        {

                GridTile* gt = &mGridState[mFillRegion.mTop][x];

                if (gt->mFillState == GRID_FILLING)

                {

                        gt->mFillRect.mHeight += amt;

                        if (gt->mFillRect.mHeight >= GRID_PIX_SIZE)

                        {

                                float overflow = gt->mFillRect.mHeight - GRID_PIX_SIZE;

                                gt->mFillState = GRID_FILLED;

                                gt->mFillRect.mHeight = GRID_PIX_SIZE;

                                //overflow into next row

                                if (mFillRegion.mTop + 1 <= mFillRegion.mBottom)

                                        if (mGridState[mFillRegion.mTop + 1][x].mFillState == GRID_NORMAL)

                                                mGridState[mFillRegion.mTop + 1][x].mFillRect.mHeight += overflow;

                        }

                        else

                                change = false;

                }

        }

        if (change && (++mFillRegion.mTop > mFillRegion.mBottom))

                mFilling = false;

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::MoveLines(float theFrac)

{

        // Move the lines, differently depending on if they are oriented verticall

        // or horizontally. When a line reaches its target, it is done, and planets

        // can bounce off of it. When both lines are done, we will calculate the region

        // to fill.

        int numDone = 0;

        if (!mMovingLine1.mDone)

        {

                float amt = -mLineSpeed * theFrac;

                if (mMovingLine1.mIsVertical)

                {

                        mMovingLine1.mY += amt;

                        mMovingLine1.mHeight += fabsf(amt);

                        if (mMovingLine1.mY <= mMovingLine1.mTargetY)

                        {

                                mMovingLine1.mY = mMovingLine1.mTargetY;

                                mMovingLine1.mDone = true;

                                ++numDone;

                        }

                }

                else

                {

                        mMovingLine1.mX += amt;

                        mMovingLine1.mWidth += fabsf(amt);

                        if (mMovingLine1.mX <= mMovingLine1.mTargetX)

                        {

                                mMovingLine1.mX = mMovingLine1.mTargetX;

                                mMovingLine1.mDone = true;

                                ++numDone;

                        }

                }

        }

        if (!mMovingLine2.mDone)

        {

                float amt = mLineSpeed * theFrac;

                if (mMovingLine2.mIsVertical)

                {

                        mMovingLine2.mHeight += amt;

                        if (mMovingLine2.mY + mMovingLine2.mHeight >= mMovingLine2.mTargetY)

                        {

                                mMovingLine2.mHeight = mMovingLine2.mTargetY - mMovingLine2.mY;

                                mMovingLine2.mDone = true;

                                ++numDone;

                        }

                }

                else

                {

                        mMovingLine2.mWidth += amt;

                        if (mMovingLine2.mX + mMovingLine2.mWidth >= mMovingLine2.mTargetX)

                        {

                                mMovingLine2.mWidth = mMovingLine2.mTargetX - mMovingLine2.mX;

                                mMovingLine2.mDone = true;

                                ++numDone;

                        }

                }

        }      

        // While at least one of the lines is still moving, make a bunch of sparks shower off

        // the edge of them. In non-3d mode, we'll only emit half the sparks to reduce the CPU time consumed.

        if (!mMovingLine2.mDone || !mMovingLine1.mDone)

        {

                int modVal = gSexyAppBase->Is3DAccelerated() ? 2 : 4;

                if (mUpdateCnt % modVal == 0)

                        EmitSparks();

        }

        // If both are done at the same time, or both are done but perhaps one completed earlier than the other,

        // then it's time to compute the fill region.

        if ((numDone == 2) || ((numDone == 1) && mMovingLine1.mDone && mMovingLine2.mDone))

        {

                mFilling = true;

                CalculateFillRegions();

        }      

        // Quit playing the electrical shorting out sound when both lines are broken or

        // done or any combination of the two.

        if ((mMovingLine1.mDone && mMovingLine2.mDone) ||

                (mMovingLine1.mBroken && mMovingLine2.mDone) ||

                (mMovingLine2.mBroken && mMovingLine1.mDone))

                mShortSound->Stop();

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::Draw(Graphics* g)

{

        g->SetColor(Color::Black);

        g->FillRect(0, 0, mWidth, mHeight);

        int incAmt = gSexyAppBase->Is3DAccelerated() ? 1 : 2;

        // Draw less starts if not in 3D mode to reduce CPU usage, since they aren't a critical feature

        for (int i = 0; i < MAX_STARS; i += incAmt)

        {

                Star* s = &mStarField[i];

                g->SetColor(s->mColor);

                g->FillRect(s->mX, s->mY, 1, 1);

        }      

        // We don't draw the other game elements under certain conditions, like

        // if the level up and game over effects are in a few particular states.

        if (!mLevelupEffect->HideBoard() && !mGameOverEffect->HideBoard())

        {

                DrawGrid(g);

                DrawUI(g);

                // To prevent cheating, don't draw planets if the game is paused.

                // Also don't show them during certain points of the level up effect

                if (!mLevelupEffect->HidePlanets() || (mPauseLevel > 0))

                        DrawPlanets(g);

                if (!mGameOverEffect->IsActive())

                        DrawMovingBeams(g);            

                DrawHungarr(g);

        }      

        if (mLevelupEffect->IsActive())

                mLevelupEffect->Draw(g);

        if (mGameOverEffect->IsActive())

                mGameOverEffect->Draw(g);

        if (mPauseLevel > 0)

        {

                // Paused: draw an overlay

                g->SetColor(Color(0, 0, 0, 128));

                g->FillRect(0, 0, mWidth, mHeight);

                g->SetColor(Color::White);

                g->SetFont(FONT_HUNGARR);

                g->DrawString(_S("PAUSED"), mWidth / 2 - FONT_HUNGARR->StringWidth(_S("PAUSED")) / 2, mHeight / 2);

        }

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

void Board::DrawGrid(Graphics* g)

{

        // Draw an outline around the whole grid region. See LevelUpEffect.cpp or

        // GameOverEffect.cpp for full details on using HSL instead of RGB for color and

        // why it's useful.

        if (mFlashCount > 0)

                g->SetColor(mApp->HSLToRGB(mBorderHue, 255, 128) & 0xFFFFFFFF);

        else

                g->SetColor(Color(255, 0, 0, 64));

        // grid outline:

        g->FillRect(0, GRID_START_Y, GRID_START_X, mHeight - GRID_START_Y);

        g->FillRect(0, GRID_START_Y - GRID_PIX_SIZE, mWidth, GRID_PIX_SIZE);

        g->FillRect(GRID_END_X, GRID_START_Y, mWidth - GRID_END_X, mHeight - GRID_START_Y);

        g->FillRect(GRID_START_X, GRID_END_Y, GRID_END_X - GRID_START_X, mHeight - GRID_END_Y);

        // To make a weird pattern, a few of the grid pieces will be more brightly

        // colored than the others, if they are in the normal state.

        bool startBright = true;

        for (int y = 0; y < GRID_HEIGHT; y++)

        {

                int drawY = GetRowPix(y);

                for (int x = 0; x < GRID_WIDTH; x++)

                {

                        int drawX = GetColPix(x);