Chat GPT를 활용한 Java 언어 테트리스 게임 만들어보기!

Java로 완전한 Tetris 게임을 만들려면 상당한 양의 코드와 구현 세부 정보가 필요합니다. 그러나 기본 게임 메커니즘을 포함하는 단순화된 버전의 Tetris를 제공할 수 있습니다. 이것은 단순화된 버전이며 완전한 Tetris 게임의 모든 기능과 복잡성을 포함하지 않을 수 있습니다. 코드는 다음과 같습니다.

 

 

[ Testris Game Code ] 

 

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Tetris extends JPanel {

    private final int[][] tetromino = {
        {1, 1, 1, 1}, // I-shape
        {1, 1, 1, 0, 1}, // L-shape
        {1, 1, 1, 0, 0, 0, 1}, // J-shape
        {1, 1, 0, 0, 1, 1}, // Z-shape
        {1, 1, 0, 0, 0, 1, 1}, // S-shape
        {1, 1, 1, 0, 1, 0, 0}, // T-shape
        {0, 1, 1, 0, 1, 1}, // O-shape
    };

    private final Color[] tetrominoColors = {
        Color.cyan, Color.orange, Color.blue, Color.red, Color.green, Color.magenta, Color.yellow
    };

    private int[][] gameBoard;
    private int currentTetromino;
    private int currentX;
    private int currentY;

    public Tetris() {
        gameBoard = new int[20][10]; // 20 rows, 10 columns
        currentTetromino = (int) (Math.random() * tetromino.length);
        currentX = 4;
        currentY = 0;

        setPreferredSize(new Dimension(320, 640));
        setBackground(Color.black);
        addKeyListener(new TetrisKeyListener());
        setFocusable(true);
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        // Draw the game board
        for (int row = 0; row < 20; row++) {
            for (int col = 0; col < 10; col++) {
                if (gameBoard[row][col] != 0) {
                    g.setColor(tetrominoColors[gameBoard[row][col] - 1]);
                    g.fillRect(col * 32, row * 32, 32, 32);
                }
            }
        }

        // Draw the current tetromino
        g.setColor(tetrominoColors[currentTetromino]);
        for (int row = 0; row < tetromino[currentTetromino].length / 2; row++) {
            for (int col = 0; col < tetromino[currentTetromino][row * 2 + 1]; col++) {
                g.fillRect((currentX + col) * 32, (currentY + row) * 32, 32, 32);
            }
        }
    }

    public void update() {
        if (isValidMove(currentTetromino, currentX, currentY + 1)) {
            currentY++;
        } else {
            mergeTetromino();
            checkForLineClears();
            spawnNewTetromino();
        }

        repaint();
    }

    public boolean isValidMove(int tetrominoIndex, int x, int y) {
        for (int row = 0; row < tetromino[tetrominoIndex].length / 2; row++) {
            for (int col = 0; col < tetromino[tetrominoIndex][row * 2 + 1]; col++) {
                int blockX = x + col;
                int blockY = y + row;

                if (blockX < 0 || blockX >= 10 || blockY < 0 || blockY >= 20 || gameBoard[blockY][blockX] != 0) {
                    return false;
                }
            }
        }

        return true;
    }

    public void mergeTetromino() {
        for (int row = 0; row < tetromino[currentTetromino].length / 2; row++) {
            for (int col = 0; col < tetromino[currentTetromino][row * 2 + 1]; col++) {
                if (tetromino[currentTetromino][row * 2 + col] != 0) {
                    gameBoard[currentY + row][currentX + col] = currentTetromino + 1;
                }
            }
        }
    }

    public void checkForLineClears() {
        for (int row = 0; row < 20; row++) {
            boolean lineClear = true;
            for (int col = 0; col < 10; col++) {
                if (gameBoard[row][col] == 0) {
                    lineClear = false;
                    break;
                }
            }
            if (lineClear) {
                removeLine(row);
            }
        }
    }

    public void removeLine(int row) {
        for (int i = row; i > 0; i--) {
            for (int j = 0; j < 10; j++) {
                gameBoard[i][j] = gameBoard[i - 1][j];
            }
        }
        for (int j = 0; j < 10; j++) {
            gameBoard[0][j] = 0;
        }
    }

    public void spawnNewTetromino() {
        currentTetromino = (int) (Math.random() * tetromino.length);
        currentX = 4;
        currentY = 0;

        if (!isValidMove(currentTetromino, currentX, currentY)) {
            // Game over
            // Implement game over logic here
        }
    }

    private class TetrisKeyListener implements KeyListener {

        @Override
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_LEFT && isValidMove(currentTetromino, currentX - 1, currentY)) {
                currentX--;
            } else if (e.getKeyCode() == KeyEvent.VK_RIGHT && isValidMove(currentTetromino, currentX + 1, currentY)) {
                currentX++;
            } else if (e.getKeyCode() == KeyEvent.VK_DOWN && isValidMove(currentTetromino, currentX, currentY + 1)) {
                currentY++;
            }

            repaint();
        }

        @Override
        public void keyReleased(KeyEvent e) {
            // Do nothing
        }

        @Override
        public void keyTyped(KeyEvent e) {
            // Do nothing
        }
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Tetris");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(new Tetris());
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}