Saturday, 6 August 2016

Tetris Game program in java

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.Random;
import java.net.URL;
import java.net.MalformedURLException;

public class Tetris extends Applet {

//
// STATIC MEMBERS
//

private final static int INITIAL_DELAY = 1000;
private final static byte ROWS = 18;
private final static byte COLUMNS = 10;
private final static int EMPTY = -1;
private final static int DELETED_ROWS_PER_LEVEL = 5;
private final static Color PIECE_COLORS[] = {
new Color(0xFF00FF), // fucia
new Color(0xDC143C), // crimson
new Color(0x00CED1), // dark turquoise
new Color(0xFFD700), // gold
new Color(0x32CD32), // lime green
new Color(0x008080), // teal
new Color(0xFFA500), // orange
};
private final static Color BACKGROUND_COLORS[] = {
new Color(0xFFDAB9), // peachpuff
new Color(0xFFC0CB), // pink
new Color(0xFF99CC), // hot pink
new Color(0x0099CC), // sky blue
new Color(0x9966CC), // lavender
};
private final static Color BACKGROUND_COLOR = new Color(0x99FFCC);

//   *    **   *    *    *    *
//   *    *    *    **   **   **   **
//   *    *    **    *   *    *    **
//   *
//   0    1    2    3    4    5    6  
private final static boolean PIECE_BITS[][][] = {
{
{false, true, false, false},
{false, true, false, false},
{false, true, false, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, true, true, false},
{false, true, false, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, true, false, false},
{false, true, false, false},
{false, true, true, false},
},
{
{false, false, false, false},
{false, true, false, false},
{false, true, true, false},
{false, false, true, false},
},
{
{false, false, false, false},
{false, false, true, false},
{false, true, true, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, true, false, false},
{false, true, true, false},
{false, true, false, false},
},
{
{false, false, false, false},
{false, false, false, false},
{false, true, true, false},
{false, true, true, false},
},
};
private static boolean tmp_grid[][] = new boolean[4][4]; // scratch space
private static Random random = new Random();

private static class TetrisLabel extends Label {
private final static Font LABEL_FONT = new Font("Serif", Font.BOLD, 18);
private TetrisLabel(String text) {
super(text);
setFont(LABEL_FONT);
}
private void addValue(int val) {
setText(Integer.toString((Integer.parseInt(getText())) + val ));
}
}

//
// INSTANCE DATA
//

private int grid[][] = new int[ROWS][COLUMNS];
private int next_piece_grid[][] = new int[4][4];
private int num_rows_deleted = 0;
private GridCanvas game_grid = new GridCanvas(grid, true);
private GridCanvas next_piece_canvas = new GridCanvas(next_piece_grid, false);
private Timer timer;
private TetrisPiece cur_piece;
private TetrisPiece next_piece = randomPiece();
private TetrisSound sounds;// = new TetrisSound(this);
private TetrisLabel rows_deleted_label = new TetrisLabel("0");
private TetrisLabel level_label = new TetrisLabel("1");
private TetrisLabel score_label = new TetrisLabel("0");
private TetrisLabel high_score_label = new TetrisLabel("");
final Button start_newgame_butt = new TetrisButton("Start");
final Button pause_resume_butt = new TetrisButton("Pause");

//
// INNER CLASSES
//

private class TetrisButton extends Button {
public TetrisButton(String label) {
super(label);
}
public Dimension getPreferredSize() {
return new Dimension(120, super.getPreferredSize().height);
}
}

private class TetrisPiece {
private boolean squares[][];
private int type;
private Point position = new Point(3, -4); // -4 to start above top row
public int getX() { return position.x; }
public int getY() { return position.y; }
public void setX(int newx) { position.x = newx; }
public void setY(int newy) { position.y = newy; }
public void setPosition(int newx, int newy) { setX(newx); setY(newy); }

public TetrisPiece(int type) {
this.type = type;
this.squares = new boolean[4][4];
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
this.squares[i][j] = PIECE_BITS[type][i][j];
}

public boolean canStepDown() {
synchronized(timer) {
cut();
position.y++;
boolean OK = canPaste();
position.y--;
paste();
return OK;
}
}

public boolean canPaste() {
for(int i=0; i<4; i++) {
for(int j=0; j<4; j++) {
int to_x = j + position.x;
int to_y = i + position.y;
if(squares[i][j]) { // piece contains this square?
if(0 > to_x || to_x >= COLUMNS // square too far left or right?
|| to_y >= ROWS) // square off bottom?
{
return false;
// note: it's always considered OK to paste a square
// *above* the grid though attempting to do so does nothing.
// This allows the user to move a piece before it drops
// completely into view.
}
if(to_y >= 0 && grid[to_y][to_x] != EMPTY)
return false;
}
}
}
return true;
}

public void stepDown() {
position.y++;
}

public void cut() {
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
if(squares[i][j] && position.y+i>=0)
grid[position.y + i][position.x + j] = EMPTY;
}

/**
* Paste the color info of this piece into the given grid
*/
public void paste(int into[][]) {
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
if(squares[i][j] && position.y+i>=0)
into[position.y + i][position.x + j] = type;
}

/**
* No argument version assumes pasting into main game grid
*/
public void paste() {
paste(grid);
}

public void rotate() {
// copy the piece's data into a temp array
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
tmp_grid[i][j] = squares[i][j];
// copy back rotated 90 degrees
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
squares[j][i] = tmp_grid[i][3-j];
}
public void rotateBack() {
// copy originally saved version back
// this of course assumes this call was preceeded by
// a call to rotate() for the same piece
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
squares[i][j] = tmp_grid[i][j];
}

// this method is a bit of a hack to check for the case
// where a piece may be safely on the grid but have one or more
// rows of empty squares that are above the grid and therefore OK
public boolean isTotallyOnGrid() {
for(int i=0; i<4; i++) {
if(position.y + i >= 0)
return true; //everything from here down is on grid
// this row is above grid so look for non-empty squares
for(int j=0; j<4; j++)
if(squares[i][j])
return false;
}
System.err.println("TetrisPiece.isTotallyOnGrid internal error");
return false;
}
} // end class TetrisPiece


private class Timer extends Thread {
private long m_delay;
private boolean m_paused = true;
private boolean m_fast = false;
private ActionListener m_cb;
public Timer(long delay, ActionListener cb) {
setDelay(delay);
m_cb = cb;
}
public void setPaused(boolean pause) {
m_paused = pause;
if(m_paused) {
sounds.stopSoundtrack();
}
else {
sounds.playSoundtrack();
synchronized(this) {
this.notify();
}
}
}
public boolean isPaused() { return m_paused; }
public void setDelay(long delay) { m_delay = delay; }
public boolean isRunning() { return !m_paused; }
public void setFast(boolean fast) {
m_fast = fast;
if(m_fast) {
try {
this.checkAccess();
this.interrupt(); // no exception, so OK to interrupt
} catch(SecurityException se) {}
}
}
public boolean isFast() { return m_fast; }
public void faster() {
m_delay = (int)(m_delay * .9); //increase the speed exponentially in reverse
}
public void run() {
while(true) {
try {
sleep(m_fast ? 30 : m_delay);
} catch (Exception e) {}
if(m_paused) {
try {
synchronized(this) {
this.wait();
}
} catch(InterruptedException ie) {}
}
synchronized(this) {
m_cb.actionPerformed(null);
}
}
}
} // end class Timer

private class GridCanvas extends DoubleBufferedCanvas {
private int grid[][];
private boolean paint_background;
public GridCanvas(int[][] grid, boolean do_background) {
this.grid = grid;
paint_background = do_background;
clear();
}

private void clear() {
for(int i=0; i<grid.length; i++)
for(int j=0; j<grid[0].length; j++)
grid[i][j] = EMPTY;
}
public Dimension getPreferredSize() {
return new Dimension(grid[0].length * 30, grid.length * 30);
}
public void paint(Graphics g) {
g = this.startPaint(g); // returned g paints into offscreen image
int width = this.getSize().width;
int height = this.getSize().height;
g.clearRect(0, 0, width, height);
int cell_size, xstart, ystart;
double panel_aspect_ratio = (double)width/height;
double grid_aspect_ratio = (double)grid[0].length/grid.length;
if(panel_aspect_ratio > grid_aspect_ratio) {
// extra space on sides
cell_size = (int)((double)height/grid.length + 0.5);
xstart = (int)(width/2 - (grid[0].length/2.0 * cell_size + 0.5));
ystart = 0;
}
else {
// extra vertical space
cell_size = (int)((double)width/grid[0].length + 0.5);
xstart = 0;
ystart = (int)(height/2 - (grid.length/2.0 * cell_size + 0.5));
}
if(paint_background) {
g.setColor(BACKGROUND_COLORS[(num_rows_deleted / DELETED_ROWS_PER_LEVEL) % BACKGROUND_COLORS.length]);
g.fillRect(xstart, ystart, COLUMNS*cell_size, ROWS*cell_size);
}
for(int i=0; i<grid.length; i++) {
for(int j=0; j<grid[0].length; j++) {
if(grid[i][j] != EMPTY) {
g.setColor(PIECE_COLORS[grid[i][j]]);
int x = xstart + j*cell_size;
int y = ystart + i*cell_size;
g.fill3DRect(x, y, cell_size, cell_size, true);
}
}
}
this.endPaint(); // paints accumulated image in one shot
}
} // end class GridCanvas

private class TetrisSound {
private AudioClip soundTrack = null;
private AudioClip destroyRowSounds[] = new AudioClip[4];
private AudioClip gameOverSound = null;
private AudioClip getClip(String name) throws MalformedURLException {
URL soundFileUrl = new URL(getCodeBase(), name);
try {
AudioClip clip = getAudioClip(soundFileUrl);
return clip;
} catch(NullPointerException npe) {
System.err.println("exception " + npe);
return null;
}
}
public TetrisSound() {
//load sound files
try {
soundTrack          = getClip("theme.au");
destroyRowSounds[0] = getClip("quiteImpressive.au");
destroyRowSounds[1] = getClip("smashing.au");
destroyRowSounds[2] = getClip("yeahbaby.au");
destroyRowSounds[3] = getClip("great.au");
gameOverSound       = getClip("groovy.au");
}
catch (Exception e) {
System.err.println(e.getMessage());
}
}
public void playSoundtrack() {
if(soundTrack == null)
return;
soundTrack.loop();
}
public void playDestroyRows(int rows) {
int soundid = rows - 1;
if(0 > soundid || soundid >= destroyRowSounds.length || destroyRowSounds[soundid] == null)
return;
destroyRowSounds[soundid].play();
}
public void playGameOverSound() {
if(gameOverSound == null)
return;
gameOverSound.play();
}
public void stopSoundtrack() {
if(soundTrack == null)
return;
soundTrack.stop();
}
} // end class TetrisSound


//
// INSTANCE METHODS
//

private TetrisPiece randomPiece() {
int rand = Math.abs(random.nextInt());
return new TetrisPiece(rand % (PIECE_COLORS.length));
}

private void installNewPiece() {
next_piece_canvas.clear();
cur_piece = next_piece;
cur_piece.setPosition(3, -4); //-4 to start above top of grid
if(cur_piece.canPaste()) {
next_piece = randomPiece();
next_piece.setPosition(0, 0);
next_piece.paste(next_piece_grid);
next_piece_canvas.repaint();
}
else
gameOver();
}

private void gameOver() {
System.out.println("Game Over!");
timer.setPaused(true);
pause_resume_butt.setEnabled(false);
int score = Integer.parseInt(score_label.getText());
int high_score = high_score_label.getText().length() > 0 ?
Integer.parseInt(high_score_label.getText()) : 0;
if(score > high_score)
high_score_label.setText("" + score);
sounds.playGameOverSound();
}

private boolean rowIsFull(int row) {
for(int i=0; i<COLUMNS; i++)
if(grid[row][i] == EMPTY)
return false;
return true;
}

private int countFullRows() {
int n_full_rows = 0;
for(int i=0; i<ROWS; i++)
if(rowIsFull(i))
n_full_rows++;
return n_full_rows;
}

private void removeRow(int row) {
for(int j=0; j<COLUMNS; j++)
grid[row][j] = EMPTY;
for(int i=row; i>0; i--) {
for(int j=0; j<COLUMNS; j++) {
grid[i][j] = grid[i-1][j];
}
}
}

private void removeFullRows() {
int n_full = countFullRows();
score_label.addValue((int)(10 * Math.pow(2, n_full) - 10)); //give points exponentially
if(n_full == 0)
return;
sounds.playDestroyRows(n_full);
if(num_rows_deleted / DELETED_ROWS_PER_LEVEL != (num_rows_deleted+n_full) / DELETED_ROWS_PER_LEVEL) {
timer.faster();
level_label.addValue(n_full / DELETED_ROWS_PER_LEVEL + 1);
level_label.repaint();
}
rows_deleted_label.addValue(n_full);
num_rows_deleted += n_full;
for(int i=ROWS-1; i>=0; i--)
while(rowIsFull(i))
removeRow(i);
game_grid.repaint();
}

public void start() {
timer = new Timer(INITIAL_DELAY, new ActionListener() {
public void actionPerformed(ActionEvent ae) {
synchronized(timer) {
if(cur_piece.canStepDown()) {
cur_piece.cut();
cur_piece.stepDown();
cur_piece.paste();
if(timer.isFast())
score_label.addValue(1); // a small reward for using fast mode
}
else { // it hit something
timer.setFast(false);
if( ! cur_piece.isTotallyOnGrid())
gameOver();
else {
removeFullRows();
installNewPiece();
}
}
}
game_grid.repaint();
}
});
timer.start(); // pauses immediately
}

public void stop() {
pauseGame();
synchronized(timer){
timer.stop();
}
timer = null;
}

private void startGame() {
timer.setDelay(INITIAL_DELAY);
timer.setPaused(false);
start_newgame_butt.setLabel("Start New Game");
pause_resume_butt.setEnabled(true); // stays enabled from here on
pause_resume_butt.setLabel("Pause");
pause_resume_butt.validate();
sounds.playSoundtrack();
}

private void newGame() {
game_grid.clear();
installNewPiece();
num_rows_deleted = 0;
rows_deleted_label.setText("0");
level_label.setText("1");
score_label.setText("0");
startGame();
}

private void pauseGame() {
timer.setPaused(true);
pause_resume_butt.setLabel("Resume");
sounds.stopSoundtrack();
}

private void resumeGame() {
timer.setPaused(false);
pause_resume_butt.setLabel("Pause");
sounds.playSoundtrack();
}

public void init() {
sounds = new TetrisSound(); // NOTE: Must be initialized after Applet fully constructed!
installNewPiece();

pause_resume_butt.setEnabled(false);
start_newgame_butt.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
if(start_newgame_butt.getLabel().equals("Start"))
startGame();
else
newGame();
}
});
pause_resume_butt.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
if(pause_resume_butt.getLabel().equals("Pause"))
pauseGame();
else
resumeGame();
}
});

