diff --git a/source/code/BlockGame.cpp b/source/code/BlockGame.cpp
new file mode 100644
index 0000000..62dfc00
--- /dev/null
+++ b/source/code/BlockGame.cpp
@@ -0,0 +1,2361 @@
+/*
+ * 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 "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(int tx, int ty) {
+        #if WITH_SDL
+        tmp = IMG_Load2((char*)"gfx/BackBoard.png");
+        sBoard = SDL_DisplayFormat(tmp);
+        SDL_FreeSurface(tmp);
+        #endif
+        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 = 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() {
+        #if WITH_SDL
+        SDL_FreeSurface(sBoard);
+        #endif
+    }
+
+    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
+
+    #if WITH_SDL
+    //Loads BackBoard again if surface format has changed
+    void BlockGame::convertSurface() {
+        SDL_FreeSurface(sBoard);
+        sBoard = SDL_DisplayFormat(backBoard);
+    }
+    #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;
+        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 BlockGame::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 BlockGame::FirstGarbageMarker(int x, int y) {
+        if ((x>6)||(x<0)||(y<0)||(y>29)) return -1;
+        if (((board[x][y])/1000000 == 2)&&(garbageToBeCleared[x][y] == false)) {
+            for (int i=0;i<6;i++)
+                garbageToBeCleared[i][y] = true;
+        }
+        else
+            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;
+    }
+
+    //Clear Blocks if 3 or more is alligned (naive implemented)
+    void BlockGame::ClearBlocks() {
+
+        bool toBeCleared[7][30]; //true if blok must be removed
+
+        int previus=-1; //the last block checked
+        int combo=0;
+        for (int i=0;i<30;i++)
+            for (int j=0;j<7;j++) {
+                toBeCleared[j][i] = false;
+                garbageToBeCleared[j][i] = false;
+            }
+        for (int i=0;i<7;i++) {
+            bool faaling = false;
+            for (int j=0;j<30;j++) {
+                if ((faaling)&&(board[i][j]>-1)&&(board[i][j]%10000000<7)) {
+                    board[i][j]+=BLOCKFALL;
+                }
+                if ((!faaling)&&((board[i][j]/BLOCKFALL)%10==1))
+                    board[i][j]-=BLOCKFALL;
+                if (!((board[i][j]>-1)&&(board[i][j]%10000000<7)))
+                    faaling=true;
+                if (((board[i][j]/1000000)%10==1)||((board[i][j]/1000000)%10==2)||((board[i][j]/BLOCKHANG)%10==1)||((board[i][j]/BLOCKWAIT)%10==1))
+                    faaling = false;
+            }
+        }
+
+
+        for (int j=0;j<7;j++) {
+            previus = -1;
+            combo=0;
+
+            for (int i=1;i<30;i++) {
+                if ((board[j][i]>-1)&&(board[j][i]%10000000<7)) {
+                    if (board[j][i]%10000000 == previus) {
+                        combo++;
+                    }
+                    else {
+                        if (combo>2)
+                            for (int k = i-combo; k<i;k++) {
+                                toBeCleared[j][k] = true;
+                            }
+                        combo=1;
+                        previus = board[j][i]%10000000;
+                    }
+                } //if board
+                else {
+                    if (combo>2)
+                        for (int k = i-combo; k<i;k++) {
+                            toBeCleared[j][k] = true;
+                        }
+                    combo = 0;
+                    previus = -1;
+                }
+
+            } //for i
+        } //for j
+
+
+        combo = 0;
+        chain = 0;
+        for (int i=0; i<6;i++)
+            for (int j=0; j<30;j++) {
+                //Clears blocks marked for clearing
+                Sint32 temp=board[i][j];
+                if (1==((temp/BLOCKWAIT)%10))
+                    if (((temp/10)%100)==0) {
+                        if (chainSize[chain]<chainSize[board[i][j]/10000000])
+                            chain = board[i][j]/10000000;
+
+                        theBallManeger.addBall(topx+40+i*bsize, topy+bsize*12-j*bsize, true, board[i][j]%10);
+                        theBallManeger.addBall(topx+i*bsize, topy+bsize*12-j*bsize, false, board[i][j]%10);
+                        theExplosionManeger.addExplosion(topx-10+i*bsize, topy+bsize*12-10-j*bsize);
+                        board[i][j]=-2;
+                    }
+            }
+        for (int i=0; i<7;i++) {
+            bool setChain=false;
+            for (int j=0; j<30;j++) {
+                if (board[i][j]==-1)
+                    setChain=false;
+                if (board[i][j]==-2) {
+                    board[i][j]=-1;
+                    setChain=true;
+                    if (SoundEnabled)Mix_PlayChannel(0, boing, 0);
+                }
+                if (board[i][j]!=-1)
+                    if ((setChain)&&((board[i][j]/GARBAGE)%10!=1)&&((board[i][j]/GARBAGE)%10!=2)) {
+                        board[i][j]=((board[i][j]%CHAINPLACE)+CHAINPLACE*chain);
+                        //somethingsGottaFall = true;
+                    }
+
+            }
+        }
+        combo=0;
+        int startvalue;
+        if (pixels == 0)
+            startvalue=1;
+        else
+            startvalue=0;
+        for (int i=startvalue;i<30;i++) {
+            previus=-1;
+            combo=0;
+            for (int j=0;j<7;j++) {
+                if (((board[j][i]>-1)&&(board[j][i]%10000000<7))) {
+                    if (board[j][i]%10000000 == previus) {
+                        combo++;
+                    }
+                    else {
+                        if (combo>2)
+                            for (int k = j-combo; k<j;k++) {
+                                toBeCleared[k][i] = true;
+                            }
+                        combo=1;
+                        previus = board[j][i]%10000000;
+                    }
+                } //if board
+                else {
+                    if (combo>2)
+                        for (int k = j-combo; k<j;k++) {
+                            toBeCleared[k][i] = true;
+                        }
+                    combo = 0;
+                    previus = -1;
+                }
+
+            } //for j
+        } //for i
+        bool blockIsFalling[6][30]; //See that is falling
+        for (int i=0;i<30;i++)
+            for (int j=0;j<6;j++)
+                blockIsFalling[j][i] = false;
+
+
+
+        combo = 0;
+        chain = 0;
+        int grey = 0;
+        for (int i=0;i<30;i++)
+            for (int j=0;j<6;j++)
+                if (toBeCleared[j][i]) {
+                    //see if any garbage is around:
+                    FirstGarbageMarker(j-1, i);
+                    FirstGarbageMarker(j+1, i);
+                    FirstGarbageMarker(j, i-1);
+                    FirstGarbageMarker(j, i+1);
+                    //that is checked now :-)
+                    if (board[j][i]%10000000==6)
+                        grey++;
+                    if ((vsMode) && (grey>2) && (board[j][i]%10000000==6))
+                        garbageTarget->CreateGreyGarbage();
+                    if ((board[j][i]>-1)&&(board[j][i]%10000000<7))
+                        board[j][i]+=BLOCKWAIT+10*FALLTIME;
+
+                    if (chainSize[board[j][i]/10000000]>chainSize[chain])
+                        chain=board[j][i]/10000000;
+                    combo++;
+                    stop+=140*combo;
+                    score +=10;
+                    if (combo>3)
+                        score+=3*combo; //More points if more cleared simontanously
+                }
+        score+=chainSize[chain]*100;
+        if (chain==0) {
+            chain=firstUnusedChain();
+            chainSize[chain]=0;
+            chainUsed[chain]=true;
+        }
+        chainSize[chain]++;
+        for (int i=0;i<30;i++)
+            for (int j=0;j<6;j++) {
+                //if(board[j][i]/10==(BLOCKWAIT+10*FALLTIME)/10)
+                if (toBeCleared[j][i]) {
+                    board[j][i]=(board[j][i]%10000000)+chain*10000000;
+                }
+            }
+
+        { //This is here we add text to screen!
+            bool dead = false;
+            for (int i=29;i>=0;i--)
+                for (int j=0;j<6;j++)
+                    if (toBeCleared[j][i]) {
+                        if (!dead) {
+                            dead=true;
+                            string tempS = itoa(chainSize[chain]);
+                            if (chainSize[chain]>1)
+                                theTextManeger.addText(topx-10+j*bsize, topy+12*bsize-i*bsize, tempS, 1000);
+                        }
+                    }
+        } //This was there text was added
+
+        if (vsMode)
+            switch (combo) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+                break;
+            case 4:
+                garbageTarget->CreateGarbage(3, 1);
+                break;
+            case 5:
+                garbageTarget->CreateGarbage(4, 1);
+                break;
+            case 6:
+                garbageTarget->CreateGarbage(5, 1);
+                break;
+            case 7:
+                garbageTarget->CreateGarbage(6, 1);
+                break;
+            case 8:
+                garbageTarget->CreateGarbage(4, 1);
+                garbageTarget->CreateGarbage(4, 1);
+                break;
+            case 9:
+                garbageTarget->CreateGarbage(5, 1);
+                garbageTarget->CreateGarbage(4, 1);
+                break;
+            case 10:
+                garbageTarget->CreateGarbage(5, 1);
+                garbageTarget->CreateGarbage(5, 1);
+                break;
+            case 11:
+                garbageTarget->CreateGarbage(6, 1);
+                garbageTarget->CreateGarbage(5, 1);
+                break;
+            case 12:
+                garbageTarget->CreateGarbage(6, 1);
+                garbageTarget->CreateGarbage(6, 1);
+                break;
+            case 13:
+                garbageTarget->CreateGarbage(5, 1);
+                garbageTarget->CreateGarbage(5, 1);
+                garbageTarget->CreateGarbage(4, 1);
+                break;
+            default:
+                garbageTarget->CreateGarbage(5, 1);
+                garbageTarget->CreateGarbage(5, 1);
+                garbageTarget->CreateGarbage(4, 1);
+                break;
+            }
+        for (int i=0;i<30;i++)
+            for (int j=0;j<6;j++)
+                if (garbageToBeCleared[j][i]) {
+                    GarbageClearer(j, i, board[j][i]%1000000, true, chain); //Clears the blocks and all blocks connected to it.
+                }
+
+        chain=0;
+
+        //Break chains (if a block is stable it is resetted to (chain == 0)):
+        for (int i=0;i<7;i++) {
+            bool faaling = false;  //In the beginning we are NOT falling
+            for (int j=0;j<30;j++) {
+                if ((faaling)&&(board[i][j]>-1)&&(board[i][j]<7)) {
+                    board[i][j]+=BLOCKFALL;
+                }
+                if ((!faaling)&&((board[i][j]/BLOCKFALL)%10==1))
+                    board[i][j]-=BLOCKFALL;
+                if ((!faaling)&&(board[i][j]>0)&&(board[i][j]/10000000!=0)&&((board[i][j]/BLOCKWAIT)%10!=1)&&((board[i][j]/BLOCKHANG)%10!=1)) {
+                    if (chainSize[board[i][j]/10000000]>chainSize[chain])
+                        chain=board[i][j]/10000000;
+                    board[i][j]=board[i][j]%10000000;
+                }
+                if (!((board[i][j]>-1)&&(board[i][j]<7)))
+                    faaling=true;
+                if (((board[i][j]/1000000)%10==1)||((board[i][j]/BLOCKHANG)%10==1)||((board[i][j]/BLOCKWAIT)%10==1))
+                    faaling = false;
+            }
+        }
+
+        //Create garbage as a result
+        //if((vsMode)&&(chainSize[chain]>1)) garbageTarget->CreateGarbage(6,chainSize[chain]-1);
+
+        //Calculate chain
+        chain=0;
+        for (int i=0; i<6;i++)
+            for (int j=0; j<30;j++) {
+                if (chainSize[board[i][j]/10000000]>chain)
+                    chain=chainSize[board[i][j]/10000000];
+            }
+
+        //Make space in table for more things
+        if (chain==0)
+            for (int i=0;i<NUMBEROFCHAINS;i++)
+                if (chainUsed[i]==true) {
+                    if ((vsMode)&&(chainSize[i]>1)) garbageTarget->CreateGarbage(6, chainSize[i]-1);
+                    if ((SoundEnabled)&&(chainSize[i]>4))Mix_PlayChannel(1, applause, 0);
+                    if(chainSize[i]>1 && !puzzleMode && !AI_Enabled)
+                        Stats::getInstance()->addOne((string)"chainX"+itoa(chainSize[i]));
+                    chainUsed[i]=false;
+                }
+    } //ClearBlocks
+
+    //prints "Game Over" and ends game
+    void BlockGame::SetGameOver() {
+        if (!bGameOver) {
+        	gameEndedAfter = ticks-gameStartedAt; //We game ends now!
+		if(!AI_Enabled && !bReplaying)
+		{
+			TimeHandler::addTime("playTime",TimeHandler::ms2ct(gameEndedAfter));
+		}
+	}
+        if(bReplaying)
+        {
+            bReplaying = false;
+        }
+        else
+        {
+            strncpy(theReplay.name,name,30);
+        }
+        theReplay.setFinalFrame(getPackage(), 0);
+        bGameOver = true;
+        showGame = false;
+        if(stageClear)
+            stageButtonStatus = SBstageClear;
+    }
+
+    bool BlockGame::GetAIenabled() {
+        return AI_Enabled;
+    }
+
+
+    //Moves all peaces a spot down if possible
+    int BlockGame::FallBlock(int x, int y, int number) {
+        if (y == 0) return -1;
+        if (x>0)
+            if (board[x-1][y] == number)
+                return -1;
+        int i=x;
+        bool canFall = true;
+        //checks a line of a garbage block and see if something is under it
+        while ((board[i][y] == number)&&(canFall)&&(i<6)) {
+            if (board[i][y-1] != -1) canFall = false;
+            i++;
+        }
+        if (canFall) {
+            //cout << "Now falling" << endl;
+            for (int j = x;j<i;j++) {
+                board[j][y-1] = board[j][y];
+                board[j][y] = -1;
+            }
+        }
+        return 0;
+    }	//FallBlock
+
+
+    //Makes all Garbage fall one spot
+    void BlockGame::GarbageFall() {
+        for (int i=0;i<30;i++)
+            for (int j=0;j<7; j++) {
+                if ((((board[j][i]/1000000)%10) == 1)||(((board[j][i]/1000000)%10) == 2))
+                    FallBlock(j, i, board[j][i]);
+            }
+    }
+
+    //Makes the blocks fall (it doesn't test time, this must be done before hand)
+    void BlockGame::FallDown() {
+        bool falling =false;        //nothing is moving unless proven otherwise
+        for (int i=0;i<29;i++)
+            for (int j=0;j<6;j++) {
+                if ((board[j][i]==-1) && (board[j][i+1]!=-1) && (board[j][i+1]%BLOCKFALL<7)) {
+                    board[j][i] = board[j][i+1];
+                    board[j][i+1] = -1;
+                    falling = true;              //something is moving!
+                }
+                if ((board[j][i]/BLOCKWAIT)%10==1)
+                    falling=true;
+            }
+        if (!falling) //If nothing is falling
+        {
+            if ((puzzleMode)&&(!bGameOver)&&(MovesLeft==0)&&(!(BoardEmpty()))) {
+                //Puzzle not won
+                SetGameOver();
+                stageButtonStatus = SBpuzzleMode;
+            }
+        }
+        GarbageFall();		//Makes the garbage fall
+        nrFellDown++;      //Sets number of this fall, so we know then the next will occur
+    }
+
+    //Moves the cursor, receaves N,S,E or W as a char an moves as desired
+    void BlockGame::MoveCursor(char way) {
+        if (!bGameOver)       //If game over nothing happends
+        {
+            if ((way == 'N') && ((cursory<10)||(TowerHeight>12) ||(((pixels==bsize)||(pixels==0)) && (cursory<11))))
+                cursory++;
+            if ((way == 'S') && (cursory>0))
+                cursory--;
+            if ((way == 'W') && (cursorx>0))
+                cursorx--;
+            if ((way == 'E') && (cursorx<4))
+                cursorx++;
+        }
+    }
+
+    //switches the two blocks at the cursor position, unless game over
+    void BlockGame::SwitchAtCursor() {
+        if ((board[cursorx][cursory+1]<7) && (board[cursorx+1][cursory+1]<7) && (!bGameOver) && ((!puzzleMode)||(MovesLeft>0)) && (gameStartedAt<ticks)) {
+            int temp = board[cursorx][cursory+1];
+            board[cursorx][cursory+1] = board[cursorx+1][cursory+1];
+            board[cursorx+1][cursory+1] = temp;
+        }
+        if ((puzzleMode)&&(gameStartedAt<ticks)&&(MovesLeft>0)) MovesLeft--;
+    }
+
+    //Generates a new line and moves the field one block up (restart puzzle mode)
+    void BlockGame::PushLine() {
+        //If not game over, not high tower and not puzzle mode
+        if ((!bGameOver) && TowerHeight<13 && (!puzzleMode) && (gameStartedAt<ticks)&&(chain==0)) {
+            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] = rand2() % 4;
+                if (j > 0) {
+                    if (board[j][0] == board[j-1][0])
+                        board[j][0] = rand2() % 6;
+                }
+                if (board[j][0] == board[j][1])
+                    board[j][0] = rand2() % 6;
+                if (board[j][0] == board[j][1])
+                    board[j][0] = rand2() % 6;
+                while ((j>0)&&(board[j][0]==board[j-1][0]))
+                    board[j][0] = rand2() % 6;
+            }
+            score+=1;
+            MoveCursor('N');
+            if (vsMode) {
+                if (rand2()%6==1)
+                    board[rand2()%6][0]=6;
+            }
+            pixels = 0;
+            stop=0;
+            pushedPixelAt = ticks;
+            linesCleared++;
+            AI_LineOffset++;
+            nrPushedPixel=(int)((double)(pushedPixelAt-gameStartedAt)/(1000.0*speed));
+
+            if(!AI_Enabled && !bReplaying)
+            {
+                Stats::getInstance()->addOne("linesPushed");
+            }
+        } //if !bGameOver
+
+        //Restart Puzzle mode
+        if (puzzleMode && !bGameOver) {
+            //Reloads 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];
+                }
+            score=0;
+            bGameOver=false;
+            showGame = true;
+        }
+
+        if ((TowerHeight>12) && (!puzzleMode)&&(!bGameOver)&&(chain==0)) {
+            if ((!vsMode)&&(theTopScoresEndless.isHighScore(score))&&(!AI_Enabled)) {
+                if (SoundEnabled)Mix_PlayChannel(1, applause, 0);
+                theTopScoresEndless.addScore(name, score);
+                cout << "New high score!" << endl;
+            }
+            SetGameOver();
+        }
+
+
+    }//PushLine
+
+    //Pushes a single pixel, so it appears to scrool
+    void BlockGame::PushPixels() {
+        nrPushedPixel++;
+        if ((pixels < bsize) && TowerHeight<13) {
+            pixels++;
+        }
+        else
+            PushLine();
+        if (pixels>bsize)
+            pixels=0;
+    }
+
+
+    //See how high the tower is, saved in integer TowerHeight
+    void BlockGame::FindTowerHeight() {
+        /*
+         * Old implementation, used until I find the bug in the other.
+         * This function has a bug in stage clear! if an empty line appears.
+         */
+        prevTowerHeight = TowerHeight;
+        bool found = false;
+        TowerHeight = 0;
+        while (!found) {
+            found = true;
+            for (int j=0;j<6;j++)
+                if (board[j][TowerHeight] != -1)
+                    found = false;
+            TowerHeight++;
+        }
+        TowerHeight--;
+    }
+
+///////////////////////////////////////////////////////////////////////////
+/////////////////////////// AI starts here! ///////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+    //First the helpet functions:
+    int BlockGame::nrOfType(int line, int type) {
+        // cout << "Start_ nrOfType" << endl;
+        int counter = 0;
+        for (int i=0; i<6; i++)
+            if (board[i][line]==type)counter++;
+        return counter;
+    }
+
+
+    //See if a combo can be made in this line
+    int BlockGame::horiInLine(int line) {
+        //cout << "Start_ hori in line" << endl;
+        int nrOfType[7] = {0, 0, 0, 0, 0, 0, 0};
+        int iTemp;
+        int max = 0;
+        for (int i=0; i<6; i++) {
+            iTemp = board[i][line];
+            if ((iTemp>-1)&&(iTemp<7))
+                nrOfType[iTemp]++;
+        }
+        for (int j=0; j<7; j++) {
+            if (nrOfType[j]>max) {
+                max = nrOfType[j];
+                AIcolorToClear = j;
+            }
+        }
+        return max;
+    }
+
+    bool BlockGame::horiClearPossible() {
+        //cout << "Start_ horiclear possible" << endl;
+        int i=13;
+        bool solutionFound = false;
+        do{
+            if (horiInLine(i)>2) {
+                AI_LineOffset = 0;
+                AIlineToClear = i;
+                solutionFound = true;
+            }
+            i--;
+        }while ((!solutionFound)&&(i>0));
+        return solutionFound;
+    }
+
+    //the Line Has Unmoveable Objects witch might stall the AI
+    bool BlockGame::lineHasGarbage(int line) {
+        for (int i=0;i<6;i++)
+            if (board[i][line]>1000000)
+                return true;
+        return false;
+    }
+
+    //Types 0..6 in line
+    int BlockGame::nrOfRealTypes(int line) {
+        //cout << "Start_ nrOfReal" << endl;
+        int counter = 0;
+        for (int i=0; i<6; i++)
+            if ((board[i][line]>-1)&&(board[i][line]<7))counter++;
+        return counter;
+    }
+
+    //See if there is a tower
+    bool BlockGame::ThereIsATower() {
+        //cout << "Start_ there is a tower" << endl;
+        bool bThereIsATower = false; //Unless proven otherwise!
+        bool topReached = false; //If we have reached the top
+        int lineNumber = 0;
+        bool emptySpacesFound = false;
+        do {
+            if ((emptySpacesFound) && (nrOfRealTypes(lineNumber)>0)&&(nrOfType(lineNumber, -1)>0)) {
+                AIlineToClear = lineNumber;
+                if (lineHasGarbage(lineNumber))
+                    return false;
+                else
+                    bThereIsATower = true;
+            }
+            else
+                emptySpacesFound=false;
+            if ((!emptySpacesFound)&&(nrOfType(lineNumber, -1)>0))
+                emptySpacesFound = true;
+            if (lineNumber<12)
+                lineNumber++;
+            else
+                topReached = true;
+        }while ((!bThereIsATower)&&(!topReached));
+        //if(bThereIsATower)
+        //cout << "There is actually a tower" << endl;
+        return bThereIsATower;
+    }
+
+    double BlockGame::firstInLine1(int line) {
+        for (int i=0;i<6;i++)
+            if ((board[i][line]>-1)&&(board[i][line]<7))
+                return (double)i;
+        return 3.0;
+    }
+
+    //returns the first coordinate of the block of type
+    double BlockGame::firstInLine(int line, int type) {
+        for (int i=0;i<6;i++)
+            if (board[i][line]==type)
+                return (double)i;
+        return 3.0;
+    }
+
+    //There in the line shall we move
+    int BlockGame::closestTo(int line, int place) {
+        if ((int)firstInLine1(line)>place)
+            return (int)firstInLine1(line)-1;
+        for (int i=place;i>=0;i--) {
+            if ((board[i][line]>-1)&&(board[i][line]<7))
+                return i;
+        }
+        AIstatus=0;
+        return place;
+    }
+
+    //The AI will remove a tower
+    void BlockGame::AI_ClearTower() {
+        //   cout << "AI: ClearTower, line: " << AIlineToClear << endl;
+        int place = (int)firstInLine(AIlineToClear-1, -1); //Find an empty field to frop a brick into
+        int xplace = closestTo(AIlineToClear, place); //Find the brick to drop in it
+        if (cursory+1<AIlineToClear)
+            MoveCursor('N');
+        else
+            if (cursory+1>AIlineToClear)
+                MoveCursor('S');
+            else
+                if (cursorx<xplace)
+                    MoveCursor('E');
+                else
+                    if (cursorx>xplace)
+                        MoveCursor('W');
+                    else
+                        SwitchAtCursor();
+        if (!ThereIsATower())
+            AIstatus = 0;
+    }
+
+    //The AI will try to clear block horisontally
+    void BlockGame::AI_ClearHori() {
+        //   cout << "AI: ClearHori";
+        int lowestLine = AIlineToClear;
+        //AIcolorToClear
+        bool found =true;
+        /*for(int i; (i<12)&&(!found);i++)
+         * {
+         * if(horiInLine(i)>2)
+         * {
+         * int lowestLine = i;
+         * found = true;
+         * }
+         * }*/
+        for (int i=0;i<7;i++) {
+            if (nrOfType(lowestLine, i)>2)
+                AIcolorToClear = i;
+        }
+        if (found) {
+            if (cursory>lowestLine-1)
+                MoveCursor('S');
+            else if (cursory<lowestLine-1)
+                MoveCursor('N');
+            else if (nrOfType(lowestLine, AIcolorToClear)>2) {
+                int left=0, right=0;
+                if (board[0][lowestLine]==AIcolorToClear) left++;
+                if (board[1][lowestLine]==AIcolorToClear) left++;
+                if (board[2][lowestLine]==AIcolorToClear) left++;
+                if (board[3][lowestLine]==AIcolorToClear) right++;
+                if (board[4][lowestLine]==AIcolorToClear) right++;
+                if (board[5][lowestLine]==AIcolorToClear) right++;
+                int xplace = 0;
+                if (left<right) {
+                    //   cout << ", right>left";
+                    int count=0;
+                    for (int i=0;(i<4)&&(count<1);i++)
+                        if ((board[i][lowestLine]==AIcolorToClear)&&((i==0)||(board[i+1][lowestLine]!=AIcolorToClear))) {
+                            count++;
+                            xplace = i;
+                        }
+                }
+                else {
+                    //   cout << ", left>=right";
+                    int count=0;
+                    for (int i=3;(i<=5)&&(count<1);i++)
+                        if ((board[i][lowestLine]==AIcolorToClear)&&(board[i-1][lowestLine]!=AIcolorToClear)) {
+                            count++;
+                            xplace = --i;
+                        }
+                }
+                //cout << ", xplace: " << xplace;
+                if (cursorx<xplace)
+                    MoveCursor('E');
+                else
+                    if (cursorx>xplace)
+                        MoveCursor('W');
+                    else
+                        if (cursorx==xplace)
+                            SwitchAtCursor();
+                        else
+                            AIstatus = 0;
+            }
+            else
+                AIstatus = 0;
+        }
+        else
+            AIstatus = 0;
+        //cout << endl; //for debugging
+    }
+
+    //Test if vertical clear is possible
+    bool BlockGame::veriClearPossible() {
+        bool found=false;
+        int colors[7] = {0, 0, 0, 0, 0, 0, 0};
+        for (int i=12;(i>0)&&(!found);i--) {
+            for (int j=0;j<7;j++) {
+                if (nrOfType(i, j)==0)
+                    colors[j]=0;
+                else
+                    if (++colors[j]>2) {
+                        AIcolorToClear = j;
+                        AIlineToClear = i;
+                        found=true;
+                    }
+
+            }
+        }
+        return found;
+    }
+
+
+
+    //There in the line shall we move
+    int BlockGame::closestTo(int line, int type, int place) {
+        if ((int)firstInLine(line, type)>place)
+            return (int)firstInLine(line, type)-1;
+        for (int i=place;i>=0;i--) {
+            if (board[i][line]==type)
+                return i;
+        }
+        AIstatus=0;
+        return place;
+    }
+
+    //The AI will try to clear blocks vertically
+    void BlockGame::AI_ClearVertical() {
+        // cout << "AI: ClearVeri";
+        //First we find the place there we will align the bricks
+        int placeToCenter = (int)(firstInLine(AIlineToClear, AIcolorToClear)/3.0+firstInLine(AIlineToClear+1, AIcolorToClear)/3.0+firstInLine(AIlineToClear+2, AIcolorToClear)/3.0);
+        int unlimitedLoop=0;
+        while (((board[placeToCenter][AIlineToClear]>1000000)||(board[placeToCenter][AIlineToClear+1]>1000000)||(board[placeToCenter][AIlineToClear+2]>1000000))&&(unlimitedLoop<10)) {
+            unlimitedLoop++;
+            placeToCenter++;
+            if (placeToCenter>5)
+                placeToCenter=0;
+        }
+        if(unlimitedLoop>9) {
+            AIstatus = 0;
+        }
+        //cout << ", ptc: " << placeToCenter << ", line: " << AIlineToClear << ", cy: " << cursory;
+        if (cursory+1>AIlineToClear+2) {
+            // cout << ", cursory>line+2";
+            MoveCursor('S');
+        }
+        if (cursory+1<AIlineToClear)
+            MoveCursor('N');
+        bool toAlign[3]={true, true, true};
+        if (board[placeToCenter][AIlineToClear+0]==AIcolorToClear)
+            toAlign[0]=false;
+        if (board[placeToCenter][AIlineToClear+1]==AIcolorToClear)
+            toAlign[1]=false;
+        if (board[placeToCenter][AIlineToClear+2]==AIcolorToClear)
+            toAlign[2]=false;
+        //cout << "status: " << toAlign[0] << " " << toAlign[1] << " " << toAlign[2];
+        if (cursory+1==AIlineToClear) {
+            if (toAlign[0]==false)
+                MoveCursor('N');
+            else {
+                if (cursorx>closestTo(AIlineToClear, AIcolorToClear, placeToCenter))
+                    MoveCursor('W');
+                else
+                    if (cursorx<closestTo(AIlineToClear, AIcolorToClear, placeToCenter))
+                        MoveCursor('E');
+                    else
+                        SwitchAtCursor();
+            }
+        }
+        else
+            if (cursory+1==AIlineToClear+1) {
+                if (toAlign[1]==false) {
+                    if (toAlign[2])
+                        MoveCursor('N');
+                    else
+                        MoveCursor('S');
+                }
+                else {
+                    if (cursorx>closestTo(AIlineToClear+1, AIcolorToClear, placeToCenter))
+                        MoveCursor('W');
+                    else
+                        if (cursorx<closestTo(AIlineToClear+1, AIcolorToClear, placeToCenter))
+                            MoveCursor('E');
+                        else
+                            SwitchAtCursor();
+                }
+            }
+            else
+                if (cursory+1==AIlineToClear+2) {
+                    if (toAlign[2]==false)
+                        MoveCursor('S');
+                    else {
+                        if (cursorx>closestTo(AIlineToClear+2, AIcolorToClear, placeToCenter))
+                            MoveCursor('W');
+                        else
+                            if (cursorx<closestTo(AIlineToClear+2, AIcolorToClear, placeToCenter))
+                                MoveCursor('E');
+                            else
+                                SwitchAtCursor();
+                    }
+                }
+
+        if ((!toAlign[0])&&(!toAlign[1])&&(!toAlign[2]))
+            AIstatus = 0;
+        if ((nrOfType(AIlineToClear, AIcolorToClear)==0)||(nrOfType(AIlineToClear+1, AIcolorToClear)==0)||(nrOfType(AIlineToClear+2, AIcolorToClear)==0))
+            AIstatus = 0;
+        //cout << endl;
+    }
+
+
+    void BlockGame::AI_Move() {
+        switch (AIstatus) {
+        case 1:
+            if (TowerHeight<8)PushLine();
+            else AIstatus = 0;
+            break;
+        case 2:
+            AI_ClearTower();
+            break;
+        case 3:
+            AI_ClearHori();
+            break;
+        case 4:
+            AI_ClearVertical();
+            break;
+        case 5:
+            if (!firstLineCreated){
+                PushLine();
+                firstLineCreated = true;
+            }
+            else {
+                PushLine();
+                AIstatus = 0;
+            }
+            break;
+        case 6:
+            PushLine();
+            AIstatus = 0;
+            break;
+        default:
+            if (TowerHeight<6) AIstatus = 1;
+            else
+                if (horiClearPossible()) AIstatus = 3;
+                else
+                    if (veriClearPossible()) AIstatus = 4;
+                    else
+                        if (ThereIsATower()) AIstatus = 2;
+                        else
+                            AIstatus = 5;
+            break;
+        }
+    }
+
+//////////////////////////////////////////////////////////////////////////
+///////////////////////////// AI ends here! //////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+#if WITH_SDL
+    //Draws all the bricks to the board (including garbage)
+    void BlockGame::PaintBricks() {
+        for (int i=0;((i<13)&&(i<30));i++)
+            for (int j=0;j<6;j++) {
+                if ((board[j][i]%10 != -1) && (board[j][i]%10 < 7) && ((board[j][i]/1000000)%10==0)) {
+                    DrawIMG(bricks[board[j][i]%10], sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((board[j][i]/BLOCKWAIT)%10==1)
+                        DrawIMG(bomb[(ticks/BOMBTIME)%2], sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((board[j][i]/BLOCKHANG)%10==1)
+                        DrawIMG(ready[(ticks/READYTIME)%2], sBoard, j*bsize, bsize*12-i*bsize-pixels);
+
+                }
+                if ((board[j][i]/1000000)%10==1) {
+                    int left, right, over, under;
+                    int number = board[j][i];
+                    if (j<1) left = -1;
+                    else left = board[j-1][i];
+                    if (j>5) right = -1;
+                    else right = board[j+1][i];
+                    if (i>28) over = -1;
+                    else over = board[j][i+1];
+                    if (i<1) under = -1;
+                    else under = board[j][i-1];
+                    if ((left == number)&&(right == number)&&(over == number)&&(under == number))
+                        DrawIMG(garbageFill, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left != number)&&(right == number)&&(over == number)&&(under == number))
+                        DrawIMG(garbageL, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left == number)&&(right != number)&&(over == number)&&(under == number))
+                        DrawIMG(garbageR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left == number)&&(right == number)&&(over != number)&&(under == number))
+                        DrawIMG(garbageT, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left == number)&&(right == number)&&(over == number)&&(under != number))
+                        DrawIMG(garbageB, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left != number)&&(right == number)&&(over != number)&&(under == number))
+                        DrawIMG(garbageTL, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left != number)&&(right == number)&&(over == number)&&(under != number))
+                        DrawIMG(garbageBL, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left == number)&&(right != number)&&(over != number)&&(under == number))
+                        DrawIMG(garbageTR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left == number)&&(right != number)&&(over == number)&&(under != number))
+                        DrawIMG(garbageBR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left == number)&&(right != number)&&(over != number)&&(under != number))
+                        DrawIMG(garbageMR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left == number)&&(right == number)&&(over != number)&&(under != number))
+                        DrawIMG(garbageM, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    if ((left != number)&&(right == number)&&(over != number)&&(under != number))
+                        DrawIMG(garbageML, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                }
+                if ((board[j][i]/1000000)%10==2) {
+                    if (j==0)
+                        DrawIMG(garbageGML, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                    else
+                        if (j==5)
+                            DrawIMG(garbageGMR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                        else
+                            DrawIMG(garbageGM, sBoard, j*bsize, bsize*12-i*bsize-pixels);
+                }
+            }
+        const int j = 0;
+
+        int garbageSize=0;
+        for (int i=0;i<20;i++) {
+            if ((board[j][i]/1000000)%10==1) {
+                int left, right, over, under;
+                int number = board[j][i];
+                if (j<1) left = -1;
+                else left = board[j-1][i];
+                if (j>5) right = -1;
+                else right = board[j+1][i];
+                if (i>28) over = -1;
+                else over = board[j][i+1];
+                if (i<1) under = -1;
+                else under = board[j][i-1];
+                if (((left != number)&&(right == number)&&(over != number)&&(under == number))&&(garbageSize>0)) {
+                    DrawIMG(smiley[board[j][i]%4], sBoard, 2*bsize, 12*bsize-i*bsize-pixels+(bsize/2)*garbageSize);
+                }
+                if (!((left != number)&&(right == number)&&(over == number)&&(under == number))) //not in garbage
+                {
+                    garbageSize=0;
+                }
+                else {
+                    //cout << "In garbage" << endl;
+                    garbageSize++;
+                }
+
+            }
+        }
+        for (int i=0;i<6;i++)
+            if (board[i][0]!=-1)
+                DrawIMG(transCover, sBoard, i*bsize, 12*bsize-pixels); //Make the appering blocks transperant
+
+    }
+
+    //Paints the bricks gotten from a replay/net package
+    void BlockGame::SimplePaintBricks() {
+        /*
+         * We will need to mark the blocks that must have a bomb, we will here need to see, what is falling
+         */
+        bool bbomb[6][13]; //has a bomb on it!
+        bool falling[6][13]; //this is falling
+        bool getReady[6][13]; //getReady
+        for (int i=0;i<6;i++)
+            for (int j=0;j<13;j++) {
+                bbomb[i][j]=false; //All false by default
+                falling[i][j]=false;
+                if (board[i][j]>29)
+                    getReady[i][j]=true;
+                else
+                    getReady[i][j]=false;
+            }
+        //See that is falling
+        for (int i=0;i<6;i++) {
+            bool rowFalling = false;
+            for (int j=0;j<13;j++) {
+                if (rowFalling)
+                    falling[i][j]=true;
+                if ((!rowFalling)&&(board[i][j]%30==-1))
+                    rowFalling = true;
+                if ((rowFalling)&&(board[i][j]%30>6))
+                    rowFalling = false;
+                if (getReady[i][j]) {
+                    falling[i][j]=true; //getReady is the same as falling
+                    rowFalling = false;
+                }
+            }
+        }
+        //Now looking at rows:
+        for (int i=0;i<6;i++) {
+            int count = 0;
+            int color = -1;
+            for (int j=1;j<13;j++) {
+                if ((board[i][j]%30==color)&&(!falling[i][j]))
+                    count++;
+                else
+                    if (falling[i][j]) {
+                        count = 0;
+                    }
+                    else {
+                        color=board[i][j]%30;
+                        count=1;
+                    }
+                if ((count>2)&&(color>-1)&&(color)<7) {
+                    bbomb[i][j]=true;
+                    bbomb[i][j-1]=true;
+                    bbomb[i][j-2]=true;
+                }
+            }
+        }
+        //now looking for lines
+        for (int i=1;i<13;i++) {
+            int count = 0;
+            int color = -1;
+            for (int j=0;j<6;j++) {
+                if ((board[j][i]%30==color)&&(!falling[j][i]))
+                    count++;
+                else
+                    if (falling[j][i]) {
+                        count = 0;
+                    }
+                    else {
+                        color=board[j][i]%30;
+                        count=1;
+                    }
+                if ((count>2)&&(color>-1)&&(color<7)) {
+                    bbomb[j][i]=true;
+                    bbomb[j-1][i]=true;
+                    bbomb[j-2][i]=true;
+                }
+            }
+        }
+        for (int i=0;((i<13)&&(i<30));i++)
+            for (int j=0;j<6;j++) {
+                if ((board[j][i]%10 != -1) && (board[j][i]%30 < 7)) {
+                    DrawIMG(bricks[board[j][i]%10], sBoard, j*bsize, 12*bsize-i*bsize-pixels);
+                    if (bbomb[j][i])
+                        DrawIMG(bomb[(ticks/BOMBTIME)%2], sBoard, j*bsize, 12*bsize-i*bsize-pixels);
+                    if (getReady[j][i])
+                        DrawIMG(ready[(ticks/READYTIME)%2], sBoard, j*bsize, 12*bsize-i*bsize-pixels);
+                }
+                if (board[j][i]%30>6) {
+                    if (board[j][i]%30==7)
+                        DrawIMG(garbageR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==9)
+                        DrawIMG(garbageML, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==10)
+                        DrawIMG(garbageMR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==11)
+                        DrawIMG(garbageTR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==12)
+                        DrawIMG(garbageTL, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==13)
+                        DrawIMG(garbageBL, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==14)
+                        DrawIMG(garbageBR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==15)
+                        DrawIMG(garbageM, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==16)
+                        DrawIMG(garbageFill, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==17)
+                        DrawIMG(garbageT, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==18)
+                        DrawIMG(garbageB, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==19)
+                        DrawIMG(garbageL, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
+                    if (board[j][i]%30==20)
+                        switch(j) {
+                            case 0:
+                                DrawIMG(garbageGML, sBoard,j*bsize, 12*bsize-i*bsize-pixels);
+                                break;
+                            case 5:
+                                DrawIMG(garbageGMR, sBoard,j*bsize, 12*bsize-i*bsize-pixels);
+                                break;
+                            default:
+                                DrawIMG(garbageGM, sBoard,j*bsize, 12*bsize-i*bsize-pixels);
+                        }
+                    //cout << "IS: " << board[j][i] << endl;
+                }
+
+
+            }
+
+        int garbageSize=0;
+        for (int i=0;i<20;i++) {
+            if ((board[0][i]%30==12)&&(garbageSize>0)) {
+                DrawIMG(smiley[0], sBoard, 2*bsize, bsize-i*bsize-pixels+(bsize/2)*garbageSize);
+            }
+            if (board[0][i]%30!=19) //not in garbage
+            {
+                garbageSize=0;
+            }
+            else {
+                //cout << "In garbage" << endl;
+                garbageSize++;
+            }
+
+        }
+    }
+
+    //Draws everything
+    void BlockGame::DoPaintJob() {
+        DrawIMG(backBoard, sBoard, 0, 0);
+        #if NETWORK
+        if ((!bReplaying)&&(!bNetworkPlayer))
+        #else
+        if (!bReplaying)
+        #endif
+            PaintBricks();
+        else
+            SimplePaintBricks();
+        if (stageClear) DrawIMG(blackLine, sBoard, 0, bsize*(12+2)+bsize*(stageClearLimit-linesCleared)-pixels-1);
+        if (puzzleMode&&(!bGameOver)) {
+            //We need to write nr. of moves left!
+            strHolder = "Moves left: " + itoa(MovesLeft);
+            SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
+        }
+        if(puzzleMode && stageButtonStatus == SBpuzzleMode)
+        {
+            DrawIMG(bRetry,sBoard, cordRetryButton.x, cordRetryButton.y);
+            if(Level<nrOfPuzzles-1)
+            {
+                if(hasWonTheGame)
+                    DrawIMG(bNext,sBoard,cordNextButton.x, cordNextButton.y);
+                else
+                    DrawIMG(bSkip,sBoard,cordNextButton.x, cordNextButton.y);
+            }
+            else
+            {
+                strHolder = "Last puzzle";
+                SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
+            }
+        }
+        if(stageClear && stageButtonStatus == SBstageClear)
+        {
+            DrawIMG(bRetry,sBoard, cordRetryButton.x, cordRetryButton.y);
+            if(Level<50-1)
+            {
+                if(hasWonTheGame)
+                    DrawIMG(bNext,sBoard,cordNextButton.x, cordNextButton.y);
+                else
+                    DrawIMG(bSkip,sBoard,cordNextButton.x, cordNextButton.y);
+            }
+            else
+            {
+                strHolder = "Last stage";
+                SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
+            }
+        }
+
+#if DEBUG
+        if (AI_Enabled&&(!bGameOver)) {
+            strHolder = "AI_status: " + itoa(AIstatus)+ ", "+ itoa(AIlineToClear);
+            SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
+        }
+#endif
+        if (!bGameOver)DrawIMG(cursor[(ticks/600)%2],sBoard,cursorx*bsize-4,11*bsize-cursory*bsize-pixels-4);
+        if (ticks<gameStartedAt)
+        {
+            int currentCounter = abs((int)ticks-(int)gameStartedAt)/1000;
+            if( (currentCounter!=lastCounter) && (SoundEnabled)&&(!NoSound))
+                Mix_PlayChannel(1,counterChunk,0);
+            lastCounter = currentCounter;
+            switch (currentCounter) {
+            case 2:
+                DrawIMG(counter[2], sBoard, 2*bsize, 5*bsize);
+                break;
+            case 1:
+                DrawIMG(counter[1], sBoard, 2*bsize, 5*bsize);
+                break;
+            case 0:
+                DrawIMG(counter[0], sBoard, 2*bsize, 5*bsize);
+                break;
+            default:
+                break;
+            }
+        }
+        else
+        {
+            if(SoundEnabled&&(!NoSound)&&(timetrial)&&(ticks>gameStartedAt+10000)&&(!bGameOver))
+            {
+                int currentCounter = (ticks-(int)gameStartedAt)/1000;
+                if(currentCounter!=lastCounter)
+                {
+                    if(currentCounter>115 && currentCounter<120)
+                        Mix_PlayChannel(1,counterChunk,0);
+                }
+                lastCounter = currentCounter;
+            }
+            else
+            {
+                if( (0==lastCounter) && (SoundEnabled)&&(!NoSound))
+                {
+                    Mix_PlayChannel(1,counterFinalChunk,0);
+                }
+                lastCounter = -1;
+            }
+        }
+
+        if ((bGameOver)&&(!editorMode))
+            if (hasWonTheGame)DrawIMG(iWinner, sBoard, 0, 5*bsize);
+            else if (bDraw) DrawIMG(iDraw, sBoard, 0, 5*bsize);
+            else
+                DrawIMG(iGameOver, sBoard, 0, 5*bsize);
+    }
+
+    #endif
+
+    //Updates evrything, if not called nothing happends
+    void BlockGame::Update() {
+        Uint32 tempUInt32;
+        Uint32 nowTime = ticks; //We remember the time, so it doesn't change during this call
+        if (bReplaying) {
+            setBoard(theReplay.getFrameSec((Uint32)(nowTime-gameStartedAt)));
+            strncpy(name,theReplay.name,30);
+            if (theReplay.isFinnished((Uint32)(nowTime-gameStartedAt)))
+                switch (theReplay.getFinalStatus()) {
+                case 1: //Winner
+                    bGameOver = true;
+                    hasWonTheGame = true;
+                    break;
+                case 2: //Looser
+                case 4: //GameOver
+                    bGameOver = true;
+                    break;
+                case 3: //draw
+                    bGameOver =true;
+                    bDraw = true;
+                    break;
+                default:
+                    bGameOver = true;
+                    //Nothing
+                    break;
+                };
+        }
+        #if NETWORK
+        if ((!bReplaying)&&(!bNetworkPlayer)) {
+        #else
+            if (!bReplaying) {
+        #endif
+            FindTowerHeight();
+            if ((linesCleared-TowerHeight>stageClearLimit) && (stageClear) && (!bGameOver)) {
+                stageCleared[Level] = true;
+                if(stageScores[Level]<score)
+                {
+                    gameEndedAfter = nowTime-gameStartedAt;
+                    stageScores[Level] = score;
+                    stageTimes[Level] = gameEndedAfter;
+                }
+
+                ofstream outfile;
+                outfile.open(stageClearSavePath.c_str(), ios::binary |ios::trunc);
+                if (!outfile) {
+                    cout << "Error writing to file: " << stageClearSavePath << endl;
+                }
+                else {
+                    for (int i=0;i<nrOfStageLevels;i++) {
+                        bool tempBool = stageCleared[i];
+                        outfile.write(reinterpret_cast<char*>(&tempBool), sizeof(bool));
+                    }
+                    for (int i=0;i<nrOfStageLevels;i++) {
+                        tempUInt32 = stageScores[i];
+                        outfile.write(reinterpret_cast<char*>(&tempUInt32), sizeof(Uint32));
+                    }
+                    for (int i=0;i<nrOfStageLevels;i++) {
+                        tempUInt32 = stageTimes[i];
+                        outfile.write(reinterpret_cast<char*>(&tempUInt32), sizeof(Uint32));
+                    }
+                    outfile.close();
+                }
+                setPlayerWon();
+                stageButtonStatus = SBstageClear;
+            }
+            if ((TowerHeight>12)&&(prevTowerHeight<13)&&(!puzzleMode)) {
+                //if (SoundEnabled) Mix_PlayChannel(1, heartBeat, 0);
+                stop+=1000;
+            }
+
+            if ((TowerHeight>12)&&(!puzzleMode)&&(!bGameOver)) {
+                bNearDeath = true;
+            }
+
+            while (nowTime>nrStops*40+gameStartedAt) //Increase stops, till we reach nowTime
+            {
+                if (stop>0) {
+                    stop = stop-20;
+                    if (stop<=0) nrPushedPixel=(int)((nowTime-gameStartedAt)/(1000.0*speed));
+                }
+                if (stop<0)
+                    stop = 0;
+                nrStops++;
+            }
+            //If we have static content, we don't raise at all!
+            if (hasStaticContent())
+                stop++;
+            if ((puzzleMode)&&(!bGameOver)&&BoardEmpty()) {
+                if (!singlePuzzle) {
+                    if(puzzleCleared[Level]==false)
+                        Stats::getInstance()->addOne("puzzlesSolved");
+                    puzzleCleared[Level] = true;
+                    ofstream outfile;
+                    stageButtonStatus = SBpuzzleMode;
+                    outfile.open(puzzleSavePath.c_str(), ios::binary |ios::trunc);
+                    if (!outfile) {
+                        cout << "Error writing to file: " << puzzleSavePath << endl;
+                    }
+                    else {
+                        for (int i=0;i<nrOfPuzzles;i++) {
+                            bool tempBool = puzzleCleared[i];
+                            outfile.write(reinterpret_cast<char*>(&tempBool), sizeof(bool));
+                        }
+                        outfile.close();
+                    }
+                }
+                setPlayerWon();
+            }
+
+            //increse speed:
+            if ((nowTime>gameStartedAt+20000*speedLevel)&&(speedLevel <99)&&(!bGameOver))
+            {
+                speed = (baseSpeed*0.9)/((double)speedLevel*0.5);
+                speedLevel++;
+                nrPushedPixel=(int)((double)(nowTime-gameStartedAt)/(1000.0*speed));
+            }
+
+
+            //To prevent the stack from raising a lot then we stop a chain (doesn't work anymore)
+            if (chain>0)
+                stop+=1;
+            //Raises the stack
+            if ((nowTime>gameStartedAt+nrPushedPixel*1000*speed) && (!bGameOver)&&(!stop))
+                while ((nowTime>gameStartedAt+nrPushedPixel*1000*speed)&&(!(puzzleMode)))
+                    PushPixels();
+            if (!bGameOver)ClearBlocks();
+
+            /*************************************************************
+            Ai stuff
+             **************************************************************/
+            if (bGameOver) {
+                AIstatus = 0;       //Enusres that AI is resetted
+            }
+            else
+                if (AI_Enabled)
+                    if (lastAImove+AI_MoveSpeed<ticks) {
+                        AI_Move();
+                        lastAImove=ticks;
+                    }
+
+            /*************************************************************
+            Ai stuff ended
+             **************************************************************/
+            if ((nowTime>gameStartedAt+nrFellDown*140) && (!bGameOver)) FallDown();
+            if ((nowTime<gameStartedAt)&&(puzzleMode)) {
+                FallDown();
+                nrFellDown--;
+            }
+            ReduceStuff();
+            if ((timetrial) && (!bGameOver) && (nowTime>gameStartedAt+2*60*1000)) {
+                SetGameOver();
+                if(!NoSound && SoundEnabled)Mix_PlayChannel(1,counterFinalChunk,0);
+                if ((theTopScoresTimeTrial.isHighScore(score))&&(!AI_Enabled)) {
+                    theTopScoresTimeTrial.addScore(name, score);
+                    //new highscore
+                    //Also check if it is better than the best result so far.
+                    string checkFilename = getPathToSaveFiles() + "/bestTTresult";
+                    ifstream inFile(checkFilename.c_str());
+                    Uint32 bestResult = 3000; //Never accept a best result under 3000
+                    if(inFile)
+                    {
+                        inFile >> bestResult;
+                        inFile.close();
+                    }
+                    if(score>bestResult)
+                    {
+                        string bestFile = getPathToSaveFiles() + "/bestTT";
+                        theReplay.saveReplay(bestFile);
+                        ofstream outFile(checkFilename.c_str(),ios::trunc);
+                        if(outFile)
+                            outFile << score;
+                    }
+                }
+            }
+        }
+        if ((!bGameOver)&&(!bReplaying)&&(nowTime>gameStartedAt))
+        {
+            //cout << nowTime << " bigger than " << gameStartedAt << endl;
+            theReplay.setFrameSecTo(nowTime-gameStartedAt, getPackage());
+        }
+        DoPaintJob();
+    }
+
+    void BlockGame::Update(int newtick) {
+        ticks = newtick;
+        Update();
+    }
+////////////////////////////////////////////////////////////////////////////////
+///////////////////////// BlockAttack class end ////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
diff --git a/source/code/BlockGame.hpp b/source/code/BlockGame.hpp
index 7187c71..b60c9cb 100644
--- a/source/code/BlockGame.hpp
+++ b/source/code/BlockGame.hpp
@@ -23,10 +23,28 @@
  * blockattack@poulsander.com
  */
 
+#ifndef BLOCKGAME_HPP
+#define BLOCKGAME_HPP 1
+
 #include "stats.h"
 #include "common.h"
-#include "mainVars.hpp"
-
+#include "SDL.h"
+#include "replay.h"
+
+#define WITH_SDL 1
+
+//Some definitions
+//The game is divided in frames. FALLTIME means the blocks will fall one block every FRAMELENGTH*FALLTIME millisecond
+#define FRAMELENGTH 50
+#define HANGTIME 40
+#define FALLTIME 20
+//Don't change the following, they are fundamental and later some functions are hardcoded
+#define BLOCKFALL 10000
+#define BLOCKWAIT 100000
+#define BLOCKHANG 1000
+#define GARBAGE 1000000
+#define CHAINPLACE 10000000
+#define NUMBEROFCHAINS 100
 
 ////////////////////////////////////////////////////////////////////////////////
 //The BloackGame class represents a board, score, time etc. for a single player/
@@ -58,22 +76,8 @@ private:
 
     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;
-    }
+    Uint16 rand2();
+    int firstUnusedChain();
 
 //public:
     Uint32 gameStartedAt;
@@ -112,2376 +116,206 @@ public:
     #endif
 
     //Constructor
-    BlockGame(int tx, int ty) {
-        #if WITH_SDL
-        tmp = IMG_Load2((char*)"gfx/BackBoard.png");
-        sBoard = SDL_DisplayFormat(tmp);
-        SDL_FreeSurface(tmp);
-        #endif
-        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 = 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
+    BlockGame(int tx, int ty);
 
     //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() {
-        #if WITH_SDL
-        SDL_FreeSurface(sBoard);
-        #endif
-    }
-
-    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);
-    }
+    ~BlockGame();
 
