a,d로 움직이기

w로 회전

s로 빠르게 내려가기

한줄이 완성되면 없어지고 너무 높이 올라가면 게임오버

스코어는 블럭 설치는 1p, 한줄 완성은 2p

import pygame
import random
import time

# 초기 설정
pygame.init()
SCREEN_WIDTH, SCREEN_HEIGHT = 420, 720
BLOCK_SIZE = 30
COLUMNS = 10
ROWS = SCREEN_HEIGHT // BLOCK_SIZE
FPS = 60

# 색상 정의
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
COLORS = {
    "I": (173, 216, 230),
    "J": (0, 0, 255),
    "L": (255, 165, 0),
    "O": (255, 255, 0),
    "S": (0, 255, 0),
    "T": (128, 0, 128),
    "Z": (255, 0, 0)
}

# 블록 모양
SHAPES = {
    "I": [(0, 0), (0, 1), (0, 2), (0, 3)],
    "J": [(0, 0), (1, 0), (1, 1), (1, 2)],
    "L": [(0, 2), (0, 1), (0, 0), (1, 0)],
    "O": [(0, 0), (0, 1), (1, 1), (1, 0)],
    "S": [(0, 0), (1, 0), (1, 1), (2, 1)],
    "T": [(0, 1), (1, 1), (1, 0), (2, 1)],
    "Z": [(0, 1), (1, 1), (1, 0), (2, 0)]
}

# 화면 설정
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption('Tetris')

clock = pygame.time.Clock()
font = pygame.font.Font(None, 36)
game_over_font = pygame.font.Font(None, 72)

# 테트리스 블록 클래스
class Tetromino:
    def __init__(self, x, y, shape_type):
        self.x = x
        self.y = y
        self.shape = SHAPES[shape_type]
        self.color = COLORS[shape_type]

    def draw(self):
        for coord in self.shape:
            block_x = self.x + coord[0] * BLOCK_SIZE
            block_y = self.y + coord[1] * BLOCK_SIZE
            pygame.draw.rect(screen, self.color, (block_x, block_y, BLOCK_SIZE, BLOCK_SIZE))
            pygame.draw.rect(screen, WHITE, (block_x, block_y, BLOCK_SIZE, BLOCK_SIZE), 1)

    def move(self, dx, dy, fixed_blocks):
        new_x = self.x + dx * BLOCK_SIZE
        new_y = self.y + dy * BLOCK_SIZE

        for coord in self.shape:
            block_x = new_x + coord[0] * BLOCK_SIZE
            block_y = new_y + coord[1] * BLOCK_SIZE
            if block_x < 0 or block_x >= COLUMNS * BLOCK_SIZE:
                return False
            if block_y >= SCREEN_HEIGHT or (block_x, block_y) in fixed_blocks:
                return False

        self.x = new_x
        self.y = new_y
        return True

    def rotate(self, fixed_blocks):
        new_shape = [(-y, x) for x, y in self.shape]
        for coord in new_shape:
            block_x = self.x + coord[0] * BLOCK_SIZE
            block_y = self.y + coord[1] * BLOCK_SIZE
            if block_x < 0 or block_x >= COLUMNS * BLOCK_SIZE or block_y >= SCREEN_HEIGHT or (block_x, block_y) in fixed_blocks:
                return
        self.shape = new_shape

def clear_lines(fixed_blocks):
    block_positions = list(fixed_blocks.keys())
    rows = [y for _, y in block_positions]
    cleared_rows = []

    for y in range(0, SCREEN_HEIGHT, BLOCK_SIZE):
        if rows.count(y) == COLUMNS:
            cleared_rows.append(y)

    # 깜빡이는 줄 처리
    for _ in range(3):
        for row in cleared_rows:
            for x in range(0, COLUMNS * BLOCK_SIZE, BLOCK_SIZE):
                pygame.draw.rect(screen, WHITE, (x, row, BLOCK_SIZE, BLOCK_SIZE))
        pygame.display.flip()
        time.sleep(0.1)

    # 줄 제거
    for row in cleared_rows:
        for (x, y) in list(fixed_blocks.keys()):
            if y == row:
                del fixed_blocks[(x, y)]

    # 위에 있는 블록들을 한 칸 아래로 이동
    cleared_rows.sort()
    for row in cleared_rows:
        for (x, y) in list(fixed_blocks.keys()):
            if y < row:
                fixed_blocks[(x, y + BLOCK_SIZE)] = fixed_blocks.pop((x, y))

    return len(cleared_rows)

