pastebin - collaborative debugging

package bufferedterrain;

import org.newdawn.slick.opengl.renderer.Renderer;
import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.Color;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;

public class Main extends BasicGame {

    Main()
    {
        super("Terrain Test");
    }

    private Input input;

    private int[][] terrain;

    private int columnToUpdate = 0;

    private int brushX, brushY;
    private boolean brushOn;
    private int brushType = -1;
    private boolean resetTime = true;
    private int mouseButton = 0;

    private int width = 400;
    private int height = 300;

    public static void main(String[] args) {
        try
        {
            AppGameContainer app = new AppGameContainer(new Main());
            app.setDisplayMode(800, 600, false);
            app.setFullscreen(false);
            app.setShowFPS(false);
            app.setClearEachFrame(false);
            app.setTargetFrameRate(60);
            app.start();
        }
        catch (SlickException e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void init(GameContainer container) throws SlickException
    {
        input = container.getInput();
        Renderer.setRenderer(Renderer.VERTEX_ARRAY_RENDERER);
        start();
    }

    @Override
    public void update(GameContainer container, int delta) throws SlickException
    {
        mouseButton = 0;
        int mX = (int) Math.floor(input.getMouseX() / 2);
        int mY = (int) Math.floor(input.getMouseY() / 2);
        if (input.isKeyPressed(Input.KEY_ESCAPE)) container.exit();
        if (input.isMouseButtonDown(Input.MOUSE_LEFT_BUTTON))
        {
            if (resetTime)
            {
                brushX = mX;
                brushY = mY;
                brushOn = true;
                brushType = -1;
                brushOn = true;
                resetTime = false;
                drawBrush(brushX, brushY);
            }
        }
        else
        {
            mouseButton ++;
        }
        if (input.isMouseButtonDown(Input.MOUSE_RIGHT_BUTTON))
        {
            if (resetTime)
            {
                brushX = mX;
                brushY = mY;
                brushOn = true;
                brushType = 0;
                brushOn = true;
                resetTime = false;
                drawBrush(brushX, brushY);
            }
        }
        else
        {
            mouseButton ++;
        }
        if (mouseButton == 2)
        {
            resetTime = true;
            brushOn = false;
        }
        if (brushOn)
        {
            while(brushX != mX && brushY != mY)
            {
                drawBrush(brushX, brushY);
                if (Math.abs(brushX - mX) >= (Math.abs(brushY - mY)))
                {
                    if (brushX < mX)
                    {
                        brushX ++;
                    }
                    if (brushX > mX)
                    {
                        brushX --;
                    }
                }
                else
                {
                    if (brushY < mY)
                    {
                        brushY ++;
                    }
                    if (brushY > mY)
                    {
                        brushY --;
                    }
                }
            }
        }
        for (int i = 0; i < width / 32; i++)
        {
            for (int x = columnToUpdate; x < columnToUpdate + 16; x++)
            {
                for (int y = height - 2; y >= 0; y--)
                {
                    if (terrain[x][y] > 0)
                    {
                        if (terrain[x][y+1] == 0)
                        {
                            terrain[x][y+1] = terrain[x][y];
                            terrain[x][y] = 0;
                        }
                        if (y + 1 < height - 2)
                        {
                            if (Math.random() * 2 > 1)
                            {
                                if (x + 1 < width)
                                {
                                    if (terrain[x+1][y] == 0)
                                    {
                                        terrain[x+1][y] = terrain[x][y];
                                        terrain[x][y] = 0;
                                    }
                                }
                            }
                            else
                            {
                                if (x - 1 >= 0)
                                {
                                    if (terrain[x-1][y] == 0)
                                    {
                                        terrain[x-1][y] = terrain[x][y];
                                        terrain[x][y] = 0;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            columnToUpdate += 16;
            if (columnToUpdate == width)
            {
                columnToUpdate = 0;
                terrain[75 + (int)(Math.random() * 32)-16][0] = 1;
                terrain[150 + (int)(Math.random() * 32)-16][0] = 2;
                terrain[225 + (int)(Math.random() * 32)-16][0] = 3;
                terrain[300 + (int)(Math.random() * 32)-16][0] = 4;
            }
        }
    }

    public void render(GameContainer container, Graphics g) throws SlickException
    {
        g.setColor(Color.black);
        g.fillRect(0, 0, 800, 600);
        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                if (terrain[x][y] != 0)
                {
                    switch(terrain[x][y])
                    {
                        case -1:
                        {
                            g.setColor(new Color(255, 100, 100));
                            break;
                        }
                        case 1:
                        {
                            g.setColor(Color.white);
                            break;
                        }
                        case 2:
                        {
                            g.setColor(Color.orange);
                            break;
                        }
                        case 3:
                        {
                            g.setColor(Color.blue);
                            break;
                        }
                        case 4:
                        {
                            g.setColor(Color.red);
                            break;
                        }
                    }
                    g.fillRect(x * 2, y * 2, 2, 2);
                }
            }
        }
    }

    private void drawBrush(int brushX, int brushY)
    {
        if (brushX >= 1 && brushX < width - 1 && brushY >= 1 && brushY < height - 1)
        {
            //Scripted brush
            terrain[brushX][brushY] = brushType;
            terrain[brushX + 1][brushY] = brushType;
            terrain[brushX + 1][brushY + 1] = brushType;
            terrain[brushX][brushY + 1] = brushType;
            terrain[brushX - 1][brushY] = brushType;
            terrain[brushX - 1][brushY - 1] = brushType;
            terrain[brushX][brushY - 1] = brushType;
            terrain[brushX + 1][brushY - 1] = brushType;
            terrain[brushX - 1][brushY + 1] = brushType;
        }
    }

    private void start()
    {
        terrain = new int[width][height];
    }
}