blame: source/code/BlockGame.cpp

/*

 * BlockGame.cpp (this was cut from main.cpp for the overview)

 * Copyright (C) 2005 Poul Sander

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Poul Sander

 * R�veh�jvej 36, V. 1111

 * 2800 Kgs. Lyngby

 * DENMARK

 * blockattack@poulsander.com

 */

#include "BlockGame.hpp"

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

//The BloackGame class represents a board, score, time etc. for a single player/

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

    Uint16 BlockGame::rand2() {

        nextRandomNumber = nextRandomNumber*1103515245 + 12345;

        return ((Uint16)(nextRandomNumber/65536)) % 32768;

    }

    int BlockGame::firstUnusedChain() {

        bool found=false;

        int i = 0;

        while (!found) {

            if (!chainUsed[++i])

                found=true;

            if (i>NUMBEROFCHAINS-2)

                found=true;

        }

        return i;

    }

    //Constructor

    BlockGame::BlockGame() {

        srand((int)time(NULL));

        nrFellDown = 0;

        nrPushedPixel = 0;

        garbageTarget = this;

        nrStops=0;

        //topx = tx;

        //topy = ty;

        cursorx = 2;

        cursory = 3;

        stop = 0;

        pixels = 0;

        score = 0;

        bGameOver = false;

        bDraw = false;

        bReplaying=false; //No replay by default

        #if NETWORK

        bDisconnected=false;

        bNetworkPlayer = false;

        #endif

        timetrial = false;

        stageClear = false;

        vsMode = false;

        puzzleMode = false;

        linesCleared = 0;

        AI_Enabled = false;

        AI_MoveSpeed=100;

        hasWonTheGame = false;

        combo=0;                      //counts

        chain=0;

        hangTicks = 0;

        baseSpeed = 0.5;           //All other speeds are relative to this

        speed = baseSpeed;

        speedLevel = 1;

        ticks = 0;

        gameStartedAt = ticks;

        gameEndedAfter = 0;

        pushedPixelAt = gameStartedAt;

        nextGarbageNumber = 10;

        handicap=0;

        for (int i=0;i<7;i++)

            for (int j=0;j<30;j++) {

                board[i][j] = -1;

            }

        for (int i=0;i<NUMBEROFCHAINS;i++) {

            chainUsed[i]=false;

            chainSize[i] = 0;

        }

        theReplay = Replay();

        showGame = true;              //The game is now active

        lastCounter = -1;           //To prevent the final chunk to be played when stating the program

    }	//Constructor

    //Deconstructor, never really used... game used to crash when called, cause of the way sBoard was created

    //It should work now and can be used if we want to assign more players in network games that we need to free later

    BlockGame::~BlockGame() {

    }

    void BlockGame::setGameSpeed(Uint8 globalSpeedLevel) {

        switch (globalSpeedLevel) {

        case 0:

            baseSpeed=0.5;

            break;

        case 1:

            baseSpeed=0.4;

            break;

        case 2:

            baseSpeed=0.3;

            break;

        case 3:

            baseSpeed=0.25;

            break;

        case 4:

            baseSpeed=0.2;

            break;

        default:

            baseSpeed=0.15;

            break;

        };

    }

    void BlockGame::setHandicap(Uint8 globalHandicap) {

        handicap=1000*((Uint32)globalHandicap);

    }

    //Set the move speed of the AI based on the aiLevel parameter

    //Also enables AI

    void BlockGame::setAIlevel(Uint8 aiLevel) {

        AI_Enabled = true;

        AI_MoveSpeed=120-(20*(aiLevel-3));

    };

    Uint8 BlockGame::getAIlevel() {

        return (120-AI_MoveSpeed)/20+3;

    }

    int BlockGame::GetScore() {

        return score;

    }

    int BlockGame::GetHandicap() {

        return handicap;

    }

    bool BlockGame::isGameOver() {

        return bGameOver;

    }

    int BlockGame::GetTopX() {

        return topx;

    }

    int BlockGame::GetTopY() {

        return topy;

    }

    unsigned int BlockGame::GetGameStartedAt() {

        return gameStartedAt;

    }

    unsigned int BlockGame::GetGameEndedAt() {

        return gameEndedAfter;

    }

    bool BlockGame::isTimeTrial() {

        return timetrial;

    }

    bool BlockGame::isStageClear() {

        return stageClear;

    }

    bool BlockGame::isVsMode() {

        return vsMode;

    }

    bool BlockGame::isPuzzleMode() {

        return puzzleMode;

    }

    int BlockGame::GetLinesCleared() {

        return linesCleared;

    }

    int BlockGame::GetStageClearLimit() {

        return stageClearLimit;

    }

    int BlockGame::GetChains() {

        return chain;

    }

    int BlockGame::GetPixels() {

        return pixels;

    }

    int BlockGame::GetSpeedLevel() {

        return speedLevel;

    }

    int BlockGame::GetTowerHeight() {

        return TowerHeight;

    }

    int BlockGame::GetCursorX() {

        return cursorx;

    }

    int BlockGame::GetCursorY() {

        return cursory;

    }

    void BlockGame::MoveCursorTo(int x, int y) {

        cursorx = x;

        cursory = y;

    }

    bool BlockGame::GetIsWinner() {

        return hasWonTheGame;

    }