+    void setGameSpeed(Uint8 globalSpeedLevel);
+    void setHandicap(Uint8 globalHandicap);
     //Set the move speed of the AI based on the aiLevel parameter
     //Also enables AI
-    void setAIlevel(Uint8 aiLevel) {
-        AI_Enabled = true;
-        AI_MoveSpeed=120-(20*(aiLevel-3));
-    };
-    
-    Uint8 getAIlevel() {
-        return (120-AI_MoveSpeed)/20+3;
-    }
-
-    int GetScore() {
-        return score;
-    }
-
-    int GetHandicap() {
-        return handicap;
-    }
-
-    bool isGameOver() {
-        return bGameOver;
-    }
-
-    int GetTopX() {
-        return topx;
-    }
-
-    int GetTopY() {
-        return topy;
-    }
-
-    unsigned int GetGameStartedAt() {
-        return gameStartedAt;
-    }
-
-    unsigned int GetGameEndedAt() {
-        return gameEndedAfter;
-    }
-
-    bool isTimeTrial() {
-        return timetrial;
-    }
-
-    bool isStageClear() {
-        return stageClear;
-    }
-
-    bool isVsMode() {
-        return vsMode;
-    }
-
-    bool isPuzzleMode() {
-        return puzzleMode;
-    }
-
-    int GetLinesCleared() {
-        return linesCleared;
-    }
-
-    int GetStageClearLimit() {
-        return stageClearLimit;
-    }
-
-    int GetChains() {
-        return chain;
-    }
-
-    int GetPixels() {
-        return pixels;
-    }
-
-    int GetSpeedLevel() {
-        return speedLevel;
-    }
-
-    int GetTowerHeight() {
-        return TowerHeight;
-    }
-
-    int GetCursorX() {
-        return cursorx;
-    }
-
-    int GetCursorY() {
-        return cursory;
-    }
-
-    void MoveCursorTo(int x, int y) {
-        cursorx = x;
-        cursory = y;
-    }
-
-    bool GetIsWinner() {
-        return hasWonTheGame;
-    }
-
+    void setAIlevel(Uint8 aiLevel);
+    Uint8 getAIlevel();
+
+    int GetScore();
+    int GetHandicap();
+    bool isGameOver();
+    int GetTopX();
+    int GetTopY();
+    unsigned int GetGameStartedAt();
+    unsigned int GetGameEndedAt();
+    bool isTimeTrial();
+    bool isStageClear();
+    bool isVsMode();
+    bool isPuzzleMode();
+    int GetLinesCleared();
+    int GetStageClearLimit();
+    int GetChains();
+    int GetPixels();
+    int GetSpeedLevel();
+    int GetTowerHeight();
+    int GetCursorX();
+    int GetCursorY();
+    void MoveCursorTo(int x, int y);
+    bool GetIsWinner();
 private:
 #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;