//create key listener for rotating, moving left, moving right
KeyListener key_listener = new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if(timer.isPaused()) //don't do anything if game is paused
return;
if (e.getKeyCode() == 37 || e.getKeyCode() == 39) { //left or right arrow pressed
int dir = e.getKeyCode() == 37 ? -1 : 1;
synchronized(timer) {
cur_piece.cut();
cur_piece.setX(cur_piece.getX() + dir); // try to move
if( ! cur_piece.canPaste())
cur_piece.setX(cur_piece.getX() - dir); // undo move
cur_piece.paste();
}
game_grid.repaint();
}
else if (e.getKeyCode() == 38) { //rotate
synchronized(timer) {
cur_piece.cut();
cur_piece.rotate();
if( ! cur_piece.canPaste())
cur_piece.rotateBack();
cur_piece.paste();
}
game_grid.repaint();
}
if (e.getKeyCode() == 40) { //down arrow pressed; drop piece
timer.setFast(true);
}
}
};

// add the key listener to all components that might get focus
// so that it'll work regardless of which has focus
start_newgame_butt.addKeyListener(key_listener);
pause_resume_butt.addKeyListener(key_listener);

Panel right_panel = new Panel(new GridLayout(3, 1));
right_panel.setBackground(BACKGROUND_COLOR);