#if NETWORK

#define garbageStackSize 10

    void BlockGame::emptyGarbageStack() {

        for (int i=0;i<10;i++)

            for (int j=0;j<3;j++)

                garbageStack[i][j] = 0;

        garbageStackUsed = 0;

    }

    bool BlockGame::pushGarbage(Uint8 width, Uint8 height, Uint8 type) {

        if (garbageStackUsed>=garbageStackSize)

            return false;

        garbageStack[garbageStackUsed][0]=width;

        garbageStack[garbageStackUsed][1]=height;

        garbageStack[garbageStackUsed][2]=type;

        garbageStackUsed++;

        return true;

    }

    bool BlockGame::popGarbage(Uint8 *width, Uint8 *height, Uint8 *type) {

        if (garbageStackUsed<1)

            return false;

        garbageStackUsed--;

        *width=garbageStack[garbageStackUsed][0];

        *height=garbageStack[garbageStackUsed][1];

        *type=garbageStack[garbageStackUsed][2];

        return true;

    }

#endif

    //Instead of creating new object new game is called, to prevent memory leaks

    void BlockGame::NewGame(int tx, int ty, unsigned int ticks) {

        this->ticks = ticks;

        stageButtonStatus = SBdontShow;

        bReplaying  =  false;

        #if NETWORK

        bNetworkPlayer=false;

        bDisconnected =false;

        #endif

        nrFellDown = 0;

        lastNrOfPlayers = 1; //At least one player :-)

        nrPushedPixel = 0;

        nrStops = 0;

        topx = tx;

        topy = ty;

        cursorx = 2;

        cursory = 3;

        stop = 0;

        pixels = 0;

        score = 0;

        bGameOver = false;

        bDraw = false;

        timetrial = false;

        stageClear = false;

        linesCleared = 0;

        hasWonTheGame = false;

        vsMode = false;

        puzzleMode = false;

        combo=0;

        chain=0;

        AI_Enabled = false;

        baseSpeed= 0.5;

        speed = baseSpeed;

        speedLevel = 1;

        gameStartedAt = ticks+3000;

        pushedPixelAt = gameStartedAt;

        nextGarbageNumber = 10;

        handicap=0;

        for (int i=0;i<7;i++)

            for (int j=0;j<30;j++) {

                board[i][j] = -1;

            }

        for (int i=0;i<NUMBEROFCHAINS;i++) {

            chainUsed[i]=false;

            chainSize[i] = 0;

        }

        lastAImove = ticks+3000;

        showGame = true;

        theReplay = Replay();

    }	//NewGame

    void BlockGame::NewTimeTrialGame(int x,int y, unsigned int ticks) {

        NewGame(x,y,ticks);

        timetrial = true;

        putStartBlocks();

    }

    //Starts a new stage game, takes level as input!

    void BlockGame::NewStageGame(int level, int tx, int ty,unsigned int ticks) {

        if (level > -1) {

            NewGame(tx, ty,ticks);

            stageClear = true;

            Level = level;

            Stats::getInstance()->addOne("PlayedStageLevel"+itoa2(level));

            stageClearLimit = 30+(Level%6)*10;

            baseSpeed = 0.5/((double)(Level*0.5)+1.0);

            speed = baseSpeed;

        }

    }

    void BlockGame::NewPuzzleGame(int level, int tx, int ty, unsigned int ticks) {

        if (level>-1) {

            NewGame(tx, ty,ticks);

            puzzleMode = true;

            Level = level;

            MovesLeft = nrOfMovesAllowed[Level];

            for (int i=0;i<6;i++)

                for (int j=0;j<12;j++) {

                    board[i][j+1] = puzzleLevels[Level][i][j];

                }

            baseSpeed = 100000;

            speed = 100000;

            //Now push the blines up

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

                for (int j=0;j<6;j++) {

                    board[j][i] = board[j][i-1];

                }

            for (int j=0;j<6;j++) {

                board[j][0] = rand() % 6;

                if (j > 0) {

                    if (board[j][0] == board[j-1][0])

                        board[j][0] = rand() % 6;

                }

                if (board[j][0] == board[j][1])

                    board[j][0] = 6;

                if (board[j][0] == board[j][1])

                    board[j][0] = 6;

            }

        }

    }

    //Replay the current level

    void BlockGame::retryLevel(unsigned int ticks)

    {

        if(puzzleMode)

            NewPuzzleGame(Level,topx,topy,ticks);

        else

            if(stageClear)

                NewStageGame(Level,topx,topy,ticks);

    }

    //Play the next level

    void BlockGame::nextLevel(unsigned int ticks)

    {

        if(puzzleMode)

        {

            if(Level<nrOfPuzzles-1)

                NewPuzzleGame(Level+1,topx,topy,ticks);

        }

        else

            if(stageClear)

            {

                if(Level<50-1)

                    NewStageGame(Level+1,topx,topy,ticks);

            }

    }

    //Starts new Vs Game (two Player)

    void BlockGame::NewVsGame(int tx, int ty, BlockGame *target,unsigned int ticks) {

        NewGame(tx, ty,ticks);

        vsMode = true;

        putStartBlocks();

        garbageTarget = target;

        Stats::getInstance()->addOne("VSgamesStarted");

    }

    //Starts new Vs Game (two Player)

    void BlockGame::NewVsGame(int tx, int ty, BlockGame *target, bool AI,unsigned int ticks) {

        NewGame(tx, ty,ticks);

        vsMode = true;

        AI_Enabled = AI;

        if(!AI)

            Stats::getInstance()->addOne("VSgamesStarted");

        else

            strcpy(name,"CPU\0");

        putStartBlocks();

        garbageTarget = target;

    }

    //Go in Demonstration mode, no movement

    void BlockGame::Demonstration(bool toggle) {

        speed=0;

        baseSpeed = 0;

    }

    //We want to play the replay (must have been loaded beforehand)

    void BlockGame::playReplay(int tx, int ty, unsigned int ticks) {

        NewGame(tx, ty,ticks);

        gameStartedAt = ticks;

        bReplaying = true; //We are playing, no calculations

        #if NETWORK

        bNetworkPlayer = false; //Take input from replay file

        #endif

    }