-    }
+    void emptyGarbageStack();
+    bool pushGarbage(Uint8 width, Uint8 height, Uint8 type);
 public:
-    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;
-    }
+    bool popGarbage(Uint8 *width, Uint8 *height, Uint8 *type);
 private:
 
 #endif
 
     #if WITH_SDL
     //Loads BackBoard again if surface format has changed
-    void convertSurface() {
-        SDL_FreeSurface(sBoard);
-        sBoard = SDL_DisplayFormat(backBoard);
-    }
+    void convertSurface();
     #endif
 
 public:
     //Instead of creating new object new game is called, to prevent memory leaks
-    void 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 NewTimeTrialGame(int x,int y, unsigned int ticks) {
-        NewGame(x,y,ticks);
-        timetrial = true;
-        putStartBlocks();
-    }
-
+    void NewGame(int tx, int ty, unsigned int ticks);
+    void NewTimeTrialGame(int x,int y, unsigned int ticks);
     //Starts a new stage game, takes level as input!
-    void 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 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;
-
-            }
-        }
-    }
-    
+    void NewStageGame(int level, int tx, int ty,unsigned int ticks);
+    void NewPuzzleGame(int level, int tx, int ty, unsigned int ticks);
     //Replay the current level
-    void retryLevel(unsigned int ticks)
-    {
-        if(puzzleMode)
-            NewPuzzleGame(Level,topx,topy,ticks);
-        else
-            if(stageClear)
-                NewStageGame(Level,topx,topy,ticks);
-    }
-    
+    void retryLevel(unsigned int ticks);
     //Play the next level