Panel control_panel = new Panel();
control_panel.add(start_newgame_butt);
control_panel.add(pause_resume_butt);
control_panel.setBackground(BACKGROUND_COLOR);
right_panel.add(control_panel);

Panel tmp = new Panel(new BorderLayout());
tmp.add("North", new TetrisLabel("    Next Piece:"));
tmp.add("Center", next_piece_canvas);
tmp.setBackground(BACKGROUND_COLOR);
right_panel.add(tmp);

Panel stats_panel = new Panel(new GridLayout(4, 2));
stats_panel.add(new TetrisLabel("    Rows Deleted: "));
stats_panel.add(rows_deleted_label);
stats_panel.add(new TetrisLabel("    Level: "));
stats_panel.add(level_label);
stats_panel.add(new TetrisLabel("    Score: "));
stats_panel.add(score_label);
stats_panel.add(new TetrisLabel("    High Score: "));
stats_panel.add(high_score_label);
tmp = new Panel(new BorderLayout());
tmp.setBackground(BACKGROUND_COLOR);
tmp.add("Center", stats_panel);
right_panel.add(tmp);

// finaly, add all the main panels to the applet panel
this.setLayout(new GridLayout(1, 2));
this.add(game_grid);
this.add(right_panel);
this.setBackground(BACKGROUND_COLOR);
this.validate();
}


