Tetris/src/Tetris/Board.java

package Tetris;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;
import javax.swing.JPanel;
import javax.swing.Timer;

//Ewen Kerbs,Zhe Wang-Holkenbrink
public class Board extends JPanel implements KeyListener {
    private static int FPS = 60;
    private static int delay = FPS / 1000;

    //Spielfeld Breite und Länge
    public static final int BOARD_WIDTH = 11;
    public static final int BOARD_HEIGHT = 20;
    public static final int BLOCK_SIZE = 30;

    private Timer loop;
    private Color[][] board = new Color[BOARD_HEIGHT][BOARD_WIDTH];
    private Stein[] steine = new Stein[7];
    private Stein currenStein;
    private Random ran;
    private boolean gameOver = false;

    // Steinfarben
    private Color[] colors = {Color.decode("#ff00bf"), Color.decode("#0000ff"), Color.decode("#00ff80"), Color.decode("#ff8000"), Color.decode("#ffb3b3"),
            Color.decode("#8000ff"), Color.decode("#ff0040"),};


    // Steinform
    public Board() {
        ran = new Random();
        steine[0] = new Stein(new int[][]{
                {1, 1, 1},
                {0, 1, 0},

        }, this, colors[0]);
        steine[1] = new Stein(new int[][]{
                {1, 1},
                {1, 1}

        }, this, colors[1]);
        steine[2] = new Stein(new int[][]{
                {1, 1, 1},
                {1, 0, 0}
        }, this, colors[2]);
        steine[3] = new Stein(new int[][]{
                {1, 1, 1},
                {0, 0, 1}
        }, this, colors[3]);
        steine[4] = new Stein(new int[][]{
                {0, 1, 1},
                {1, 1, 0}
        }, this, colors[4]);
        steine[5] = new Stein(new int[][]{
                {1, 1, 0},
                {0, 1, 1}
        }, this, colors[5]);
        steine[6] = new Stein(new int[][]{
                {1, 1, 1, 1}
        }, this, colors[6]);

        currenStein = steine[0];

        loop = new Timer(delay, new ActionListener() {
            int n = 0;

            @Override
            public void actionPerformed(ActionEvent e) {
                update();
                repaint();
                //System.out.println(n++);
            }
        });
        loop.start();
    }

    private void update() {
        if (spielbeenden()) {
            loop.stop();
            return;
        }
        currenStein.update();
    }

    private boolean spielbeenden() {
        if (!gameOver) {
            for (int i = 0; i < currenStein.getCoords().length; i++) {
                for (int j = 0; j < currenStein.getCoords()[0].length; j++) {
                    if (currenStein.getCoords()[i][j] != 0) {
                        if (board[currenStein.getY() + i][currenStein.getX() + j] != null) {
                            gameOver = true;
                        }
                    }
                }
            }
        }
        return false;
    }


    public void setCurrenStein() {
        currenStein = steine[ran.nextInt(steine.length)];
        currenStein.reset();
    }

    public Stein getCurrenStein() {
        return currenStein;
    }

    public Color[][] getBoard() {
        return board;
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(Color.lightGray);

        currenStein.render(g);

        for (int row = 0; row < board.length; row++) {
            for (int col = 0; col < board[row].length; col++) {
                if (board[row][col] != null) {
                    g.setColor(board[row][col]);
                    //
                    g.fillRect(col * BLOCK_SIZE, row * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
                }
            }
        }

        //linien mit 2-Forschleife


        for (int row = 0; row < BOARD_HEIGHT + 1; row++) {
            g.drawLine(0, BLOCK_SIZE * row, BLOCK_SIZE * BOARD_WIDTH, BLOCK_SIZE * row);
        }
        for (int col = 0; col < BOARD_WIDTH + 1; col++) {
            g.drawLine(col * BLOCK_SIZE, 0, col * BLOCK_SIZE, BLOCK_SIZE * BOARD_HEIGHT);}
        if (gameOver) {
            String gameOverString = "GAME OVER";
            g.setColor(Color.GREEN);
            g.setFont(new Font("SANS_SERIF", Font.BOLD, 30));
            g.drawString(gameOverString, 50, GameGui.height / 2);
        }
    }


    @Override
    public void keyTyped(KeyEvent e) {

    }

    //Tastatur eingabe zur steinbewegung
    //wang/kerbs
    @Override
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_SPACE) {
            currenStein.speedup();
        } else if (e.getKeyCode() == KeyEvent.VK_D) {
            currenStein.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_A) {
            currenStein.moveLeft();
        } else if (e.getKeyCode() == KeyEvent.VK_W) {
            currenStein.steinRotiert();
        }

    }

    @Override
    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_SPACE) {
            currenStein.speedDown();
        }
    }
}