-    void 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);
-            }
-    }
-
+    void nextLevel(unsigned int ticks);
     //Starts new Vs Game (two Player)
-    void NewVsGame(int tx, int ty, BlockGame *target,unsigned int ticks) {
-        NewGame(tx, ty,ticks);
-        vsMode = true;
-        putStartBlocks();
-        garbageTarget = target;
-        Stats::getInstance()->addOne("VSgamesStarted");
-    }
-
+    void NewVsGame(int tx, int ty, BlockGame *target,unsigned int ticks);
     //Starts new Vs Game (two Player)
-    void 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;
-    }
+    void NewVsGame(int tx, int ty, BlockGame *target, bool AI,unsigned int ticks);
 private:
-
     //Go in Demonstration mode, no movement
-    void Demonstration(bool toggle) {
-        speed=0;
-        baseSpeed = 0;
-    }
+    void Demonstration(bool toggle);
 public:
     //We want to play the replay (must have been loaded beforehand)
-    void 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
-    }
-
-
+    void playReplay(int tx, int ty, unsigned int ticks);
 #if NETWORK
-
     //network play
-    void 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();
-    }
+    void playNetwork(int tx, int ty,unsigned int ticks);
 #endif
-
     //Prints "winner" and ends game
-    void 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 setPlayerWon();
     //void SetGameOver();
 
     #if NETWORK
     //Sets disconnected:
-    void setDisconnect() {
-        bDisconnected = true;
-        SetGameOver();
-    }
+    void setDisconnect();
     #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");
-    }
-
+    void setDraw();
     //Function to get a boardpackage
-    boardPackage 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;
-    }
-
+    boardPackage getPackage();
     //Takes a package and sets the board like it
-    void 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;
-        }
-
-    }
-
+    void setBoard(boardPackage bp);
 private:
-
     //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;
-    }
-
+    bool LineEmpty(int lineNr);
     //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;
-    }
-
+    bool BoardEmpty();
     //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));
-    }
-
+    bool hasStaticContent();
+    void putStartBlocks();
 public:
-    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;
-        };
-    }
-
+    void putStartBlocks(Uint32 n);
 private:
-
     //decreases hang for all hanging blocks and wait for waiting blocks
-    void 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;
-    }
-
+    void ReduceStuff();
 public:
-
     //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;
-        }
-    }
-
+    bool CreateGarbage(int wide, int height);
     //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;
-        }
-    }
-
+    bool CreateGreyGarbage();
 private:
-
     //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;
-    }
-
+    int GarbageClearer(int x, int y, int number, bool aLineToClear, int chain);
     //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) {
-        if ((x>6)||(x<0)||(y<0)||(y>29)) return -1;
-        if (((board[x][y])/1000000 == 2)&&(garbageToBeCleared[x][y] == false)) {
-            for (int i=0;i<6;i++)
-                garbageToBeCleared[i][y] = true;
-        }
-        else
-            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 GarbageMarker(int x, int y);
+    int FirstGarbageMarker(int x, int y);
     //Clear Blocks if 3 or more is alligned (naive implemented)
-    void ClearBlocks() {
-
-        bool toBeCleared[7][30]; //true if blok must be removed
-
-        int previus=-1; //the last block checked
-        int combo=0;
-        for (int i=0;i<30;i++)
-            for (int j=0;j<7;j++) {
-                toBeCleared[j][i] = false;
-                garbageToBeCleared[j][i] = false;
-            }
-        for (int i=0;i<7;i++) {
-            bool faaling = false;
-            for (int j=0;j<30;j++) {
-                if ((faaling)&&(board[i][j]>-1)&&(board[i][j]%10000000<7)) {
-                    board[i][j]+=BLOCKFALL;
-                }
-                if ((!faaling)&&((board[i][j]/BLOCKFALL)%10==1))
-                    board[i][j]-=BLOCKFALL;
-                if (!((board[i][j]>-1)&&(board[i][j]%10000000<7)))
-                    faaling=true;
-                if (((board[i][j]/1000000)%10==1)||((board[i][j]/1000000)%10==2)||((board[i][j]/BLOCKHANG)%10==1)||((board[i][j]/BLOCKWAIT)%10==1))
-                    faaling = false;
-            }
-        }
-
-
-        for (int j=0;j<7;j++) {
-            previus = -1;
-            combo=0;
-
-            for (int i=1;i<30;i++) {
-                if ((board[j][i]>-1)&&(board[j][i]%10000000<7)) {
-                    if (board[j][i]%10000000 == previus) {
-                        combo++;
-                    }
-                    else {
-                        if (combo>2)
-                            for (int k = i-combo; k<i;k++) {
-                                toBeCleared[j][k] = true;
-                            }
-                        combo=1;
-                        previus = board[j][i]%10000000;
-                    }
-                } //if board
-                else {
-                    if (combo>2)
-                        for (int k = i-combo; k<i;k++) {
-                            toBeCleared[j][k] = true;
-                        }
-                    combo = 0;
-                    previus = -1;
-                }
-
-            } //for i
-        } //for j
-
-
-        combo = 0;
-        chain = 0;
-        for (int i=0; i<6;i++)
-            for (int j=0; j<30;j++) {
-                //Clears blocks marked for clearing
-                Sint32 temp=board[i][j];
-                if (1==((temp/BLOCKWAIT)%10))
-                    if (((temp/10)%100)==0) {
-                        if (chainSize[chain]<chainSize[board[i][j]/10000000])
-                            chain = board[i][j]/10000000;
-
-                        theBallManeger.addBall(topx+40+i*bsize, topy+bsize*12-j*bsize, true, board[i][j]%10);
-                        theBallManeger.addBall(topx+i*bsize, topy+bsize*12-j*bsize, false, board[i][j]%10);
-                        theExplosionManeger.addExplosion(topx-10+i*bsize, topy+bsize*12-10-j*bsize);
-                        board[i][j]=-2;
-                    }
-            }
-        for (int i=0; i<7;i++) {
-            bool setChain=false;
-            for (int j=0; j<30;j++) {
-                if (board[i][j]==-1)
-                    setChain=false;
-                if (board[i][j]==-2) {
-                    board[i][j]=-1;
-                    setChain=true;
-                    if (SoundEnabled)Mix_PlayChannel(0, boing, 0);
-                }
-                if (board[i][j]!=-1)
-                    if ((setChain)&&((board[i][j]/GARBAGE)%10!=1)&&((board[i][j]/GARBAGE)%10!=2)) {
-                        board[i][j]=((board[i][j]%CHAINPLACE)+CHAINPLACE*chain);
-                        //somethingsGottaFall = true;
-                    }
-
-            }
-        }
-        combo=0;
-        int startvalue;
-        if (pixels == 0)
-            startvalue=1;
-        else
-            startvalue=0;
-        for (int i=startvalue;i<30;i++) {
-            previus=-1;
-            combo=0;
-            for (int j=0;j<7;j++) {
-                if (((board[j][i]>-1)&&(board[j][i]%10000000<7))) {
-                    if (board[j][i]%10000000 == previus) {
-                        combo++;
-                    }
-                    else {
-                        if (combo>2)
-                            for (int k = j-combo; k<j;k++) {
-                                toBeCleared[k][i] = true;
-                            }
-                        combo=1;
-                        previus = board[j][i]%10000000;
-                    }
-                } //if board
-                else {
-                    if (combo>2)
-                        for (int k = j-combo; k<j;k++) {
-                            toBeCleared[k][i] = true;
-                        }
-                    combo = 0;
-                    previus = -1;
-                }
-
-            } //for j
-        } //for i
-        bool blockIsFalling[6][30]; //See that is falling
-        for (int i=0;i<30;i++)
-            for (int j=0;j<6;j++)
-                blockIsFalling[j][i] = false;
-
-
-
-        combo = 0;
-        chain = 0;
-        int grey = 0;
-        for (int i=0;i<30;i++)
-            for (int j=0;j<6;j++)
-                if (toBeCleared[j][i]) {
-                    //see if any garbage is around:
-                    FirstGarbageMarker(j-1, i);
-                    FirstGarbageMarker(j+1, i);
-                    FirstGarbageMarker(j, i-1);
-                    FirstGarbageMarker(j, i+1);
-                    //that is checked now :-)
-                    if (board[j][i]%10000000==6)
-                        grey++;
-                    if ((vsMode) && (grey>2) && (board[j][i]%10000000==6))
-                        garbageTarget->CreateGreyGarbage();
-                    if ((board[j][i]>-1)&&(board[j][i]%10000000<7))
-                        board[j][i]+=BLOCKWAIT+10*FALLTIME;
-
-                    if (chainSize[board[j][i]/10000000]>chainSize[chain])
-                        chain=board[j][i]/10000000;
-                    combo++;
-                    stop+=140*combo;
-                    score +=10;
-                    if (combo>3)
-                        score+=3*combo; //More points if more cleared simontanously
-                }
-        score+=chainSize[chain]*100;
-        if (chain==0) {
-            chain=firstUnusedChain();
-            chainSize[chain]=0;
-            chainUsed[chain]=true;
-        }
-        chainSize[chain]++;
-        for (int i=0;i<30;i++)
-            for (int j=0;j<6;j++) {
-                //if(board[j][i]/10==(BLOCKWAIT+10*FALLTIME)/10)
-                if (toBeCleared[j][i]) {
-                    board[j][i]=(board[j][i]%10000000)+chain*10000000;
-                }
-            }
-
-        { //This is here we add text to screen!
-            bool dead = false;
-            for (int i=29;i>=0;i--)
-                for (int j=0;j<6;j++)
-                    if (toBeCleared[j][i]) {
-                        if (!dead) {
-                            dead=true;
-                            string tempS = itoa(chainSize[chain]);
-                            if (chainSize[chain]>1)
-                                theTextManeger.addText(topx-10+j*bsize, topy+12*bsize-i*bsize, tempS, 1000);
-                        }
-                    }
-        } //This was there text was added
-
-        if (vsMode)
-            switch (combo) {
-            case 0:
-            case 1:
-            case 2:
-            case 3:
-                break;
-            case 4:
-                garbageTarget->CreateGarbage(3, 1);
-                break;
-            case 5:
-                garbageTarget->CreateGarbage(4, 1);
-                break;
-            case 6:
-                garbageTarget->CreateGarbage(5, 1);
-                break;
-            case 7:
-                garbageTarget->CreateGarbage(6, 1);
-                break;
-            case 8:
-                garbageTarget->CreateGarbage(4, 1);
-                garbageTarget->CreateGarbage(4, 1);
-                break;
-            case 9:
-                garbageTarget->CreateGarbage(5, 1);
-                garbageTarget->CreateGarbage(4, 1);
-                break;
-            case 10:
-                garbageTarget->CreateGarbage(5, 1);
-                garbageTarget->CreateGarbage(5, 1);
-                break;
-            case 11:
-                garbageTarget->CreateGarbage(6, 1);
-                garbageTarget->CreateGarbage(5, 1);
-                break;
-            case 12:
-                garbageTarget->CreateGarbage(6, 1);
-                garbageTarget->CreateGarbage(6, 1);
-                break;
-            case 13:
-                garbageTarget->CreateGarbage(5, 1);
-                garbageTarget->CreateGarbage(5, 1);
-                garbageTarget->CreateGarbage(4, 1);
-                break;
-            default:
-                garbageTarget->CreateGarbage(5, 1);
-                garbageTarget->CreateGarbage(5, 1);
-                garbageTarget->CreateGarbage(4, 1);
-                break;
-            }
-        for (int i=0;i<30;i++)
-            for (int j=0;j<6;j++)
-                if (garbageToBeCleared[j][i]) {
-                    GarbageClearer(j, i, board[j][i]%1000000, true, chain); //Clears the blocks and all blocks connected to it.
-                }
-
-        chain=0;
-
-        //Break chains (if a block is stable it is resetted to (chain == 0)):
-        for (int i=0;i<7;i++) {
-            bool faaling = false;  //In the beginning we are NOT falling
-            for (int j=0;j<30;j++) {
-                if ((faaling)&&(board[i][j]>-1)&&(board[i][j]<7)) {
-                    board[i][j]+=BLOCKFALL;
-                }
-                if ((!faaling)&&((board[i][j]/BLOCKFALL)%10==1))
-                    board[i][j]-=BLOCKFALL;
-                if ((!faaling)&&(board[i][j]>0)&&(board[i][j]/10000000!=0)&&((board[i][j]/BLOCKWAIT)%10!=1)&&((board[i][j]/BLOCKHANG)%10!=1)) {
-                    if (chainSize[board[i][j]/10000000]>chainSize[chain])
-                        chain=board[i][j]/10000000;
-                    board[i][j]=board[i][j]%10000000;
-                }
-                if (!((board[i][j]>-1)&&(board[i][j]<7)))
-                    faaling=true;
-                if (((board[i][j]/1000000)%10==1)||((board[i][j]/BLOCKHANG)%10==1)||((board[i][j]/BLOCKWAIT)%10==1))
-                    faaling = false;
-            }
-        }
-
-        //Create garbage as a result
-        //if((vsMode)&&(chainSize[chain]>1)) garbageTarget->CreateGarbage(6,chainSize[chain]-1);
-
-        //Calculate chain
-        chain=0;
-        for (int i=0; i<6;i++)
-            for (int j=0; j<30;j++) {
-                if (chainSize[board[i][j]/10000000]>chain)
-                    chain=chainSize[board[i][j]/10000000];
-            }
-
-        //Make space in table for more things
-        if (chain==0)
-            for (int i=0;i<NUMBEROFCHAINS;i++)
-                if (chainUsed[i]==true) {
-                    if ((vsMode)&&(chainSize[i]>1)) garbageTarget->CreateGarbage(6, chainSize[i]-1);
-                    if ((SoundEnabled)&&(chainSize[i]>4))Mix_PlayChannel(1, applause, 0);
-                    if(chainSize[i]>1 && !puzzleMode && !AI_Enabled)
-                        Stats::getInstance()->addOne((string)"chainX"+itoa(chainSize[i]));
-                    chainUsed[i]=false;
-                }
-    } //ClearBlocks
-
+    void ClearBlocks();
 public:
     //prints "Game Over" and ends game
-    void SetGameOver() {
-        if (!bGameOver) {
-        	gameEndedAfter = ticks-gameStartedAt; //We game ends now!
-		if(!AI_Enabled && !bReplaying)
-		{
-			TimeHandler::addTime("playTime",TimeHandler::ms2ct(gameEndedAfter));
-		}
-	}
-        if(bReplaying)
-        {
-            bReplaying = false;
-        }
-        else
-        {
-            strncpy(theReplay.name,name,30);
-        }
-        theReplay.setFinalFrame(getPackage(), 0);
-        bGameOver = true;
-        showGame = false;
-        if(stageClear)
-            stageButtonStatus = SBstageClear;
-    }
-
-    bool GetAIenabled() {
-        return AI_Enabled;
-    }
-
+    void SetGameOver();
+    bool GetAIenabled();
 private:
-
     //Moves all peaces a spot down if possible
