import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.util.Random;
import javax.swing.*;

/* Random bits of info
Grid Size: 10 x 16
*/
public class RBlocks
{
    // Define global variables
//    static int[][] LevelGrid = new int[10][];
    static int[][] LevelGrid = new int[10][16];
    static int multipler = 0;
    static int score = 0;
    static int level = 1;
    static int lines = 0;
    static long prevTime;
    static boolean bDown = false;
    static boolean dead = false;
    static boolean pause = false;
    static boolean newgame = false;
    static JFrame frame;
    static Random rand = new Random(System.currentTimeMillis());
    static Blocks block = new Blocks();
    static LevelCanvas levelcanvas = new LevelCanvas();

    // Start here
    public static void main(String[] args)
    {
        // Initialize stuff
/*        for(int x = 0; x < 10; x++)
        {
            LevelGrid[x] = new int[16];
            for(int y = 0; y < 16; y++)
            {
                LevelGrid[x][y] = 0;
            }
        }
*/
        // Create Window
        JFrame.setDefaultLookAndFeelDecorated(true);
        frame = new JFrame("RBlocks");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(levelcanvas);

        frame.setBounds(0,0,330,290);
        frame.setVisible(true);
        levelcanvas.addKeyListener(new RBlocksKey());
        levelcanvas.requestFocusInWindow();
        
        // Init Game
        initGame();
    }
    public static void initGame()
    {
    	// Reset Grid
        for(int x = 0; x < 10; x++)
        {
            for(int y = 0; y < 16; y++)
            {
                LevelGrid[x][y] = 0;
            }
        }
        
        // Reset Vars
        dead = false;
        bDown = false;
        pause = false;
        newgame = false;
        multipler = 0;
        score = 0;
        lines = 0;
        level = 1;
        block.newBlock();
        score -= 1;

        prevTime = System.currentTimeMillis();
        
        gameLoop();
    }
    public static void gameLoop()
    {
        while(!dead)
        {
        	while(pause) { /* DO ABSOLUTELY NOTHING :) */ }
            // Don't let it run too fast
            if(level < 10)
                while(System.currentTimeMillis() - prevTime < (1000 - (level * 80)));
            else
                while(System.currentTimeMillis() - prevTime < 200);
            block.moveDown();
            prevTime = System.currentTimeMillis();
        }

        // Game Over
        levelcanvas.repaint();
        while(!newgame) { }
        initGame();
    }

    // Handle block-related stuff here like creating, collision detection, moving
    static class Blocks
    {
        private int curBlock = 0;
        private int nextBlock = 0;
        private int curDir = 0;
        private int curX = 0;
        private int curY = 0;
        public Blocks()
        {
        	nextBlock = rand.nextInt(7) + 1;
        }