public static void main(String[] args) {

Frame frame = new Frame("Tetris");
Tetris tetris = new Tetris();
frame.add(tetris);
tetris.init();
tetris.start();

frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});

frame.setSize(489, 441);
frame.setResizable(false);
frame.setVisible(true);
}
} // end class Tetris


class DoubleBufferedCanvas extends Canvas {
private Image mActiveOffscreenImage = null;
private Dimension mOffscreenSize = new Dimension(-1,-1);
private Graphics mActiveOffscreenGraphics = null;
private Graphics mSystemGraphics = null;

DoubleBufferedCanvas() {
/*
this.addComponentListener(new ComponentAdapter() {
public void componentResized(ComponentEvent e) {
repaint();
}
});*/
}

  /**
  * NOTE: when extending applets:
* this overrides update() to *not* erase the background before painting
*/
public void update(Graphics g) {
paint(g);
}

public Graphics startPaint (Graphics sysgraph) {
mSystemGraphics = sysgraph;
// Initialize if this is the first pass or the size has changed
Dimension d = getSize();
if ((mActiveOffscreenImage == null) ||
(d.width != mOffscreenSize.width) ||
(d.height != mOffscreenSize.height))
{
mActiveOffscreenImage = createImage(d.width, d.height);
mActiveOffscreenGraphics = mActiveOffscreenImage.getGraphics();
mOffscreenSize = d;
mActiveOffscreenGraphics.setFont(getFont());
}
//mActiveOffscreenGraphics.clearRect(0, 0, mOffscreenSize.width, mOffscreenSize.height);
return mActiveOffscreenGraphics;
}

public void endPaint () {
// Start copying the offscreen image to this canvas
// The application will begin drawing into the other one while this happens
mSystemGraphics.drawImage(mActiveOffscreenImage, 0, 0, null);
}
}


Post a Comment