-    int FallBlock(int x, int y, int number) {
-        if (y == 0) return -1;
-        if (x>0)
-            if (board[x-1][y] == number)
-                return -1;
-        int i=x;
-        bool canFall = true;
-        //checks a line of a garbage block and see if something is under it
-        while ((board[i][y] == number)&&(canFall)&&(i<6)) {
-            if (board[i][y-1] != -1) canFall = false;
-            i++;
-        }
-        if (canFall) {
-            //cout << "Now falling" << endl;
-            for (int j = x;j<i;j++) {
-                board[j][y-1] = board[j][y];
-                board[j][y] = -1;
-            }
-        }
-        return 0;
-    }	//FallBlock
-
-
+    int FallBlock(int x, int y, int number);
     //Makes all Garbage fall one spot
-    void GarbageFall() {
-        for (int i=0;i<30;i++)
-            for (int j=0;j<7; j++) {
-                if ((((board[j][i]/1000000)%10) == 1)||(((board[j][i]/1000000)%10) == 2))
-                    FallBlock(j, i, board[j][i]);
-            }
-    }
-
+    void GarbageFall();
     //Makes the blocks fall (it doesn't test time, this must be done before hand)
-    void FallDown() {
-        bool falling =false;        //nothing is moving unless proven otherwise
-        for (int i=0;i<29;i++)
-            for (int j=0;j<6;j++) {
-                if ((board[j][i]==-1) && (board[j][i+1]!=-1) && (board[j][i+1]%BLOCKFALL<7)) {
-                    board[j][i] = board[j][i+1];
-                    board[j][i+1] = -1;
-                    falling = true;              //something is moving!
-                }
-                if ((board[j][i]/BLOCKWAIT)%10==1)
-                    falling=true;
-            }
-        if (!falling) //If nothing is falling
-        {
-            if ((puzzleMode)&&(!bGameOver)&&(MovesLeft==0)&&(!(BoardEmpty()))) {
-                //Puzzle not won
-                SetGameOver();
-                stageButtonStatus = SBpuzzleMode;
-            }
-        }
-        GarbageFall();		//Makes the garbage fall
-        nrFellDown++;      //Sets number of this fall, so we know then the next will occur
-    }
-
+    void FallDown();
 public:
     //Moves the cursor, receaves N,S,E or W as a char an moves as desired
-    void MoveCursor(char way) {
-        if (!bGameOver)       //If game over nothing happends
-        {
-            if ((way == 'N') && ((cursory<10)||(TowerHeight>12) ||(((pixels==bsize)||(pixels==0)) && (cursory<11))))
-                cursory++;
-            if ((way == 'S') && (cursory>0))
-                cursory--;
-            if ((way == 'W') && (cursorx>0))
-                cursorx--;
-            if ((way == 'E') && (cursorx<4))
-                cursorx++;
-        }
-    }
-
+    void MoveCursor(char way);
     //switches the two blocks at the cursor position, unless game over
-    void SwitchAtCursor() {
-        if ((board[cursorx][cursory+1]<7) && (board[cursorx+1][cursory+1]<7) && (!bGameOver) && ((!puzzleMode)||(MovesLeft>0)) && (gameStartedAt<ticks)) {
-            int temp = board[cursorx][cursory+1];
-            board[cursorx][cursory+1] = board[cursorx+1][cursory+1];
-            board[cursorx+1][cursory+1] = temp;
-        }
-        if ((puzzleMode)&&(gameStartedAt<ticks)&&(MovesLeft>0)) MovesLeft--;
-    }
-
+    void SwitchAtCursor();
     //Generates a new line and moves the field one block up (restart puzzle mode)
-    void PushLine() {
-        //If not game over, not high tower and not puzzle mode
-        if ((!bGameOver) && TowerHeight<13 && (!puzzleMode) && (gameStartedAt<ticks)&&(chain==0)) {
-            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] = rand2() % 4;
-                if (j > 0) {
-                    if (board[j][0] == board[j-1][0])
-                        board[j][0] = rand2() % 6;
-                }
-                if (board[j][0] == board[j][1])
-                    board[j][0] = rand2() % 6;
-                if (board[j][0] == board[j][1])
-                    board[j][0] = rand2() % 6;
-                while ((j>0)&&(board[j][0]==board[j-1][0]))
-                    board[j][0] = rand2() % 6;
-            }
-            score+=1;
-            MoveCursor('N');
-            if (vsMode) {
-                if (rand2()%6==1)
-                    board[rand2()%6][0]=6;
-            }
-            pixels = 0;
-            stop=0;
-            pushedPixelAt = ticks;
-            linesCleared++;
-            AI_LineOffset++;
-            nrPushedPixel=(int)((double)(pushedPixelAt-gameStartedAt)/(1000.0*speed));
-            
-            if(!AI_Enabled && !bReplaying)
-            {
-                Stats::getInstance()->addOne("linesPushed");
-            }
-        } //if !bGameOver
-
-        //Restart Puzzle mode
-        if (puzzleMode && !bGameOver) {
-            //Reloads 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];
-                }
-            score=0;
-            bGameOver=false;
-            showGame = true;
-        }
-
-        if ((TowerHeight>12) && (!puzzleMode)&&(!bGameOver)&&(chain==0)) {
-            if ((!vsMode)&&(theTopScoresEndless.isHighScore(score))&&(!AI_Enabled)) {
-                if (SoundEnabled)Mix_PlayChannel(1, applause, 0);
-                theTopScoresEndless.addScore(name, score);
-                cout << "New high score!" << endl;
-            }
-            SetGameOver();
-        }
-        
-        
-    }//PushLine
-
+    void PushLine();
 private:
-
     //Pushes a single pixel, so it appears to scrool
-    void PushPixels() {
-        nrPushedPixel++;
-        if ((pixels < bsize) && TowerHeight<13) {
-            pixels++;
-        }
-        else
-            PushLine();
-        if (pixels>bsize)
-            pixels=0;
-    }
-
-    //See how high the tower is, saved in integer TowerHeight
-    /*void FindTowerHeight()
-     * {
-     * /*
-     * This function needs to be corrected, if an empty line appears towerheight become to low!
-     * /
-     * bool found = false;
-     * bool notNew = false;
-     * TowerHeight = 0;
-     * for(int i=0; i<19;i++)
-     * //while(!found)
-     * {
-     * found = true;
-     * for(int j=0;j<6;j++)
-     * if(board[j][i] != -1)
-     * found = false;
-     * if((!found) && (notNew))
-     * notNew =false;
-     * if((found)&&(!notNew))
-     * {
-     * TowerHeight=i;
-     * notNew = true;
-     * }
-     * }
-     * TowerHeight--;
-     * }*/
-
+    void PushPixels();
     //See how high the tower is, saved in integer TowerHeight
-    void FindTowerHeight() {
-        /*
-         * Old implementation, used until I find the bug in the other.
-         * This function has a bug in stage clear! if an empty line appears.
-         */
-        prevTowerHeight = TowerHeight;
-        bool found = false;
-        TowerHeight = 0;
-        while (!found) {
-            found = true;
-            for (int j=0;j<6;j++)
-                if (board[j][TowerHeight] != -1)
-                    found = false;
-            TowerHeight++;
-        }
-        TowerHeight--;
-    }
-
+    void FindTowerHeight();
 ///////////////////////////////////////////////////////////////////////////
 /////////////////////////// AI starts here! ///////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
     //First the helpet functions:
-    int nrOfType(int line, int type) {
-        // cout << "Start_ nrOfType" << endl;
-        int counter = 0;
-        for (int i=0; i<6; i++)
-            if (board[i][line]==type)counter++;
-        return counter;
-    }
-
+    int nrOfType(int line, int type);
     int AIcolorToClear;
     int AIlineToClear;
-
     //See if a combo can be made in this line
-    int horiInLine(int line) {
-        //cout << "Start_ hori in line" << endl;
-        int nrOfType[7] = {0, 0, 0, 0, 0, 0, 0};
-        int iTemp;
-        int max = 0;
-        for (int i=0; i<6; i++) {
-            iTemp = board[i][line];
-            if ((iTemp>-1)&&(iTemp<7))
-                nrOfType[iTemp]++;
-        }
-        for (int j=0; j<7; j++) {
-            if (nrOfType[j]>max) {
-                max = nrOfType[j];
-                AIcolorToClear = j;
-            }
-        }
-        return max;
-    }
-
-    bool horiClearPossible() {
-        //cout << "Start_ horiclear possible" << endl;
-        int i=13;
-        bool solutionFound = false;
-        do{
-            if (horiInLine(i)>2) {
-                AI_LineOffset = 0;
-                AIlineToClear = i;
-                solutionFound = true;
-            }
-            i--;
-        }while ((!solutionFound)&&(i>0));
-        return solutionFound;
-    }
-
+    int horiInLine(int line);
+    bool horiClearPossible();
     //the Line Has Unmoveable Objects witch might stall the AI
-    bool lineHasGarbage(int line) {
-        for (int i=0;i<6;i++)
-            if (board[i][line]>1000000)
-                return true;
-        return false;
-    }
-
+    bool lineHasGarbage(int line);
     //Types 0..6 in line
-    int nrOfRealTypes(int line) {
-        //cout << "Start_ nrOfReal" << endl;
-        int counter = 0;
-        for (int i=0; i<6; i++)
-            if ((board[i][line]>-1)&&(board[i][line]<7))counter++;
-        return counter;
-    }
-
+    int nrOfRealTypes(int line);
     //See if there is a tower
-    bool ThereIsATower() {
-        //cout << "Start_ there is a tower" << endl;
-        bool bThereIsATower = false; //Unless proven otherwise!
-        bool topReached = false; //If we have reached the top
-        int lineNumber = 0;
-        bool emptySpacesFound = false;
-        do {
-            if ((emptySpacesFound) && (nrOfRealTypes(lineNumber)>0)&&(nrOfType(lineNumber, -1)>0)) {
-                AIlineToClear = lineNumber;
-                if (lineHasGarbage(lineNumber))
-                    return false;
-                else
-                    bThereIsATower = true;
-            }
-            else
-                emptySpacesFound=false;
-            if ((!emptySpacesFound)&&(nrOfType(lineNumber, -1)>0))
-                emptySpacesFound = true;
-            if (lineNumber<12)
-                lineNumber++;
-            else
-                topReached = true;
-        }while ((!bThereIsATower)&&(!topReached));
-        //if(bThereIsATower)
-        //cout << "There is actually a tower" << endl;
-        return bThereIsATower;
-    }
-
-    double firstInLine1(int line) {
-        for (int i=0;i<6;i++)
-            if ((board[i][line]>-1)&&(board[i][line]<7))
-                return (double)i;
-        return 3.0;
-    }
-
+    bool ThereIsATower();
+    double firstInLine1(int line);
     //returns the first coordinate of the block of type
-    double firstInLine(int line, int type) {
-        for (int i=0;i<6;i++)
-            if (board[i][line]==type)
-                return (double)i;
-        return 3.0;
-    }
-
+    double firstInLine(int line, int type);
     //There in the line shall we move
-    int closestTo(int line, int place) {
-        if ((int)firstInLine1(line)>place)
-            return (int)firstInLine1(line)-1;
-        for (int i=place;i>=0;i--) {
-            if ((board[i][line]>-1)&&(board[i][line]<7))
-                return i;
-        }
-        AIstatus=0;
-        return place;
-    }
-
+    int closestTo(int line, int place);
     //The AI will remove a tower
-    void AI_ClearTower() {
-        //   cout << "AI: ClearTower, line: " << AIlineToClear << endl;
-        int place = (int)firstInLine(AIlineToClear-1, -1); //Find an empty field to frop a brick into
-        int xplace = closestTo(AIlineToClear, place); //Find the brick to drop in it
-        if (cursory+1<AIlineToClear)
-            MoveCursor('N');
-        else
-            if (cursory+1>AIlineToClear)
-                MoveCursor('S');
-            else
-                if (cursorx<xplace)
-                    MoveCursor('E');
-                else
-                    if (cursorx>xplace)
-                        MoveCursor('W');
-                    else
-                        SwitchAtCursor();
-        if (!ThereIsATower())
-            AIstatus = 0;
-    }
-
+    void AI_ClearTower();
     //The AI will try to clear block horisontally
-    void AI_ClearHori() {
-        //   cout << "AI: ClearHori";
-        int lowestLine = AIlineToClear;
-        //AIcolorToClear
-        bool found =true;
-        /*for(int i; (i<12)&&(!found);i++)
-         * {
-         * if(horiInLine(i)>2)
-         * {
-         * int lowestLine = i;
-         * found = true;
-         * }
-         * }*/
-        for (int i=0;i<7;i++) {
-            if (nrOfType(lowestLine, i)>2)
-                AIcolorToClear = i;
-        }
-        if (found) {
-            if (cursory>lowestLine-1)
-                MoveCursor('S');
-            else if (cursory<lowestLine-1)
-                MoveCursor('N');
-            else if (nrOfType(lowestLine, AIcolorToClear)>2) {
-                int left=0, right=0;
-                if (board[0][lowestLine]==AIcolorToClear) left++;
-                if (board[1][lowestLine]==AIcolorToClear) left++;
-                if (board[2][lowestLine]==AIcolorToClear) left++;
-                if (board[3][lowestLine]==AIcolorToClear) right++;
-                if (board[4][lowestLine]==AIcolorToClear) right++;
-                if (board[5][lowestLine]==AIcolorToClear) right++;
-                int xplace = 0;
-                if (left<right) {
-                    //   cout << ", right>left";
-                    int count=0;
-                    for (int i=0;(i<4)&&(count<1);i++)
-                        if ((board[i][lowestLine]==AIcolorToClear)&&((i==0)||(board[i+1][lowestLine]!=AIcolorToClear))) {
-                            count++;
-                            xplace = i;
-                        }
-                }
-                else {
-                    //   cout << ", left>=right";
-                    int count=0;
-                    for (int i=3;(i<=5)&&(count<1);i++)
-                        if ((board[i][lowestLine]==AIcolorToClear)&&(board[i-1][lowestLine]!=AIcolorToClear)) {
-                            count++;
-                            xplace = --i;
-                        }
-                }
-                //cout << ", xplace: " << xplace;
-                if (cursorx<xplace)
-                    MoveCursor('E');
-                else
-                    if (cursorx>xplace)
-                        MoveCursor('W');
-                    else
-                        if (cursorx==xplace)
-                            SwitchAtCursor();
-                        else
-                            AIstatus = 0;
-            }
-            else
-                AIstatus = 0;
-        }
-        else
-            AIstatus = 0;
-        //cout << endl; //for debugging
-    }
-
+    void AI_ClearHori();
     //Test if vertical clear is possible
-    bool veriClearPossible() {
-        bool found=false;
-        int colors[7] = {0, 0, 0, 0, 0, 0, 0};
-        for (int i=12;(i>0)&&(!found);i--) {
-            for (int j=0;j<7;j++) {
-                if (nrOfType(i, j)==0)
-                    colors[j]=0;
-                else
-                    if (++colors[j]>2) {
-                        AIcolorToClear = j;
-                        AIlineToClear = i;
-                        found=true;
-                    }
-
-            }
-        }
-        return found;
-    }
-
-
-
+    bool veriClearPossible();
     //There in the line shall we move