#if NETWORK

    //network play

    void BlockGame::playNetwork(int tx, int ty,unsigned int ticks) {

        NewGame(tx, ty,ticks);

        gameStartedAt = ticks;

        bReplaying = false; //We are playing, no calculations

        bNetworkPlayer = true; //Don't Take input from replay file

        emptyGarbageStack();

    }

#endif

    //Prints "winner" and ends game

    void BlockGame::setPlayerWon() {

        if (!bGameOver)

        {

            gameEndedAfter = ticks-gameStartedAt; //We game ends now!

	    if(!AI_Enabled && !bReplaying)

		{

			TimeHandler::addTime("playTime",TimeHandler::ms2ct(gameEndedAfter));

		}

        }

        theReplay.setFinalFrame(getPackage(), 1);

        bGameOver = true;

        hasWonTheGame = true;

        showGame = false;

        if (SoundEnabled)Mix_PlayChannel(1, applause, 0);

        if(!AI_Enabled && !bReplaying)

        {

            Stats::getInstance()->addOne("totalWins");

            if(garbageTarget->AI_Enabled && !(garbageTarget->bReplaying))

            {

                //We have defeated an AI

                Stats::getInstance()->addOne("defeatedAI"+itoa(garbageTarget->getAIlevel()));

            }

        }

        if(AI_Enabled && !(garbageTarget->AI_Enabled) && garbageTarget->bReplaying==false)

        {

            //The AI have defeated a human player

            Stats::getInstance()->addOne("defeatedByAI"+itoa(getAIlevel()));

        }

    }

    //void SetGameOver();

    #if NETWORK

    //Sets disconnected:

    void BlockGame::setDisconnect() {

        bDisconnected = true;

        SetGameOver();

    }

    #endif

    //Prints "draw" and ends the game

    void BlockGame::setDraw() {

        bGameOver = true;

	if(!AI_Enabled && !bReplaying)

	{

		TimeHandler::addTime("playTime",TimeHandler::ms2ct(gameEndedAfter));

	}

        theReplay.setFinalFrame(getPackage(), 3);

        hasWonTheGame = false;

        bDraw = true;

        showGame = false;

        Mix_HaltChannel(1);

        if(!AI_Enabled && !bReplaying)

            Stats::getInstance()->addOne("totalDraws");

    }

    //Function to get a boardpackage

    boardPackage BlockGame::getPackage() {

        boardPackage bp;

        if(ticks<gameStartedAt)

            bp.time = 0;

        else

            bp.time = (Uint32)(ticks-gameStartedAt);

        for (int i=0;i<6;i++)

            for (int j=0;j<13;j++) {

                if (board[i][j]%10<7)

                    bp.brick[i][j]=board[i][j]%10+1;

                if ((board[i][j]/1000000)%10==1)

                {

                    //Ordinary garbage

                    int aInt=0; //N=1, S=2, W=4, E=8

                    if (i==0)

                        aInt+=4;

                    else

                        if ((board[i-1][j])!=(board[i][j]))

                            aInt+=4;

                    if (i==5)

                        aInt+=8;

                    else

                        if ((board[i+1][j])!=(board[i][j]))

                            aInt+=8;

                    if (j==0)

                        aInt+=2;

                    else

                        if ((board[i][j-1])!=(board[i][j]))

                            aInt+=2;

                    if ((board[i][j+1])!=(board[i][j]))

                        aInt+=1;

                    switch (aInt) {

                    case 8:

                        bp.brick[i][j]=8;

                        break;

                    case 7:

                        bp.brick[i][j]=10;

                        break;

                    case 11:

                        bp.brick[i][j]=11;

                        break;

                    case 9:

                        bp.brick[i][j]=12;

                        break;

                    case 5:

                        bp.brick[i][j]=13;

                        break;

                    case 6:

                        bp.brick[i][j]=14;

                        break;

                    case 10:

                        bp.brick[i][j]=15;

                        break;

                    case 3: //M

                        bp.brick[i][j]=16;

                        break;

                    case 0:

                        bp.brick[i][j]=17;

                        break;

                    case 1:

                        bp.brick[i][j]=18;

                        break;

                    case 2:

                        bp.brick[i][j]=19;

                        break;

                    case 4:

                        bp.brick[i][j]=20;

                        break;

                    default:

                        bp.brick[i][j]=0;

                    };

                    //cout << "garbage added to replay: " << aInt << endl;

                }

                if ((board[i][j]/1000000)%10==2)

                {

                    //Gray garbage

                    bp.brick[i][j]=21;

                }

                if ((board[i][j]/BLOCKHANG)%10==1) //If "get ready"

                    bp.brick[i][j]+=30;

            }

        bp.cursorX = (Uint8)cursorx;

        bp.cursorY = (Uint8)cursory;

        bp.score = (Uint32)score;

        bp.pixels = (Uint8)pixels;

        bp.chain = (Uint8)chain;

        bp.speed = (Uint8)speedLevel;

        Uint8 result = 0;

        if (bGameOver)

            result+=1;

        if (hasWonTheGame)

            result+=2;

        if (bDraw)

            result+=4;

        bp.result = (Uint8)result;

        return bp;

    }

    //Takes a package and sets the board like it

    void BlockGame::setBoard(boardPackage bp) {

        //gameStartedAt = ticks-bp.time;

        for (int i=0;i<6;i++)

            for (int j=0;j<13;j++) {

                //if(bp.brick[i][j]/8==0)

                board[i][j]=bp.brick[i][j]-1;

                //else

                //	board[i][j]=-1;

            }

        cursorx=bp.cursorX;

        cursory=bp.cursorY;

        score=bp.score;

        pixels=bp.pixels;

        chain=bp.chain;

        speedLevel=bp.speed;

        Uint8 result = bp.result;

        bGameOver = false; //Make sure that it is initialized!

        if(result%2==1) {

            bGameOver=true;

            result-=1;

        }

        if (result%4==2) {

            hasWonTheGame = true;

            result-=2;

        }

        if (result==4) {

            bDraw = true;

        }

    }

    //Test if LineNr is an empty line, returns false otherwise.

    bool BlockGame::LineEmpty(int lineNr) {

        bool empty = true;

        for (int i = 0; i <7; i++)

            if (board[i][lineNr] != -1)

                empty = false;

        return empty;

    }

    //Test if the entire board is empty (used for Puzzles)

    bool BlockGame::BoardEmpty() {

        bool empty = true;

        for (int i=0;i<6;i++)

            for (int j=1;j<13;j++)

                if (board[i][j] != -1)

                    empty = false;

        return empty;

    }

    //Anything that the user can't move? In that case Game Over cannot occur

    bool BlockGame::hasStaticContent() {

        for (int i=0;i<6;i++)

            for (int j=1;j<13;j++)

                if (board[i][j] >= 10000000) 	//Higher than this means combos (garbage is static, but the stack is static but nothing to do about it)

                    return true;			//They are static

        return false;					//Return false if no static object found

    }

    /*

     * Generates some blocks so the user don't see a board without blocks

     */

    //void putStartBlocks(Uint32);

    void BlockGame::putStartBlocks() {

        putStartBlocks(time(0));

    }

    void BlockGame::putStartBlocks(Uint32 n) {

        for (int i=0;i<7;i++)

            for (int j=0;j<30;j++) {

                board[i][j] = -1;

            }

        nextRandomNumber = n;

        int choice = rand2()%3; //Pick a random layout

        switch (choice) {

        case 0:

            //row 0:

            board[0][0]=1;

            board[1][0]=0;

            board[2][0]=4;

            board[3][0]=3;

            board[4][0]=3;

            board[5][0]=5;

            //row 1:

            board[0][1]=1;

            board[1][1]=4;

            board[2][1]=2;

            board[3][1]=0;

            board[4][1]=4;

            board[5][1]=5;

            //row 2:

            board[0][2]=2;

            board[1][2]=3;

            board[2][2]=0;

            board[3][2]=4;

            board[4][2]=1;

            board[5][2]=1;

            //row 3:

            board[0][3]=3;

            board[1][3]=2;

            board[2][3]=3;

            board[3][3]=1;

            board[4][3]=0;

            board[5][3]=4;

            //row 4:

            board[0][4]=2;

            board[1][4]=3;

            board[2][4]=3;

            board[3][4]=1;

            board[4][4]=4;

            board[5][4]=0;

            //row 5:

            board[0][5]=-1;

            board[1][5]=5;

            board[2][5]=5;

            board[3][5]=-1;

            board[4][5]=1;

            board[5][5]=-1;

            break;

        case 1:

            //row 0:

            board[0][0]=3;

            board[1][0]=5;

            board[2][0]=0;

            board[3][0]=0;

            board[4][0]=4;

            board[5][0]=2;

            //row 1:

            board[0][1]=3;

            board[1][1]=5;

            board[2][1]=-1;

            board[3][1]=5;

            board[4][1]=4;

            board[5][1]=2;

            //row 2:

            board[0][2]=2;

            board[1][2]=-1;

            board[2][2]=-1;

            board[3][2]=4;

            board[4][2]=0;

            board[5][2]=3;

            //row 3:

            board[0][3]=2;

            board[5][3]=3;

            break;

        default:

            //row 0:

            board[0][0]=4;

            board[1][0]=5;

            board[2][0]=2;

            board[3][0]=0;

            board[4][0]=1;

            board[5][0]=5;

            //row 1:

            board[0][1]=4;

            board[1][1]=5;

            board[2][1]=2;

            board[3][1]=1;

            board[4][1]=0;

            board[5][1]=2;

            //row 2:

            board[0][2]=2;

            board[1][2]=4;

            board[2][2]=-1;

            board[3][2]=0;

            board[4][2]=1;

            board[5][2]=5;

            //row 3:

            board[0][3]=4;

            board[1][3]=2;

            board[2][3]=-1;

            board[3][3]=1;

            board[4][3]=0;

            board[5][3]=2;

            //row 4:

            board[0][4]=4;

            board[1][4]=2;

            board[2][4]=-1;

            board[3][4]=0;

            board[4][4]=1;

            board[5][4]=-1;

            break;

        };

    }

    //decreases hang for all hanging blocks and wait for waiting blocks

    void BlockGame::ReduceStuff() {

        Uint32 howMuchHang = (ticks - FRAMELENGTH*hangTicks)/FRAMELENGTH;

        if (howMuchHang>0) {

            for (int i=0; i<7; i++)

                for (int j=0; j<30; j++) {

                    if ((board[i][j]/BLOCKHANG)%10==1) {

                        int hangNumber = (board[i][j]/10)%100;

                        if (hangNumber<=howMuchHang) {

                            board[i][j]-=BLOCKHANG;

                            board[i][j]-=hangNumber*10;

                        }

                        else {

                            board[i][j]-=10*howMuchHang;

                        }

                    }

                    if ((board[i][j]/BLOCKWAIT)%10==1) {

                        int hangNumber = (board[i][j]/10)%100;

                        if (hangNumber<=howMuchHang) {

                            //The blocks must be cleared

                            board[i][j]-=hangNumber*10;

                        }

                        else {

                            board[i][j]-=10*howMuchHang;

                        }

                    }

                }

        }

        hangTicks+=howMuchHang;

    }

    //Creates garbage using a given wide and height

    bool BlockGame::CreateGarbage(int wide, int height) {

#if NETWORK

        if (bNetworkPlayer) {

            pushGarbage(wide, height, 0);

        }

        else

#endif

        {

            if (wide>6) wide = 6;

            if (height>12) height = 12;

            int startPosition = 12;

            while ((!(LineEmpty(startPosition))) || (startPosition == 29))

                startPosition++;

            if (startPosition == 29) return false; //failed to place blocks

            if (29-startPosition<height) return false;	//not enough space

            int start, end;

            if (bGarbageFallLeft)

            {

                start=0;

                end=start+wide;

                bGarbageFallLeft = false;

            }

            else

            {

                start=6-wide;

                end = 6;

                bGarbageFallLeft = true;

            }

            for (int i = startPosition; i <startPosition+height; i++)

                for (int j = start; j < end; j++) {

                    board[j][i] = 1000000+nextGarbageNumber;

                }

            nextGarbageNumber++;

            if (nextGarbageNumber>999999) nextGarbageNumber = 10;

            //bGarbageFallLeft = !(bGarbageFallLeft);

            return true;

        }

    }

    //Creates garbage using a given wide and height

    bool BlockGame::CreateGreyGarbage() {

#if NETWORK

        if (bNetworkPlayer) {

            pushGarbage(6, 1, 1);

        }

        else

#endif

        {

            int startPosition = 12;

            while ((!(LineEmpty(startPosition))) || (startPosition == 29))

                startPosition++;

            if (startPosition == 29) return false; //failed to place blocks

            if (29-startPosition<1) return false;	//not enough space

            int start, end;

            {

                start=0;

                end=6;

            }

            for (int i = startPosition; i <startPosition+1; i++)

                for (int j = start; j < end; j++) {

                    board[j][i] = 2*1000000+nextGarbageNumber;

                }

            nextGarbageNumber++;

            if (nextGarbageNumber>999999) nextGarbageNumber = 10;

            return true;

        }

    }

    //Clears garbage, must take one the lower left corner!

    int BlockGame::GarbageClearer(int x, int y, int number, bool aLineToClear, int chain) {

        if ((board[x][y])%1000000 != number) return -1;