테트리스 만들기(08) — 점수와 레벨

import random
import sys

import pygame

COLS, ROWS = 10, 20
CELL = 30
BOARD_WIDTH = COLS * CELL
SIDE_WIDTH = 180
WIDTH, HEIGHT = BOARD_WIDTH + SIDE_WIDTH, ROWS * CELL
FPS = 60

BACKGROUND = (18, 18, 24)
GRID = (40, 40, 52)
TEXT = (235, 235, 240)

SHAPES = {
    "I": [(0, 1), (1, 1), (2, 1), (3, 1)],
    "O": [(0, 0), (1, 0), (0, 1), (1, 1)],
    "T": [(1, 0), (0, 1), (1, 1), (2, 1)],
    "S": [(1, 0), (2, 0), (0, 1), (1, 1)],
    "Z": [(0, 0), (1, 0), (1, 1), (2, 1)],
    "J": [(0, 0), (0, 1), (1, 1), (2, 1)],
    "L": [(2, 0), (0, 1), (1, 1), (2, 1)],
}
SIZES = {"I": 4, "O": 2, "T": 3, "S": 3, "Z": 3, "J": 3, "L": 3}
COLORS = {
    "I": (0, 200, 220),
    "O": (230, 200, 0),
    "T": (160, 80, 200),
    "S": (80, 200, 80),
    "Z": (220, 60, 60),
    "J": (60, 100, 220),
    "L": (240, 140, 30),
}
LINE_SCORES = {1: 100, 2: 300, 3: 500, 4: 800}
KICKS = (0, -1, 1, -2, 2)


class Piece:
    def __init__(self, kind):
        self.kind = kind
        self.cells = list(SHAPES[kind])
        self.size = SIZES[kind]
        self.x = (COLS - self.size) // 2
        self.y = 0

    def positions(self, dx=0, dy=0, cells=None):
        if cells is None:
            cells = self.cells
        return [(self.x + cx + dx, self.y + cy + dy) for cx, cy in cells]

    def rotated(self):
        n = self.size
        return [(n - 1 - cy, cx) for cx, cy in self.cells]


def new_board():
    return [[None] * COLS for _ in range(ROWS)]


def fits(board, positions):
    for x, y in positions:
        if x < 0 or x >= COLS or y < 0 or y >= ROWS:
            return False
        if board[y][x] is not None:
            return False
    return True


def clear_lines(board):
    kept = [row for row in board if None in row]
    cleared = ROWS - len(kept)
    for _ in range(cleared):
        kept.insert(0, [None] * COLS)
    board[:] = kept
    return cleared


class Game:
    def __init__(self):
        self.board = new_board()
        self.piece = Piece(random.choice(list(SHAPES)))
        self.score = 0
        self.lines = 0
        self.level = 1
        self.drop_timer = 0

    def interval(self):
        return max(100, 800 - (self.level - 1) * 70)

    def move(self, dx, dy):
        if fits(self.board, self.piece.positions(dx, dy)):
            self.piece.x += dx
            self.piece.y += dy
            return True
        return False

    def rotate(self):
        cells = self.piece.rotated()
        for kick in KICKS:
            if fits(self.board, self.piece.positions(kick, 0, cells)):
                self.piece.cells = cells
                self.piece.x += kick
                return

    def soft_drop(self):
        if self.move(0, 1):
            self.score += 1
        else:
            self.lock()
        self.drop_timer = 0

    def lock(self):
        color = COLORS[self.piece.kind]
        for x, y in self.piece.positions():
            self.board[y][x] = color
        cleared = clear_lines(self.board)
        if cleared:
            self.score += LINE_SCORES[cleared] * self.level
            self.lines += cleared
            self.level = self.lines // 10 + 1
        self.piece = Piece(random.choice(list(SHAPES)))
        self.drop_timer = 0
        if not fits(self.board, self.piece.positions()):
            self.board = new_board()

    def update(self, dt):
        self.drop_timer += dt
        if self.drop_timer >= self.interval():
            self.drop_timer = 0
            if not self.move(0, 1):
                self.lock()


def handle_key(game, key):
    if key == pygame.K_LEFT:
        game.move(-1, 0)
    elif key == pygame.K_RIGHT:
        game.move(1, 0)
    elif key == pygame.K_DOWN:
        game.soft_drop()
    elif key in (pygame.K_UP, pygame.K_x):
        game.rotate()


def draw_cell(screen, x, y, color):
    rect = pygame.Rect(x * CELL, y * CELL, CELL, CELL)
    pygame.draw.rect(screen, color, rect.inflate(-2, -2))


def draw_text(screen, font, text, x, y):
    screen.blit(font.render(text, True, TEXT), (x, y))


def draw(screen, game, font):
    screen.fill(BACKGROUND)
    for x in range(COLS + 1):
        pygame.draw.line(screen, GRID, (x * CELL, 0), (x * CELL, HEIGHT))
    for y in range(ROWS + 1):
        pygame.draw.line(screen, GRID, (0, y * CELL), (BOARD_WIDTH, y * CELL))

    for y, row in enumerate(game.board):
        for x, color in enumerate(row):
            if color is not None:
                draw_cell(screen, x, y, color)

    color = COLORS[game.piece.kind]
    for x, y in game.piece.positions():
        draw_cell(screen, x, y, color)

    left = BOARD_WIDTH + 20
    draw_text(screen, font, f"SCORE {game.score}", left, 200)
    draw_text(screen, font, f"LINES {game.lines}", left, 240)
    draw_text(screen, font, f"LEVEL {game.level}", left, 280)


def main():
    pygame.init()
    pygame.display.set_caption("Tetris")
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()
    font = pygame.font.Font(None, 34)
    pygame.key.set_repeat(170, 50)
    game = Game()

    while True:
        dt = clock.tick(FPS)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                handle_key(game, event.key)
        game.update(dt)
        draw(screen, game, font)
        pygame.display.flip()


if __name__ == "__main__":
    main()