-    int closestTo(int line, int type, int place) {
-        if ((int)firstInLine(line, type)>place)
-            return (int)firstInLine(line, type)-1;
-        for (int i=place;i>=0;i--) {
-            if (board[i][line]==type)
-                return i;
-        }
-        AIstatus=0;
-        return place;
-    }
-
+    int closestTo(int line, int type, int place);
     //The AI will try to clear blocks vertically
-    void AI_ClearVertical() {
-        // cout << "AI: ClearVeri";
-        //First we find the place there we will align the bricks
-        int placeToCenter = (int)(firstInLine(AIlineToClear, AIcolorToClear)/3.0+firstInLine(AIlineToClear+1, AIcolorToClear)/3.0+firstInLine(AIlineToClear+2, AIcolorToClear)/3.0);
-        int unlimitedLoop=0;
-        while (((board[placeToCenter][AIlineToClear]>1000000)||(board[placeToCenter][AIlineToClear+1]>1000000)||(board[placeToCenter][AIlineToClear+2]>1000000))&&(unlimitedLoop<10)) {
-            unlimitedLoop++;
-            placeToCenter++;
-            if (placeToCenter>5)
-                placeToCenter=0;
-        }
-        if(unlimitedLoop>9) {
-            AIstatus = 0;
-        }
-        //cout << ", ptc: " << placeToCenter << ", line: " << AIlineToClear << ", cy: " << cursory;
-        if (cursory+1>AIlineToClear+2) {
-            // cout << ", cursory>line+2";
-            MoveCursor('S');
-        }
-        if (cursory+1<AIlineToClear)
-            MoveCursor('N');
-        bool toAlign[3]={true, true, true};
-        if (board[placeToCenter][AIlineToClear+0]==AIcolorToClear)
-            toAlign[0]=false;
-        if (board[placeToCenter][AIlineToClear+1]==AIcolorToClear)
-            toAlign[1]=false;
-        if (board[placeToCenter][AIlineToClear+2]==AIcolorToClear)
-            toAlign[2]=false;
-        //cout << "status: " << toAlign[0] << " " << toAlign[1] << " " << toAlign[2];
-        if (cursory+1==AIlineToClear) {
-            if (toAlign[0]==false)
-                MoveCursor('N');
-            else {
-                if (cursorx>closestTo(AIlineToClear, AIcolorToClear, placeToCenter))
-                    MoveCursor('W');
-                else
-                    if (cursorx<closestTo(AIlineToClear, AIcolorToClear, placeToCenter))
-                        MoveCursor('E');
-                    else
-                        SwitchAtCursor();
-            }
-        }
-        else
-            if (cursory+1==AIlineToClear+1) {
-                if (toAlign[1]==false) {
-                    if (toAlign[2])
-                        MoveCursor('N');
-                    else
-                        MoveCursor('S');
-                }
-                else {
-                    if (cursorx>closestTo(AIlineToClear+1, AIcolorToClear, placeToCenter))
-                        MoveCursor('W');
-                    else
-                        if (cursorx<closestTo(AIlineToClear+1, AIcolorToClear, placeToCenter))
-                            MoveCursor('E');
-                        else
-                            SwitchAtCursor();
-                }
-            }
-            else
-                if (cursory+1==AIlineToClear+2) {
-                    if (toAlign[2]==false)
-                        MoveCursor('S');
-                    else {
-                        if (cursorx>closestTo(AIlineToClear+2, AIcolorToClear, placeToCenter))
-                            MoveCursor('W');
-                        else
-                            if (cursorx<closestTo(AIlineToClear+2, AIcolorToClear, placeToCenter))
-                                MoveCursor('E');
-                            else
-                                SwitchAtCursor();
-                    }
-                }
-
-        if ((!toAlign[0])&&(!toAlign[1])&&(!toAlign[2]))
-            AIstatus = 0;
-        if ((nrOfType(AIlineToClear, AIcolorToClear)==0)||(nrOfType(AIlineToClear+1, AIcolorToClear)==0)||(nrOfType(AIlineToClear+2, AIcolorToClear)==0))
-            AIstatus = 0;
-        //cout << endl;
-    }
-
-
-
+    void AI_ClearVertical();
     short AIstatus;   //Status flags:
     //0: nothing, 2: clear tower, 3: clear horisontal, 4: clear vertical
     //1: make more lines, 5: make 2 lines, 6: make 1 line
     bool firstLineCreated;
-
-    void AI_Move() {
-        switch (AIstatus) {
-        case 1:
-            if (TowerHeight<8)PushLine();
-            else AIstatus = 0;
-            break;
-        case 2:
-            AI_ClearTower();
-            break;
-        case 3:
-            AI_ClearHori();
-            break;
-        case 4:
-            AI_ClearVertical();
-            break;
-        case 5:
-            if (!firstLineCreated){
-                PushLine();
-                firstLineCreated = true;
-            }
-            else {
-                PushLine();
-                AIstatus = 0;
-            }
-            break;
-        case 6:
-            PushLine();
-            AIstatus = 0;
-            break;
-        default:
-            if (TowerHeight<6) AIstatus = 1;
-            else
-                if (horiClearPossible()) AIstatus = 3;
-                else
-                    if (veriClearPossible()) AIstatus = 4;
-                    else
-                        if (ThereIsATower()) AIstatus = 2;
-                        else
-                            AIstatus = 5;
-            break;
-        }
-    }
-
+    void AI_Move();
 //////////////////////////////////////////////////////////////////////////
 ///////////////////////////// AI ends here! //////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
 #if WITH_SDL
     //Draws all the bricks to the board (including garbage)
