blame: source/code/BlockGame.hpp

/*

 * BlockGame.hpp (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 "stats.h"

#include "common.h"

#include "mainVars.hpp"

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

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

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

class BlockGame {

private:

    int prevTowerHeight;

    bool bGarbageFallLeft;

    bool bDraw;

    bool bReplaying; //true if we are watching a replay

    #if NETWORK

    bool bNetworkPlayer; //must recieve packages from the net

    bool bDisconnected; //The player has disconnected

    #endif

    Uint32 nextGarbageNumber;

    Uint32 pushedPixelAt;

    Uint32 nrPushedPixel, nrFellDown, nrStops;

    bool garbageToBeCleared[7][30];

    Uint32 lastAImove;

    Sint16 AI_LineOffset; //how many lines have changed since command

    string strHolder;

    Uint32 hangTicks;    //How many times have hang been decreased?

    //int the two following index 0 may NOT be used (what the fuck did I meen?)

    Uint8 chainSize[NUMBEROFCHAINS]; //Contains the chains

    bool chainUsed[NUMBEROFCHAINS];   //True if the chain is used

    Uint32 nextRandomNumber;

    Uint16 rand2() {

        nextRandomNumber = nextRandomNumber*1103515245 + 12345;

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

    }

    int firstUnusedChain() {

        bool found=false;

        int i = 0;

        while (!found) {

            if (!chainUsed[++i])

                found=true;

            if (i>NUMBEROFCHAINS-2)

                found=true;

        }

        return i;

    }

public:

    char name[30];

    Uint32 gameStartedAt;

    Uint32 gameEndedAfter;		//How long did the game last?

    int linesCleared;

    SDL_Surface* sBoard;

    int TowerHeight;

    BlockGame *garbageTarget;

    Sint32 board[7][30];

    int stop;

    int speedLevel;

    int pixels;

    int MovesLeft;

    bool timetrial, stageClear, vsMode, puzzleMode;

    int Level; //Only used in stageClear and puzzle (not implemented)

    int stageClearLimit; //stores number of lines user must clear to win

    int topx, topy;

    int combo;

    int chain;

    int cursorx; //stores cursor position

    int cursory; // -||-

    double speed, baseSpeed; //factor for speed. Lower value = faster gameplay

    Uint32 score;

    bool bGameOver;

    bool hasWonTheGame;

    int AI_MoveSpeed;   //How often will the computer move? milliseconds

    bool AI_Enabled;

    Replay theReplay;   //Stores the replay

    Uint32 handicap;

    //Constructor

    BlockGame(int tx, int ty) {

        tmp = IMG_Load2((char*)"gfx/BackBoard.png");

        sBoard = SDL_DisplayFormat(tmp);

        SDL_FreeSurface(tmp);

        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;

        gameStartedAt = SDL_GetTicks();

        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() {

        SDL_FreeSurface(sBoard);

    }

    void 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 setHandicap(Uint8 globalHandicap) {

        handicap=1000*((Uint32)globalHandicap);

    }

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

    void setAIlevel(Uint8 aiLevel) {

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

    };

    Uint8 getAIlevel() {

        return (120-AI_MoveSpeed)/20+3;

    }

#if NETWORK

#define garbageStackSize 10

    Uint8 garbageStack[garbageStackSize][3]; //A garbage stack with space for 10 garbage blocks. 0=x,1=y,2=type

    int garbageStackUsed;

    void emptyGarbageStack() {

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

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

                garbageStack[i][j] = 0;

        garbageStackUsed = 0;

    }

    bool 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 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

    //Loads BackBoard again if surface format has changed

    void convertSurface() {

        SDL_FreeSurface(sBoard);

        cout << "2.1" << endl;

        sBoard = SDL_DisplayFormat(backBoard);

        cout << "2.2" << endl;

    }

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

    void NewGame(int tx, int ty) {

        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 = SDL_GetTicks()+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 = SDL_GetTicks()+3000;

        showGame = true;

        theReplay = Replay();

    }	//NewGame

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

    void NewStageGame(int level, int tx, int ty) {

        if (level > -1) {

            NewGame(tx, ty);

            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 NewPuzzleGame(int level, int tx, int ty) {

        if (level>-1) {

            NewGame(tx, ty);

            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 retryLevel()

    {

        if(puzzleMode)

            NewPuzzleGame(Level,topx,topy);

        else

            if(stageClear)

                NewStageGame(Level,topx,topy);

    }

    //Play the next level

    void nextLevel()

    {

        if(puzzleMode)

        {

            if(Level<nrOfPuzzles-1)

                NewPuzzleGame(Level+1,topx,topy);

        }

        else

            if(stageClear)

            {

                if(Level<50-1)

                    NewStageGame(Level+1,topx,topy);

            }

    }

    //Starts new Vs Game (two Player)

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

        NewGame(tx, ty);

        vsMode = true;

        putStartBlocks();

        garbageTarget = target;

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

    }

    //Starts new Vs Game (two Player)

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

        NewGame(tx, ty);

        vsMode = true;

        AI_Enabled = AI;

        if(!AI)

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

        putStartBlocks();

        garbageTarget = target;

    }

    //Go in Demonstration mode, no movement

    void Demonstration(bool toggle) {

        speed=0;

        baseSpeed = 0;

    }

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

    void playReplay(int tx, int ty) {

        NewGame(tx, ty);

        gameStartedAt = SDL_GetTicks();

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

        #if NETWORK

        bNetworkPlayer = false; //Take input from replay file

        #endif

    }

#if NETWORK

    //network play

    void playNetwork(int tx, int ty) {

        NewGame(tx, ty);

        gameStartedAt = SDL_GetTicks();

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

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

        emptyGarbageStack();

    }

#endif

    //Prints "winner" and ends game

    void setPlayerWon() {

        if (!bGameOver)

        {

            gameEndedAfter = SDL_GetTicks()-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 setDisconnect() {

        bDisconnected = true;

        SetGameOver();

    }

    #endif

    //Prints "draw" and ends the game

    void 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 getPackage() {

        boardPackage bp;

        if(SDL_GetTicks()<gameStartedAt)

            bp.time = 0;

        else

            bp.time = (Uint32)(SDL_GetTicks()-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 setBoard(boardPackage bp) {

        //gameStartedAt = SDL_GetTicks()-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 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 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 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 putStartBlocks() {

        putStartBlocks(time(0));

    }

    void 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 ReduceStuff() {

        Uint32 howMuchHang = (SDL_GetTicks() - 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 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 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 GarbageClearer(int x, int y, int number, bool aLineToClear, int chain) {

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

        if (aLineToClear) {

            board[x][y] = rand() % 6;

            board[x][y] += 10*HANGTIME+BLOCKHANG+CHAINPLACE*chain;

        }

        garbageToBeCleared[x][y] = false;

        GarbageClearer(x+1, y, number, aLineToClear, chain);

        GarbageClearer(x, y+1, number, false, chain);

        return 1;

    }

    //Marks garbage that must be cleared

    int GarbageMarker(int x, int y) {

        if ((x>6)||(x<0)||(y<0)||(y>29)) return -1;

        if (((board[x][y])/1000000 == 1)&&(garbageToBeCleared[x][y] == false)) {

            garbageToBeCleared[x][y] = true;

            //Float fill

            GarbageMarker(x-1, y);

            GarbageMarker(x+1, y);

            GarbageMarker(x, y-1);

            GarbageMarker(x, y+1);

        }

        return 1;

    }

    int FirstGarbageMarker(int x, int y) {