        public void newBlock()
        {
            checkRows();
            bDown = false;
            curBlock = nextBlock;
            nextBlock = rand.nextInt(7) + 1;
            score += 1;
            switch(curBlock)
            {
                case 1:
                    curX = 4;
                    curY = 0;
                    if(LevelGrid[curX][curY] > 0 ||
                       LevelGrid[curX + 1][curY] > 0 ||
                       LevelGrid[curX + 2][curY] > 0 ||
                       LevelGrid[curX + 3][curY] > 0)
                        dead = true;
                    LevelGrid[curX][curY] = 1;
                    LevelGrid[curX + 1][curY] = 1;
                    LevelGrid[curX + 2][curY] = 1;
                    LevelGrid[curX + 3][curY] = 1;
                break;
                case 2:
                    curX = 5;
                    curY = 0;
                    if(LevelGrid[curX][curY] > 0 ||
                       LevelGrid[curX + 1][curY] > 0 ||
                       LevelGrid[curX][curY + 1] > 0 ||
                       LevelGrid[curX + 1][curY + 1] > 0)
                        dead = true;
                    LevelGrid[curX][curY] = 2;
                    LevelGrid[curX + 1][curY] = 2;
                    LevelGrid[curX][curY + 1] = 2;
                    LevelGrid[curX + 1][curY + 1] = 2;
                break;
                case 3:
                    curX = 4;
                    curY = 0;
                    if(LevelGrid[curX][curY] > 0 ||
                       LevelGrid[curX + 1][curY] > 0 ||
                       LevelGrid[curX + 1][curY + 1] > 0 ||
                       LevelGrid[curX + 2][curY + 1] > 0)
                        dead = true;
                    LevelGrid[curX][curY] = 3;
                    LevelGrid[curX + 1][curY] = 3;
                    LevelGrid[curX + 1][curY + 1] = 3;
                    LevelGrid[curX + 2][curY + 1] = 3;
                break;
                case 4:
                    curX = 4;
                    curY = 0;
                    if(LevelGrid[curX][curY + 1] > 0 ||
                       LevelGrid[curX + 1][curY] > 0 ||
                       LevelGrid[curX + 1][curY + 1] > 0 ||
                       LevelGrid[curX + 2][curY] > 0)
                        dead = true;
                    LevelGrid[curX][curY + 1] = 4;
                    LevelGrid[curX + 1][curY] = 4;
                    LevelGrid[curX + 1][curY + 1] = 4;
                    LevelGrid[curX + 2][curY] = 4;
                break;
                case 5:
                    curX = 4;
                    curY = 0;
                    if(LevelGrid[curX][curY] > 0 ||
                       LevelGrid[curX + 1][curY] > 0 ||
                       LevelGrid[curX + 2][curY] > 0 ||
                       LevelGrid[curX + 2][curY + 1] > 0)
                        dead = true;
                    LevelGrid[curX][curY] = 5;
                    LevelGrid[curX + 1][curY] = 5;
                    LevelGrid[curX + 2][curY] = 5;
                    LevelGrid[curX + 2][curY + 1] = 5;
                break;
                case 6:
                    curX = 4;
                    curY = 0;
                    if(LevelGrid[curX][curY] > 0 ||
                       LevelGrid[curX][curY + 1] > 0 ||
                       LevelGrid[curX + 1][curY] > 0 ||
                       LevelGrid[curX + 2][curY] > 0)
                        dead = true;
                    LevelGrid[curX][curY] = 6;
                    LevelGrid[curX][curY + 1] = 6;
                    LevelGrid[curX + 1][curY] = 6;
                    LevelGrid[curX + 2][curY] = 6;
                break;
                case 7:
                    curX = 4;
                    curY = 0;
                    if(LevelGrid[curX][curY] > 0 ||
                       LevelGrid[curX + 1][curY] > 0 ||
                       LevelGrid[curX + 2][curY] > 0 ||
                       LevelGrid[curX + 1][curY + 1] > 0)
                        dead = true;
                    LevelGrid[curX][curY] = 7;
                    LevelGrid[curX + 1][curY] = 7;
                    LevelGrid[curX + 2][curY] = 7;
                    LevelGrid[curX + 1][curY + 1] = 7;
                break;
            }
            curDir = 0;
            levelcanvas.repaint();
        }
        public void checkRows()
        {
            multipler = 0;
            for(int y = 15; y >= 0; y--)
            {
                if(LevelGrid[0][y] > 0 &&
                   LevelGrid[1][y] > 0 &&
                   LevelGrid[2][y] > 0 &&
                   LevelGrid[3][y] > 0 &&
                   LevelGrid[4][y] > 0 &&
                   LevelGrid[5][y] > 0 &&
                   LevelGrid[6][y] > 0 &&
                   LevelGrid[7][y] > 0 &&
                   LevelGrid[8][y] > 0 &&
                   LevelGrid[9][y] > 0)
                {
                    shiftDown(y);
                    lines += 1;
                    multipler += 1;
                    if((lines % 10) == 0)
                        level += 1;
                    y++; // Recheck row
                }
            }
            if(multipler > 0) // A line was formed
                score += 100 + (575 * (multipler - 1));
        }
        public void shiftDown(int startRow)
        {
            for(int y2 = startRow; y2 > 0; y2--)
            {
                for(int x = 0; x < 10; x++)
                {
                    LevelGrid[x][y2] = LevelGrid[x][y2 - 1];
                }
            }
            for(int x = 0; x < 10; x++)
                LevelGrid[x][0] = 0;
        }
        public int getNextBlock()
        {
        	return nextBlock;
        }
        public void moveLeft()
        {
            // If current X position is equal to 0.. no point in checking anything at all..
            // There will be no movement
            if(curX == 0)
                return;
            switch(curBlock)
            {
                case 1:
                    switch(curDir)
                    {
                        case 0:
                            if(LevelGrid[curX - 1][curY] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 3][curY] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX + 1][curY] = 1;
                            LevelGrid[curX + 2][curY] = 1;
                            LevelGrid[curX + 3][curY] = 1;
                        break;
                        case 1:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX - 1][curY + 2] > 0 ||
                               LevelGrid[curX - 1][curY + 3] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX][curY + 3] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX][curY + 1] = 1;
                            LevelGrid[curX][curY + 2] = 1;
                            LevelGrid[curX][curY + 3] = 1;
                        break;
                    }
                break;
                case 2:
                    // No need for curDir.. it only has 1 direction
                    if(LevelGrid[curX - 1][curY] > 0 ||
                       LevelGrid[curX - 1][curY + 1] > 0)
                        break;
                    LevelGrid[curX][curY] = 0;
                    LevelGrid[curX + 1][curY] = 0;
                    LevelGrid[curX][curY + 1] = 0;
                    LevelGrid[curX + 1][curY + 1] = 0;
                    curX -= 1;
                    LevelGrid[curX][curY] = 2;
                    LevelGrid[curX + 1][curY] = 2;
                    LevelGrid[curX][curY + 1] = 2;
                    LevelGrid[curX + 1][curY + 1] = 2;
                break;
                case 3:
                    switch(curDir)
                    {
                        case 0:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 3;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX + 2][curY + 1] = 3;
                        break;
                        case 1:
                            if(LevelGrid[curX][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX - 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curX -= 1;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX][curY + 1] = 3;
                            LevelGrid[curX][curY + 2] = 3;
                        break;
                    }
                break;
                case 4:
                    switch(curDir)
                    {
                        case 0:
                            if(LevelGrid[curX][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 2][curY] = 4;
                        break;
                        case 1:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 4;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 2] = 4;
                        break;
                    }
                break;
                case 5:
                    switch(curDir)
                    {
                        case 0:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 2][curY] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                        break;
                        case 1:
                            if(LevelGrid[curX][curY] > 0 ||
                               LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX - 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curX -= 1;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 2] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                        break;
                        case 2:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                        break;
                        case 3:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX - 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                        break;
                    }
                break;
                case 6:
                    switch(curDir)
                    {
                        case 0:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                        break;
                        case 1:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                        break;
                        case 2:
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                            LevelGrid[curX + 2][curY + 1] = 6;
                        break;
                        case 3:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX - 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX][curY + 2] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                        break;
                    }
                break;
                case 7:
                    switch(curDir)
                    {
                        case 0:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 2][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                        break;
                        case 1:
                            if(LevelGrid[curX][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX][curY + 2] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX -= 1;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 2] = 7;
                        break;
                        case 2:
                            if(LevelGrid[curX][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 2][curY + 1] = 7;
                        break;
                        case 3:
                            if(LevelGrid[curX - 1][curY] > 0 ||
                               LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX - 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curX -= 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX][curY + 2] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                        break;
                    }
                break;
            }
            levelcanvas.repaint();
        }
        public void moveRight()
        {
            switch(curBlock)
            {
                case 1:
                    switch(curDir)
                    {
                        case 0:
                            if(curX == 6)
                                break;
                            if(LevelGrid[curX + 4][curY] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 3][curY] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX + 1][curY] = 1;
                            LevelGrid[curX + 2][curY] = 1;
                            LevelGrid[curX + 3][curY] = 1;
                        break;
                        case 1:
                            if(curX == 9)
                                break;
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 3] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX][curY + 3] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX][curY + 1] = 1;
                            LevelGrid[curX][curY + 2] = 1;
                            LevelGrid[curX][curY + 3] = 1;
                        break;
                    }
                break;
                case 2:
                    // No need for curDir.. it only has 1 direction
                    if(curX == 8)
                        break;
                    if(LevelGrid[curX + 2][curY] > 0 ||
                       LevelGrid[curX + 2][curY + 1] > 0)
                        break;
                    LevelGrid[curX][curY] = 0;
                    LevelGrid[curX + 1][curY] = 0;
                    LevelGrid[curX][curY + 1] = 0;
                    LevelGrid[curX + 1][curY + 1] = 0;
                    curX += 1;
                    LevelGrid[curX][curY] = 2;
                    LevelGrid[curX + 1][curY] = 2;
                    LevelGrid[curX][curY + 1] = 2;
                    LevelGrid[curX + 1][curY + 1] = 2;
                break;
                case 3:
                    switch(curDir)
                    {
                        case 0:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 3][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 3;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX + 2][curY + 1] = 3;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curX += 1;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX][curY + 1] = 3;
                            LevelGrid[curX][curY + 2] = 3;
                        break;
                    }
                break;
                case 4:
                    switch(curDir)
                    {
                        case 0:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 3][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curX += 1;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 2][curY] = 4;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 4;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 2] = 4;
                        break;
                    }
                break;
                case 5:
                    switch(curDir)
                    {
                        case 0:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 3][curY] > 0 ||
                               LevelGrid[curX + 3][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 2][curY] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curX += 1;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 2] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                        break;
                        case 2:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX + 3][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                        break;
                        case 3:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                        break;
                    }
                break;
                case 6:
                    switch(curDir)
                    {
                        case 0:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 3][curY] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                        break;
                        case 2:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 3][curY] > 0 ||
                               LevelGrid[curX + 3][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                            LevelGrid[curX + 2][curY + 1] = 6;
                        break;
                        case 3:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX][curY + 2] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                        break;
                    }
                break;
                case 7:
                    switch(curDir)
                    {
                        case 0:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 3][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 2][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX += 1;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 2] = 7;
                        break;
                        case 2:
                            if(curX == 7)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 3][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 2][curY + 1] = 7;
                        break;
                        case 3:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX][curY + 2] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                        break;
                    }
                break;
            }
            levelcanvas.repaint();
        }
        public void moveDown()
        {
            switch(curBlock)
            {
                case 1:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 15)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX + 3][curY + 1] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 3][curY] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX + 1][curY] = 1;
                            LevelGrid[curX + 2][curY] = 1;
                            LevelGrid[curX + 3][curY] = 1;
                        break;
                        case 1:
                            if(curY == 12)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 4] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX][curY + 3] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX][curY + 1] = 1;
                            LevelGrid[curX][curY + 2] = 1;
                            LevelGrid[curX][curY + 3] = 1;
                        break;
                    }
                break;
                case 2:
                    // No need for curDir.. it only has 1 direction
                    if(curY == 14)
                    {
                        newBlock();
                        break;
                    }
                    if(LevelGrid[curX][curY + 2] > 0 ||
                       LevelGrid[curX + 1][curY + 2] > 0)
                    {
                        newBlock();
                        break;
                    }
                    LevelGrid[curX][curY] = 0;
                    LevelGrid[curX + 1][curY] = 0;
                    LevelGrid[curX][curY + 1] = 0;
                    LevelGrid[curX + 1][curY + 1] = 0;
                    curY += 1;
                    LevelGrid[curX][curY] = 2;
                    LevelGrid[curX + 1][curY] = 2;
                    LevelGrid[curX][curY + 1] = 2;
                    LevelGrid[curX + 1][curY + 1] = 2;
                break;
                case 3:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 3;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX + 2][curY + 1] = 3;
                        break;
                        case 1:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 3] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX][curY + 1] = 3;
                            LevelGrid[curX][curY + 2] = 3;
                        break;
                    }
                break;
                case 4:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curY += 1;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 2][curY] = 4;
                        break;
                        case 1:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 3] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 4;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 2] = 4;
                        break;
                    }
                break;
                case 5:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 2][curY] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                        break;
                        case 1:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 3] > 0 ||
                               LevelGrid[curX + 1][curY + 3] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 2] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                        break;
                        case 2:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                        break;
                        case 3:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 3] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                        break;
                    }
                break;
                case 6:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                        break;
                        case 1:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 3] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                        break;
                        case 2:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curY += 1;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                            LevelGrid[curX + 2][curY + 1] = 6;
                        break;
                        case 3:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 3] > 0 ||
                               LevelGrid[curX + 1][curY + 3] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX][curY + 2] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                        break;
                    }
                break;
                case 7:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 2][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                        break;
                        case 1:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 3] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 2] = 7;
                        break;
                        case 2:
                            if(curY == 14)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curY += 1;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 2][curY + 1] = 7;
                        break;
                        case 3:
                            if(curY == 13)
                            {
                                newBlock();
                                break;
                            }
                            if(LevelGrid[curX][curY + 3] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0)
                            {
                                newBlock();
                                break;
                            }
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX][curY + 2] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                        break;
                    }
                break;
            }
            levelcanvas.repaint();
            if(bDown)
            	moveDown();
        }
        public void rotate()
        {
            switch(curBlock)
            {
                case 1:
                    switch(curDir)
                    {
                        case 0:
                            if(curY < 2 || curY == 15)
                                break;
                            if(LevelGrid[curX + 1][curY - 2] > 0 ||
                               LevelGrid[curX + 1][curY - 1] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 3][curY] = 0;
                            curX += 1;
                            curY -= 2;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX][curY + 1] = 1;
                            LevelGrid[curX][curY + 2] = 1;
                            LevelGrid[curX][curY + 3] = 1;
                            curDir = 1;
                        break;
                        case 1:
                            if(curX == 0 || curX > 7)
                                break;
                            if(LevelGrid[curX - 1][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX][curY + 3] = 0;
                            curX -= 1;
                            curY += 2;
                            LevelGrid[curX][curY] = 1;
                            LevelGrid[curX + 1][curY] = 1;
                            LevelGrid[curX + 2][curY] = 1;
                            LevelGrid[curX + 3][curY] = 1;
                            curDir = 0;
                        break;
                    }
                break;
                case 2: // No rotating needed... thank god
                break;
                case 3:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 0)
                                break;
                            if(LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY - 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curY -= 1;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX][curY + 1] = 3;
                            LevelGrid[curX][curY + 2] = 3;
                            curDir = 1;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX][curY] = 3;
                            LevelGrid[curX + 1][curY] = 3;
                            LevelGrid[curX + 1][curY + 1] = 3;
                            LevelGrid[curX + 2][curY + 1] = 3;
                            curDir = 0;
                        break;
                    }
                break;
                case 4:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 0)
                                break;
                            if(LevelGrid[curX][curY] > 0 ||
                               LevelGrid[curX][curY - 1] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curY -= 1;
                            LevelGrid[curX][curY] = 4;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 1][curY + 2] = 4;
                            curDir = 1;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curY += 1;
                            LevelGrid[curX][curY + 1] = 4;
                            LevelGrid[curX + 1][curY] = 4;
                            LevelGrid[curX + 1][curY + 1] = 4;
                            LevelGrid[curX + 2][curY] = 4;
                            curDir = 0;
                        break;
                    }
                break;
                case 5:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 0)
                                break;
                            if(LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY - 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curY -= 1;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 2] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                            curDir = 1;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX][curY] > 0 ||
                               LevelGrid[curX][curY + 1] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX + 1][curY + 1] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                            curDir = 2;
                        break;
                        case 2:
                            if(curY == 14)
                                break;
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX][curY + 1] = 5;
                            LevelGrid[curX][curY + 2] = 5;
                            curDir = 3;
                        break;
                        case 3:
                            if(curX == 0)
                                break;
                            if(LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            curX -= 1;
                            curY += 1;
                            LevelGrid[curX][curY] = 5;
                            LevelGrid[curX + 1][curY] = 5;
                            LevelGrid[curX + 2][curY] = 5;
                            LevelGrid[curX + 2][curY + 1] = 5;
                            curDir = 0;
                        break;
                    }
                break;
                case 6:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 0)
                                break;
                            if(LevelGrid[curX][curY - 1] > 0 ||
                               LevelGrid[curX + 1][curY - 1] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            curY -= 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                            curDir = 1;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY] > 0 ||
                               LevelGrid[curX + 2][curY + 1] > 0 ||
                               LevelGrid[curX][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY + 1] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                            LevelGrid[curX + 2][curY + 1] = 6;
                            curDir = 2;
                        break;
                        case 2:
                            if(curY == 14)
                                break;
                            if(LevelGrid[curX + 1][curY] > 0 ||
                               LevelGrid[curX + 1][curY + 2] > 0 ||
                               LevelGrid[curX + 2][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX][curY + 2] = 6;
                            LevelGrid[curX + 1][curY + 2] = 6;
                            curDir = 3;
                        break;
                        case 3:
                            if(curX == 0)
                                break;
                            if(LevelGrid[curX - 1][curY + 1] > 0 ||
                               LevelGrid[curX - 1][curY + 2] > 0 ||
                               LevelGrid[curX + 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            curX -= 1;
                            curY += 1;
                            LevelGrid[curX][curY] = 6;
                            LevelGrid[curX][curY + 1] = 6;
                            LevelGrid[curX + 1][curY] = 6;
                            LevelGrid[curX + 2][curY] = 6;
                            curDir = 0;
                        break;
                    }
                break;
                case 7:
                    switch(curDir)
                    {
                        case 0:
                            if(curY == 0)
                                break;
                            if(LevelGrid[curX + 1][curY - 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 2][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curY -= 1;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 1][curY + 2] = 7;
                            curDir = 1;
                        break;
                        case 1:
                            if(curX == 8)
                                break;
                            if(LevelGrid[curX + 2][curY + 1] > 0)
                                break;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 1][curY + 2] = 0;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            LevelGrid[curX + 2][curY + 1] = 7;
                            curDir = 2;
                        break;
                        case 2:
                            if(curY == 14)
                                break;
                            if(LevelGrid[curX + 1][curY + 2] > 0)
                                break;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX + 1][curY] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            LevelGrid[curX + 2][curY + 1] = 0;
                            curX += 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX][curY + 1] = 7;
                            LevelGrid[curX][curY + 2] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            curDir = 3;
                        break;
                        case 3:
                            if(curX == 0)
                                break;
                            if(LevelGrid[curX - 1][curY + 1] > 0)
                                break;
                            LevelGrid[curX][curY] = 0;
                            LevelGrid[curX][curY + 1] = 0;
                            LevelGrid[curX][curY + 2] = 0;
                            LevelGrid[curX + 1][curY + 1] = 0;
                            curX -= 1;
                            curY += 1;
                            LevelGrid[curX][curY] = 7;
                            LevelGrid[curX + 1][curY] = 7;
                            LevelGrid[curX + 2][curY] = 7;
                            LevelGrid[curX + 1][curY + 1] = 7;
                            curDir = 0;
                        break;
                    }
                break;
            }
            levelcanvas.repaint();
        }
    }
    static class LevelCanvas extends JComponent
    {
        private BufferedImage bi;
        private Graphics2D big;
//        private Image b1, b2, b3, b4, b5, b6, b7;
        private boolean firstRun = true;
        
       	private Image b1 = Toolkit.getDefaultToolkit().getImage("block/b1.png");
        private Image b2 = Toolkit.getDefaultToolkit().getImage("block/b2.png");
        private Image b3 = Toolkit.getDefaultToolkit().getImage("block/b3.png");
        private Image b4 = Toolkit.getDefaultToolkit().getImage("block/b4.png");
        private Image b5 = Toolkit.getDefaultToolkit().getImage("block/b5.png");
        private Image b6 = Toolkit.getDefaultToolkit().getImage("block/b6.png");
        private Image b7 = Toolkit.getDefaultToolkit().getImage("block/b7.png");
//        public LevelCanvas()
//        {
//        	bi = (BufferedImage)createImage(320,256);
//       	big = bi.createGraphics();
//        }

        public void paint(Graphics g)
        {
            Graphics2D g2 = (Graphics2D)g;

            if(firstRun)
            {
/*            	b1 = Toolkit.getDefaultToolkit().getImage("block/b1.png");
            	b2 = Toolkit.getDefaultToolkit().getImage("block/b2.png");
            	b3 = Toolkit.getDefaultToolkit().getImage("block/b3.png");
            	b4 = Toolkit.getDefaultToolkit().getImage("block/b4.png");
            	b5 = Toolkit.getDefaultToolkit().getImage("block/b5.png");
            	b6 = Toolkit.getDefaultToolkit().getImage("block/b6.png");
            	b7 = Toolkit.getDefaultToolkit().getImage("block/b7.png");*/
                bi = (BufferedImage)createImage(320,256);
                big = bi.createGraphics();
                firstRun = false;
            }

            // Erase everything
            big.setColor(Color.BLACK);
            big.fillRect(0,0,320,256);
            // Draw playing area
            big.setColor(Color.WHITE);
            big.fillRect(0,0,160,256);
            // Draw the blocks
            for(int x = 0; x < 10; x++)
            {
                for(int y = 0; y < 16; y++)
                {
                    switch(LevelGrid[x][y])
                    {
/*                        case 0:
                        break;
                        case 1:
                        	big.drawImage(b1, x << 4, y << 4, null);
                        break;
                        case 2:
                        	big.drawImage(b2, x << 4, y << 4, null);
                        break;
                        case 3:
                        	big.drawImage(b3, x << 4, y << 4, null);
                        break;
                        case 4:
                        	big.drawImage(b4, x << 4, y << 4, null);
                        break;
                        case 5:
                        	big.drawImage(b5, x << 4, y << 4, null);
                        break;
                        case 6:
                        	big.drawImage(b6, x << 4, y << 4, null);
                        break;
                        case 7:
                        	big.drawImage(b7, x << 4, y << 4, null);
                        break;
*/                        case 0:
                        break;
                        case 1:
                            big.setColor(Color.RED);
                            big.fillRect(x << 4, y << 4, 16, 16);
                            big.setColor(Color.BLACK);
                            big.drawRect(x << 4, y << 4, 16, 16);
                        break;
                        case 2:
                            big.setColor(Color.CYAN);
                            big.fillRect(x << 4, y << 4, 16, 16);
                            big.setColor(Color.BLACK);
                            big.drawRect(x << 4, y << 4, 16, 16);
                        break;
                        case 3:
                            big.setColor(Color.GREEN);
                            big.fillRect(x << 4, y << 4, 16, 16);
                            big.setColor(Color.BLACK);
                            big.drawRect(x << 4, y << 4, 16, 16);
                        break;
                        case 4:
                            big.setColor(Color.YELLOW);
                            big.fillRect(x << 4, y << 4, 16, 16);
                            big.setColor(Color.BLACK);
                            big.drawRect(x << 4, y << 4, 16, 16);
                        break;
                        case 5:
                            big.setColor(Color.BLUE);
                            big.fillRect(x << 4, y << 4, 16, 16);
                            big.setColor(Color.BLACK);
                            big.drawRect(x << 4, y << 4, 16, 16);
                        break;
                        case 6:
                            big.setColor(Color.MAGENTA);
                            big.fillRect(x << 4, y << 4, 16, 16);
                            big.setColor(Color.BLACK);
                            big.drawRect(x << 4, y << 4, 16, 16);
                        break;
                        case 7:
                            big.setColor(Color.DARK_GRAY);
                            big.fillRect(x << 4, y << 4, 16, 16);
                            big.setColor(Color.BLACK);
                            big.drawRect(x << 4, y << 4, 16, 16);
                        break;
                    }
                }
            }
            // Draw Level, Lines, and Score
            big.setColor(Color.WHITE);
            big.drawString("Level: " + level, 200, 32);
            big.drawString("Lines: " + lines, 200, 64);
            big.drawString("Score: " + score, 200, 96);
            if(pause)
            	big.drawString("Paused", 200, 160);
            if(dead)
            {
                big.drawString("Game Over", 200, 128);
                big.drawString("Press N to start new game", 170, 144);
            }
            // Draw Next Block
            switch(block.getNextBlock())
            {
            	case 1:
            		big.setColor(Color.RED);
            		big.fillRect(208, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 192, 16, 16);
            		big.setColor(Color.RED);
            		big.fillRect(224, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 192, 16, 16);
            		big.setColor(Color.RED);
            		big.fillRect(240, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(240, 192, 16, 16);
            		big.setColor(Color.RED);
            		big.fillRect(256, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(256, 192, 16, 16);
            	break;
            	case 2:
            		big.setColor(Color.CYAN);
            		big.fillRect(208, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 176, 16, 16);
            		big.setColor(Color.CYAN);
            		big.fillRect(224, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 176, 16, 16);
            		big.setColor(Color.CYAN);
            		big.fillRect(208, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 192, 16, 16);
            		big.setColor(Color.CYAN);
            		big.fillRect(224, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 192, 16, 16);
            	break;
            	case 3:
            		big.setColor(Color.GREEN);
            		big.fillRect(208, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 176, 16, 16);
            		big.setColor(Color.GREEN);
            		big.fillRect(224, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 176, 16, 16);
            		big.setColor(Color.GREEN);
            		big.fillRect(224, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 192, 16, 16);
            		big.setColor(Color.GREEN);
            		big.fillRect(240, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(240, 192, 16, 16);
            	break;
            	case 4:
            		big.setColor(Color.YELLOW);
            		big.fillRect(208, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 192, 16, 16);
            		big.setColor(Color.YELLOW);
            		big.fillRect(224, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 192, 16, 16);
            		big.setColor(Color.YELLOW);
            		big.fillRect(224, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 176, 16, 16);
            		big.setColor(Color.YELLOW);
            		big.fillRect(240, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(240, 176, 16, 16);
            	break;
            	case 5:
            		big.setColor(Color.BLUE);
            		big.fillRect(208, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 176, 16, 16);
            		big.setColor(Color.BLUE);
            		big.fillRect(208, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 192, 16, 16);
            		big.setColor(Color.BLUE);
            		big.fillRect(224, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 192, 16, 16);
            		big.setColor(Color.BLUE);
            		big.fillRect(240, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(240, 192, 16, 16);
            	break;
            	case 6:
            		big.setColor(Color.MAGENTA);
            		big.fillRect(208, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 192, 16, 16);
            		big.setColor(Color.MAGENTA);
            		big.fillRect(224, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 192, 16, 16);
            		big.setColor(Color.MAGENTA);
            		big.fillRect(240, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(240, 192, 16, 16);
            		big.setColor(Color.MAGENTA);
            		big.fillRect(240, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(240, 176, 16, 16);
            	break;
            	case 7:
            		big.setColor(Color.DARK_GRAY);
            		big.fillRect(208, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(208, 192, 16, 16);
            		big.setColor(Color.DARK_GRAY);
            		big.fillRect(224, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 192, 16, 16);
            		big.setColor(Color.DARK_GRAY);
            		big.fillRect(224, 176, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(224, 176, 16, 16);
            		big.setColor(Color.DARK_GRAY);
            		big.fillRect(240, 192, 16, 16);
            		big.setColor(Color.BLACK);
            		big.drawRect(240, 192, 16, 16);
            	break;
            }
            // Draw the buffer image to the screen
            g2.drawImage(bi, 0, 0, null);
        }
    }
    static class RBlocksKey extends KeyAdapter
    {
        // Handle Movement Here
        public void keyPressed(KeyEvent e)
        {
        	if(e.getKeyCode() == KeyEvent.VK_ESCAPE)
            {
            	frame.dispose();
            	System.exit(0);
            }
        	if(e.getKeyCode() == KeyEvent.VK_N && pause == false)
        	{
        		dead = true;
        		newgame = true;
        	}
            if(dead)
                return;
            if(e.getKeyCode() == KeyEvent.VK_UP && pause == false)
                block.rotate();
            else if(e.getKeyCode() == KeyEvent.VK_DOWN && pause == false)
                block.moveDown();
            else if(e.getKeyCode() == KeyEvent.VK_LEFT && pause == false)
                block.moveLeft();
            else if(e.getKeyCode() == KeyEvent.VK_RIGHT && pause == false)
                block.moveRight();
            else if(e.getKeyCode() == KeyEvent.VK_SPACE)
            {
            	bDown = true;
            	block.moveDown();
            }
            else if(e.getKeyCode() == KeyEvent.VK_P)
            {
            	if(pause)
            		pause = false;
            	else
            		pause = true;
            	levelcanvas.repaint();
            }
        }
    }
}