-    void PaintBricks() {
-        for (int i=0;((i<13)&&(i<30));i++)
-            for (int j=0;j<6;j++) {
-                if ((board[j][i]%10 != -1) && (board[j][i]%10 < 7) && ((board[j][i]/1000000)%10==0)) {
-                    DrawIMG(bricks[board[j][i]%10], sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((board[j][i]/BLOCKWAIT)%10==1)
-                        DrawIMG(bomb[(ticks/BOMBTIME)%2], sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((board[j][i]/BLOCKHANG)%10==1)
-                        DrawIMG(ready[(ticks/READYTIME)%2], sBoard, j*bsize, bsize*12-i*bsize-pixels);
-
-                }
-                if ((board[j][i]/1000000)%10==1) {
-                    int left, right, over, under;
-                    int number = board[j][i];
-                    if (j<1) left = -1;
-                    else left = board[j-1][i];
-                    if (j>5) right = -1;
-                    else right = board[j+1][i];
-                    if (i>28) over = -1;
-                    else over = board[j][i+1];
-                    if (i<1) under = -1;
-                    else under = board[j][i-1];
-                    if ((left == number)&&(right == number)&&(over == number)&&(under == number))
-                        DrawIMG(garbageFill, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left != number)&&(right == number)&&(over == number)&&(under == number))
-                        DrawIMG(garbageL, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left == number)&&(right != number)&&(over == number)&&(under == number))
-                        DrawIMG(garbageR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left == number)&&(right == number)&&(over != number)&&(under == number))
-                        DrawIMG(garbageT, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left == number)&&(right == number)&&(over == number)&&(under != number))
-                        DrawIMG(garbageB, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left != number)&&(right == number)&&(over != number)&&(under == number))
-                        DrawIMG(garbageTL, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left != number)&&(right == number)&&(over == number)&&(under != number))
-                        DrawIMG(garbageBL, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left == number)&&(right != number)&&(over != number)&&(under == number))
-                        DrawIMG(garbageTR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left == number)&&(right != number)&&(over == number)&&(under != number))
-                        DrawIMG(garbageBR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left == number)&&(right != number)&&(over != number)&&(under != number))
-                        DrawIMG(garbageMR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left == number)&&(right == number)&&(over != number)&&(under != number))
-                        DrawIMG(garbageM, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    if ((left != number)&&(right == number)&&(over != number)&&(under != number))
-                        DrawIMG(garbageML, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                }
-                if ((board[j][i]/1000000)%10==2) {
-                    if (j==0)
-                        DrawIMG(garbageGML, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                    else
-                        if (j==5)
-                            DrawIMG(garbageGMR, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                        else
-                            DrawIMG(garbageGM, sBoard, j*bsize, bsize*12-i*bsize-pixels);
-                }
-            }
-        const int j = 0;
-
-        int garbageSize=0;
-        for (int i=0;i<20;i++) {
-            if ((board[j][i]/1000000)%10==1) {
-                int left, right, over, under;
-                int number = board[j][i];
-                if (j<1) left = -1;
-                else left = board[j-1][i];
-                if (j>5) right = -1;
-                else right = board[j+1][i];
-                if (i>28) over = -1;
-                else over = board[j][i+1];
-                if (i<1) under = -1;
-                else under = board[j][i-1];
-                if (((left != number)&&(right == number)&&(over != number)&&(under == number))&&(garbageSize>0)) {
-                    DrawIMG(smiley[board[j][i]%4], sBoard, 2*bsize, 12*bsize-i*bsize-pixels+(bsize/2)*garbageSize);
-                }
-                if (!((left != number)&&(right == number)&&(over == number)&&(under == number))) //not in garbage
-                {
-                    garbageSize=0;
-                }
-                else {
-                    //cout << "In garbage" << endl;
-                    garbageSize++;
-                }
-
-            }
-        }
-        for (int i=0;i<6;i++)
-            if (board[i][0]!=-1)
-                DrawIMG(transCover, sBoard, i*bsize, 12*bsize-pixels); //Make the appering blocks transperant
-
-    }
-
+    void PaintBricks();
     //Paints the bricks gotten from a replay/net package
-    void SimplePaintBricks() {
-        /*
-         * We will need to mark the blocks that must have a bomb, we will here need to see, what is falling
-         */
-        bool bbomb[6][13]; //has a bomb on it!
-        bool falling[6][13]; //this is falling
-        bool getReady[6][13]; //getReady
-        for (int i=0;i<6;i++)
-            for (int j=0;j<13;j++) {
-                bbomb[i][j]=false; //All false by default
-                falling[i][j]=false;
-                if (board[i][j]>29)
-                    getReady[i][j]=true;
-                else
-                    getReady[i][j]=false;
-            }
-        //See that is falling
-        for (int i=0;i<6;i++) {
-            bool rowFalling = false;
-            for (int j=0;j<13;j++) {
-                if (rowFalling)
-                    falling[i][j]=true;
-                if ((!rowFalling)&&(board[i][j]%30==-1))
-                    rowFalling = true;
-                if ((rowFalling)&&(board[i][j]%30>6))
-                    rowFalling = false;
-                if (getReady[i][j]) {
-                    falling[i][j]=true; //getReady is the same as falling
-                    rowFalling = false;
-                }
-            }
-        }
-        //Now looking at rows:
-        for (int i=0;i<6;i++) {
-            int count = 0;
-            int color = -1;
-            for (int j=1;j<13;j++) {
-                if ((board[i][j]%30==color)&&(!falling[i][j]))
-                    count++;
-                else
-                    if (falling[i][j]) {
-                        count = 0;
-                    }
-                    else {
-                        color=board[i][j]%30;
-                        count=1;
-                    }
-                if ((count>2)&&(color>-1)&&(color)<7) {
-                    bbomb[i][j]=true;
-                    bbomb[i][j-1]=true;
-                    bbomb[i][j-2]=true;
-                }
-            }
-        }
-        //now looking for lines
-        for (int i=1;i<13;i++) {
-            int count = 0;
-            int color = -1;
-            for (int j=0;j<6;j++) {
-                if ((board[j][i]%30==color)&&(!falling[j][i]))
-                    count++;
-                else
-                    if (falling[j][i]) {
-                        count = 0;
-                    }
-                    else {
-                        color=board[j][i]%30;
-                        count=1;
-                    }
-                if ((count>2)&&(color>-1)&&(color<7)) {
-                    bbomb[j][i]=true;
-                    bbomb[j-1][i]=true;
-                    bbomb[j-2][i]=true;
-                }
-            }
-        }
-        for (int i=0;((i<13)&&(i<30));i++)
-            for (int j=0;j<6;j++) {
-                if ((board[j][i]%10 != -1) && (board[j][i]%30 < 7)) {
-                    DrawIMG(bricks[board[j][i]%10], sBoard, j*bsize, 12*bsize-i*bsize-pixels);
-                    if (bbomb[j][i])
-                        DrawIMG(bomb[(ticks/BOMBTIME)%2], sBoard, j*bsize, 12*bsize-i*bsize-pixels);
-                    if (getReady[j][i])
-                        DrawIMG(ready[(ticks/READYTIME)%2], sBoard, j*bsize, 12*bsize-i*bsize-pixels);
-                }
-                if (board[j][i]%30>6) {
-                    if (board[j][i]%30==7)
-                        DrawIMG(garbageR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==9)
-                        DrawIMG(garbageML, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==10)
-                        DrawIMG(garbageMR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==11)
-                        DrawIMG(garbageTR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==12)
-                        DrawIMG(garbageTL, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==13)
-                        DrawIMG(garbageBL, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==14)
-                        DrawIMG(garbageBR, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==15)
-                        DrawIMG(garbageM, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==16)
-                        DrawIMG(garbageFill, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==17)
-                        DrawIMG(garbageT, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==18)
-                        DrawIMG(garbageB, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==19)
-                        DrawIMG(garbageL, sBoard, j*bsize, 12*bsize-i*bsize-pixels); //good
-                    if (board[j][i]%30==20)
-                        switch(j) {
-                            case 0:
-                                DrawIMG(garbageGML, sBoard,j*bsize, 12*bsize-i*bsize-pixels);
-                                break;
-                            case 5:
-                                DrawIMG(garbageGMR, sBoard,j*bsize, 12*bsize-i*bsize-pixels);
-                                break;
-                            default:
-                                DrawIMG(garbageGM, sBoard,j*bsize, 12*bsize-i*bsize-pixels);
-                        }
-                    //cout << "IS: " << board[j][i] << endl;
-                }
-
-
-            }
-
-        int garbageSize=0;
-        for (int i=0;i<20;i++) {
-            if ((board[0][i]%30==12)&&(garbageSize>0)) {
-                DrawIMG(smiley[0], sBoard, 2*bsize, bsize-i*bsize-pixels+(bsize/2)*garbageSize);
-            }
-            if (board[0][i]%30!=19) //not in garbage
-            {
-                garbageSize=0;
-            }
-            else {
-                //cout << "In garbage" << endl;
-                garbageSize++;
-            }
-
-        }
-    }
-    
+    void SimplePaintBricks();
     int lastCounter;
 public:
     //Draws everything
-    void DoPaintJob() {
-        DrawIMG(backBoard, sBoard, 0, 0);
-        #if NETWORK
-        if ((!bReplaying)&&(!bNetworkPlayer))
-        #else
-        if (!bReplaying)
-        #endif
-            PaintBricks();
-        else
-            SimplePaintBricks();
-        if (stageClear) DrawIMG(blackLine, sBoard, 0, bsize*(12+2)+bsize*(stageClearLimit-linesCleared)-pixels-1);
-        if (puzzleMode&&(!bGameOver)) {
-            //We need to write nr. of moves left!
-            strHolder = "Moves left: " + itoa(MovesLeft);
-            SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
-        }
-        if(puzzleMode && stageButtonStatus == SBpuzzleMode)
-        {
-            DrawIMG(bRetry,sBoard, cordRetryButton.x, cordRetryButton.y);
-            if(Level<nrOfPuzzles-1)
-            {
-                if(hasWonTheGame)
-                    DrawIMG(bNext,sBoard,cordNextButton.x, cordNextButton.y);
-                else
-                    DrawIMG(bSkip,sBoard,cordNextButton.x, cordNextButton.y);
-            }
-            else
-            {
-                strHolder = "Last puzzle";
-                SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
-            }
-        }
-        if(stageClear && stageButtonStatus == SBstageClear)
-        {
-            DrawIMG(bRetry,sBoard, cordRetryButton.x, cordRetryButton.y);
-            if(Level<50-1)
-            {
-                if(hasWonTheGame)
-                    DrawIMG(bNext,sBoard,cordNextButton.x, cordNextButton.y);
-                else
-                    DrawIMG(bSkip,sBoard,cordNextButton.x, cordNextButton.y);
-            }
-            else
-            {
-                strHolder = "Last stage";
-                SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
-            }
-        }
-        
-#if DEBUG
-        if (AI_Enabled&&(!bGameOver)) {
-            strHolder = "AI_status: " + itoa(AIstatus)+ ", "+ itoa(AIlineToClear);
-            SFont_Write(sBoard, fBlueFont, 5, 5, strHolder.c_str());
-        }
-#endif
-        if (!bGameOver)DrawIMG(cursor[(ticks/600)%2],sBoard,cursorx*bsize-4,11*bsize-cursory*bsize-pixels-4);
-        if (ticks<gameStartedAt)
-        {
-            int currentCounter = abs((int)ticks-(int)gameStartedAt)/1000;
-            if( (currentCounter!=lastCounter) && (SoundEnabled)&&(!NoSound))
-                Mix_PlayChannel(1,counterChunk,0);
-            lastCounter = currentCounter;
-            switch (currentCounter) {
-            case 2:
-                DrawIMG(counter[2], sBoard, 2*bsize, 5*bsize);
-                break;
-            case 1:
-                DrawIMG(counter[1], sBoard, 2*bsize, 5*bsize);
-                break;
-            case 0:
-                DrawIMG(counter[0], sBoard, 2*bsize, 5*bsize);
-                break;
-            default:
-                break;
-            }
-        }
-        else
-        {
-            if(SoundEnabled&&(!NoSound)&&(timetrial)&&(ticks>gameStartedAt+10000)&&(!bGameOver))
-            {
-                int currentCounter = (ticks-(int)gameStartedAt)/1000;
-                if(currentCounter!=lastCounter)
-                {
-                    if(currentCounter>115 && currentCounter<120)
-                        Mix_PlayChannel(1,counterChunk,0);
-                }
-                lastCounter = currentCounter;
-            }
-            else
-            {
-                if( (0==lastCounter) && (SoundEnabled)&&(!NoSound))
-                {
-                    Mix_PlayChannel(1,counterFinalChunk,0);
-                }
-                lastCounter = -1;
-            }
-        }
-        
-        if ((bGameOver)&&(!editorMode))
-            if (hasWonTheGame)DrawIMG(iWinner, sBoard, 0, 5*bsize);
-            else if (bDraw) DrawIMG(iDraw, sBoard, 0, 5*bsize);
-            else
-                DrawIMG(iGameOver, sBoard, 0, 5*bsize);
-    }
-
+    void DoPaintJob();
     #endif
-
 private:
 
     //Updates evrything, if not called nothing happends
-    void Update() {
-        Uint32 tempUInt32;
-        Uint32 nowTime = ticks; //We remember the time, so it doesn't change during this call
-        if (bReplaying) {
-            setBoard(theReplay.getFrameSec((Uint32)(nowTime-gameStartedAt)));
-            strncpy(name,theReplay.name,30);
-            if (theReplay.isFinnished((Uint32)(nowTime-gameStartedAt)))
-                switch (theReplay.getFinalStatus()) {
-                case 1: //Winner
-                    bGameOver = true;
-                    hasWonTheGame = true;
-                    break;
-                case 2: //Looser
-                case 4: //GameOver
-                    bGameOver = true;
-                    break;
-                case 3: //draw
-                    bGameOver =true;
-                    bDraw = true;
-                    break;
-                default:
-                    bGameOver = true;
-                    //Nothing
-                    break;
-                };
-        }
-        #if NETWORK
-        if ((!bReplaying)&&(!bNetworkPlayer)) {
-        #else
-            if (!bReplaying) {
-        #endif
-            FindTowerHeight();
-            if ((linesCleared-TowerHeight>stageClearLimit) && (stageClear) && (!bGameOver)) {
-                stageCleared[Level] = true;
-                if(stageScores[Level]<score)
-                {
-                    gameEndedAfter = nowTime-gameStartedAt;
-                    stageScores[Level] = score;
-                    stageTimes[Level] = gameEndedAfter;
-                }
-
-                ofstream outfile;
-                outfile.open(stageClearSavePath.c_str(), ios::binary |ios::trunc);
-                if (!outfile) {
-                    cout << "Error writing to file: " << stageClearSavePath << endl;
-                }
-                else {
-                    for (int i=0;i<nrOfStageLevels;i++) {
-                        bool tempBool = stageCleared[i];
-                        outfile.write(reinterpret_cast<char*>(&tempBool), sizeof(bool));
-                    }
-                    for (int i=0;i<nrOfStageLevels;i++) {
-                        tempUInt32 = stageScores[i];
-                        outfile.write(reinterpret_cast<char*>(&tempUInt32), sizeof(Uint32));
-                    }
-                    for (int i=0;i<nrOfStageLevels;i++) {
-                        tempUInt32 = stageTimes[i];
-                        outfile.write(reinterpret_cast<char*>(&tempUInt32), sizeof(Uint32));
-                    }
-                    outfile.close();
-                }
-                setPlayerWon();
-                stageButtonStatus = SBstageClear;
-            }
-            if ((TowerHeight>12)&&(prevTowerHeight<13)&&(!puzzleMode)) {
-                //if (SoundEnabled) Mix_PlayChannel(1, heartBeat, 0);
-                stop+=1000;
-            }
-
-            if ((TowerHeight>12)&&(!puzzleMode)&&(!bGameOver)) {
-                bNearDeath = true;
-            }
-            
-            while (nowTime>nrStops*40+gameStartedAt) //Increase stops, till we reach nowTime
-            {
-                if (stop>0) {
-                    stop = stop-20;
-                    if (stop<=0) nrPushedPixel=(int)((nowTime-gameStartedAt)/(1000.0*speed));
-                }
-                if (stop<0)
-                    stop = 0;
-                nrStops++;
-            }
-            //If we have static content, we don't raise at all!
-            if (hasStaticContent())
-                stop++;
-            if ((puzzleMode)&&(!bGameOver)&&BoardEmpty()) {
-                if (!singlePuzzle) {
-                    if(puzzleCleared[Level]==false)
-                        Stats::getInstance()->addOne("puzzlesSolved");
-                    puzzleCleared[Level] = true;
-                    ofstream outfile;
-                    stageButtonStatus = SBpuzzleMode;
-                    outfile.open(puzzleSavePath.c_str(), ios::binary |ios::trunc);
-                    if (!outfile) {
-                        cout << "Error writing to file: " << puzzleSavePath << endl;
-                    }
-                    else {
-                        for (int i=0;i<nrOfPuzzles;i++) {
-                            bool tempBool = puzzleCleared[i];
-                            outfile.write(reinterpret_cast<char*>(&tempBool), sizeof(bool));
-                        }
-                        outfile.close();
-                    }
-                }
-                setPlayerWon();
-            }
-            
-            //increse speed:
-            if ((nowTime>gameStartedAt+20000*speedLevel)&&(speedLevel <99)&&(!bGameOver))
-            {
-                speed = (baseSpeed*0.9)/((double)speedLevel*0.5);
-                speedLevel++;
-                nrPushedPixel=(int)((double)(nowTime-gameStartedAt)/(1000.0*speed));
-            }
-            
-            
-            //To prevent the stack from raising a lot then we stop a chain (doesn't work anymore)
-            if (chain>0)
-                stop+=1;
-            //Raises the stack
-            if ((nowTime>gameStartedAt+nrPushedPixel*1000*speed) && (!bGameOver)&&(!stop))
-                while ((nowTime>gameStartedAt+nrPushedPixel*1000*speed)&&(!(puzzleMode)))
-                    PushPixels();
-            if (!bGameOver)ClearBlocks();
-            
-            /*************************************************************
-            Ai stuff
-             **************************************************************/
-            if (bGameOver) {
-                AIstatus = 0;       //Enusres that AI is resetted
-            }
-            else
-                if (AI_Enabled)
-                    if (lastAImove+AI_MoveSpeed<ticks) {
-                        AI_Move();
-                        lastAImove=ticks;
-                    }
-
-            /*************************************************************
-            Ai stuff ended
-             **************************************************************/
-            if ((nowTime>gameStartedAt+nrFellDown*140) && (!bGameOver)) FallDown();
-            if ((nowTime<gameStartedAt)&&(puzzleMode)) {
-                FallDown();
-                nrFellDown--;
-            }
-            ReduceStuff();
-            if ((timetrial) && (!bGameOver) && (nowTime>gameStartedAt+2*60*1000)) {
-                SetGameOver();
-                if(!NoSound && SoundEnabled)Mix_PlayChannel(1,counterFinalChunk,0);
-                if ((theTopScoresTimeTrial.isHighScore(score))&&(!AI_Enabled)) {
-                    theTopScoresTimeTrial.addScore(name, score);
-                    //new highscore
-                    //Also check if it is better than the best result so far.
-                    string checkFilename = getPathToSaveFiles() + "/bestTTresult";
-                    ifstream inFile(checkFilename.c_str());
-                    Uint32 bestResult = 3000; //Never accept a best result under 3000
-                    if(inFile)
-                    {
-                        inFile >> bestResult;
-                        inFile.close();
-                    }
-                    if(score>bestResult)
-                    {
-                        string bestFile = getPathToSaveFiles() + "/bestTT";
-                        theReplay.saveReplay(bestFile);
-                        ofstream outFile(checkFilename.c_str(),ios::trunc);
-                        if(outFile)
-                            outFile << score;
-                    }
-                }
-            }
-        }
-        if ((!bGameOver)&&(!bReplaying)&&(nowTime>gameStartedAt))
-        {
-            //cout << nowTime << " bigger than " << gameStartedAt << endl;
-            theReplay.setFrameSecTo(nowTime-gameStartedAt, getPackage());
-        }
-        DoPaintJob();
-    }
-
+    void Update();
 public:
-    void Update(int newtick) {
-        ticks = newtick;
-        Update();
-    }
-}; //class BlockGame
+    void Update(int newtick);
+};
 ////////////////////////////////////////////////////////////////////////////////
 ///////////////////////// BlockAttack class end ////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
+
+#endif
diff --git a/source/code/block.make b/source/code/block.make
index 7cff0ef..02c2f9f 100644
--- a/source/code/block.make
+++ b/source/code/block.make
@@ -38,12 +38,15 @@ endif
 BASE_LIBS += -lphysfs
 
 $(BINARY): 	build/main.o build/highscore.o build/SFont.o build/ReadKeyboard.o build/joypad.o build/listFiles.o build/replay.o build/common.o build/stats.o 
-	$(CPP) -O -o $(BINARY) build/main.o build/highscore.o build/SFont.o build/ReadKeyboard.o build/joypad.o build/listFiles.o build/replay.o build/common.o build/stats.o $(BASE_LIBS)
+	$(CPP) -O -o $(BINARY) build/main.o build/highscore.o build/SFont.o build/ReadKeyboard.o build/joypad.o build/listFiles.o build/replay.o build/common.o build/stats.o  $(BASE_LIBS)
 #-lphysfs
 
-build/main.o:	main.cpp BlockGame.hpp mainVars.hpp common.h
+build/main.o:	main.cpp mainVars.hpp common.h
 	$(CPP) $(BASE_CFLAGS) main.cpp -o build/main.o
 
+#build/blockgame.o:	BlockGame.hpp BlockGame.cpp
+#	$(CPP) $(BASE_CFLAGS) BlockGame.cpp -o build/blockgame.o
+
 build/highscore.o: highscore.h highscore.cpp
 	$(CPP) $(BASE_CFLAGS) highscore.cpp -o build/highscore.o
 
diff --git a/source/code/main.cpp b/source/code/main.cpp
index 334d838..f093aac 100644
--- a/source/code/main.cpp
+++ b/source/code/main.cpp
@@ -1166,6 +1166,7 @@ textManeger theTextManeger;
 
 //Here comes the Block Game object
 #include "BlockGame.hpp"
+#include "BlockGame.cpp"
 #include "SFont.h"
 
 //writeScreenShot saves the screen as a bmp file, it uses the time to get a unique filename
diff --git a/source/code/mainVars.hpp b/source/code/mainVars.hpp
index 5045b80..93b4c11 100644
--- a/source/code/mainVars.hpp
+++ b/source/code/mainVars.hpp
@@ -29,18 +29,6 @@ Copyright (C) 2007 Poul Sander
 
 //main variables and constants
 
-//Some definitions
-//The game is divided in frames. FALLTIME means the blocks will fall one block every FRAMELENGTH*FALLTIME millisecond
-#define FRAMELENGTH 50
-#define HANGTIME 40
-#define FALLTIME 20
-//Don't change the following, they are fundamental and later some functions are hardcoded
-#define BLOCKFALL 10000
-#define BLOCKWAIT 100000
-#define BLOCKHANG 1000
-#define GARBAGE 1000000
-#define CHAINPLACE 10000000
-#define NUMBEROFCHAINS 100
 
 //Animation lengths:
 #define READYTIME 500
diff --git a/source/code/replay.h b/source/code/replay.h
index 1b7fdcb..23b9daa 100644
--- a/source/code/replay.h
+++ b/source/code/replay.h
@@ -29,6 +29,9 @@ replay is used to save a replay, there is saved 10 moves per second, should be
 able to give a realistic replay
 */
 
+#ifndef REPLAY_H
+#define REPLAY_H 1
+
 //constants - 3000 is 5 minutes
 #define FRAMESPERSEC 10
 
@@ -92,3 +95,5 @@ public:
 
 
 };
+
+#endif