def main():
    running = True
    active_tetromino = None
    fixed_blocks = {}
    frame_count = 0
    score = 0
    fast_drop = False

    while running:
        screen.fill(BLACK)
        pygame.draw.line(screen, WHITE, (COLUMNS * BLOCK_SIZE, 0), (COLUMNS * BLOCK_SIZE, SCREEN_HEIGHT), 2)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            if event.type == pygame.KEYDOWN:
                if active_tetromino:
                    if event.key == pygame.K_a:
                        active_tetromino.move(-1, 0, fixed_blocks)
                    if event.key == pygame.K_d:
                        active_tetromino.move(1, 0, fixed_blocks)
                    if event.key == pygame.K_w:
                        active_tetromino.rotate(fixed_blocks)
                    if event.key == pygame.K_s:
                        fast_drop = True
            if event.type == pygame.KEYUP:
                if event.key == pygame.K_s:
                    fast_drop = False

        if active_tetromino is None:
            shape_type = random.choice(list(SHAPES.keys()))
            active_tetromino = Tetromino(COLUMNS // 2 * BLOCK_SIZE, 0, shape_type)

        frame_count += 1
        drop_speed = 3 if fast_drop else 10
        if frame_count % drop_speed == 0:
            if not active_tetromino.move(0, 1, fixed_blocks):
                for coord in active_tetromino.shape:
                    block_x = active_tetromino.x + coord[0] * BLOCK_SIZE
                    block_y = active_tetromino.y + coord[1] * BLOCK_SIZE
                    fixed_blocks[(block_x, block_y)] = active_tetromino.color
                active_tetromino = None
                score += 1  # 블록 고정 시 점수 증가
                score += clear_lines(fixed_blocks) * 2  # 한 줄 제거 시 점수 추가
                if any(y < 3 * BLOCK_SIZE for _, y in fixed_blocks.keys()):
                    screen.fill(BLACK)
                    game_over_text = game_over_font.render("GAME OVER!", True, WHITE)
                    score_text = font.render(f"Final Score: {score}", True, WHITE)
                    screen.blit(game_over_text, (SCREEN_WIDTH // 4, SCREEN_HEIGHT // 2 - 50))
                    screen.blit(score_text, (SCREEN_WIDTH // 4, SCREEN_HEIGHT // 2 + 20))
                    pygame.display.flip()
                    while True:
                        for event in pygame.event.get():
                            if event.type == pygame.QUIT:
                                pygame.quit()
                                return

        for (block_x, block_y), block_color in fixed_blocks.items():
            pygame.draw.rect(screen, block_color, (block_x, block_y, BLOCK_SIZE, BLOCK_SIZE))
            pygame.draw.rect(screen, WHITE, (block_x, block_y, BLOCK_SIZE, BLOCK_SIZE), 1)

        if active_tetromino:
            active_tetromino.draw()

        score_text = font.render(f"Score: {score}", True, WHITE)
        screen.blit(score_text, (COLUMNS * BLOCK_SIZE + 10, 10))

        pygame.display.flip()
        clock.tick(FPS)

    pygame.quit()

if __name__ == "__main__":
    main()

import random

import sys

# 초기화

pygame.init()

WIDTH, HEIGHT = 500, 700

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Falling Object Game with Shell and Bonobono")

clock = pygame.time.Clock()

# 색상

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

BLUE = (0, 150, 255)

RED = (255, 0, 0)

GREEN = (0, 200, 0)

# 글꼴

font = pygame.font.SysFont("Arial", 28)

input_font = pygame.font.SysFont("Arial", 24)

# 기본 설정

player_size = 50

player_speed = 7

object_size = 50 # 물체 크기 줄이기

object_speed = 6 # 물체 속도 높이기

# 위치

player_x = WIDTH // 2 - player_size // 2

player_y = HEIGHT - player_size - 10

object_x = random.randint(0, WIDTH - object_size)

object_y = 0

# 게임 변수

score = 0

misses = 0

level = 1

quiz_asked = False

quiz_active = False

quiz_answer = ""

quiz_result = None

correct_answers = ["usa", "united states", "america", "u.s.a."] # 정답 리스트

level_up_shown = False

level_up_message = ""

# 게임 루프

running = True

while running:

screen.fill(WHITE)

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

if quiz_active:

if event.type == pygame.KEYDOWN:

if event.key == pygame.K_RETURN:

if quiz_answer.strip().lower() in correct_answers: # 정답 처리

score += 2

quiz_result = "correct"

else:

score -= 2

quiz_result = "wrong"

quiz_active = False

elif event.key == pygame.K_BACKSPACE:

quiz_answer = quiz_answer[:-1]

else:

quiz_answer += event.unicode

# 키 조작

if not quiz_active:

keys = pygame.key.get_pressed()

if keys[pygame.K_LEFT] and player_x > 0:

player_x -= player_speed

if keys[pygame.K_RIGHT] and player_x < WIDTH - player_size:

player_x += player_speed

object_y += object_speed

# 충돌 감지

player_rect = pygame.Rect(player_x, player_y, player_size, player_size)

object_rect = pygame.Rect(object_x, object_y, object_size, object_size)

if player_rect.colliderect(object_rect):

score += 1

object_x = random.randint(0, WIDTH - object_size)

object_y = 0

object_speed += 0.2 # 물체 속도 상승

# 놓침 감지

if object_y > HEIGHT:

misses += 1

object_x = random.randint(0, WIDTH - object_size)

object_y = 0

object_speed += 0.2 # 물체 속도 상승

# 레벨 업 조건

if score >= 20 and level < 4:

level = 4

object_speed += 2

object_size = 30

player_size = 40

level_up_message = "Level 4 - Max Speed!"

level_up_shown = True

elif score >= 15 and level < 3:

level = 3

object_speed += 2

object_size = 40

player_size = 45

level_up_message = "Level 3 - Even Faster!"

level_up_shown = True

elif score >= 10 and level < 2:

level = 2

object_speed += 1

object_size = 45

player_size = 50

level_up_message = "Level 2 - Faster Objects!"

level_up_shown = True

# 퀴즈 출제

if score >= 5 and not quiz_asked:

quiz_active = True

quiz_asked = True

quiz_answer = ""

object_y = 0

# 게임 오버 조건

if misses >= 3:

game_over_text = font.render("Game Over: Too many misses!", True, RED)

screen.blit(game_over_text, (60, HEIGHT // 2))

pygame.display.flip()

pygame.time.delay(2000)

running = False

# 게임 클리어

if score > 25:

win_text = font.render("You Win! Well Done!", True, GREEN)

screen.blit(win_text, (100, HEIGHT // 2))

pygame.display.flip()

pygame.time.delay(2000)

running = False

# 그리기

pygame.draw.rect(screen, BLUE, (player_x, player_y, player_size, player_size)) # 플레이어 그리기 (보노보노 대신 사각형)

pygame.draw.rect(screen, BLACK, (object_x, object_y, object_size, object_size)) # 물체 그리기 (조개 대신 사각형)

# HUD

screen.blit(font.render(f"Score: {score}", True, BLACK), (10, 10))

screen.blit(font.render(f"Misses: {misses}/3", True, RED), (10, 50))

screen.blit(font.render(f"Level: {level}", True, BLACK), (10, 90))

# 레벨 업 메시지 표시

if level_up_shown:

msg = font.render(level_up_message, True, RED)

screen.blit(msg, (60, HEIGHT // 2 - 100))

pygame.display.flip()

pygame.time.delay(1500)

level_up_shown = False

# 퀴즈 UI

if quiz_active:

question = font.render("Which country will host the next Olympics?", True, BLACK)

input_box = pygame.Rect(40, HEIGHT // 2, 420, 40)

pygame.draw.rect(screen, WHITE, input_box)

pygame.draw.rect(screen, BLACK, input_box, 2)

input_text = input_font.render(quiz_answer, True, BLACK)

screen.blit(question, (20, HEIGHT // 2 - 50))

screen.blit(input_text, (input_box.x + 5, input_box.y + 5))

if quiz_result == "correct":

result_text = font.render("Correct! +2 points", True, GREEN)

screen.blit(result_text, (140, HEIGHT // 2 + 80))

elif quiz_result == "wrong":

result_text = font.render("Wrong! -2 points", True, RED)

screen.blit(result_text, (140, HEIGHT // 2 + 80))

pygame.display.flip()

clock.tick(60)

pygame.quit()

sys.exit()