Project) 오락실 Pang 게임 만들기

jusung-c·2020년 9월 17일
0

##################################################################
나도 코딩 강의를 듣고 정리한 내용입니다.
출처 : 나도코딩 https://www.youtube.com/channel/UC7iAOLiALt2rtMVAWWl4pnw
##################################################################



[게임 조건]

  1. 캐릭터는 화면 아래에 위치, 좌우로만 이동 가능
  2. 스페이스를 누르면 무기를 쏘아 올림
  3. 큰 공 1개가 나타나서 바운스
  4. 무기에 닿으면 공은 작은 크기 2개로 분할, 가장 작은 크기의 공은 사라짐
  5. 모든 공을 없애면 게임 종료 (성공)
  6. 캐릭터는 공에 닿으면 게임 종료 (실패)
  7. 시간 제한 99초 초과 시 게임 종료 (실패)
  8. FPS는 30으로 고정 (필요시 speed 값을 조정)

[게임 이미지]

  1. 배경 : 640 * 480 (가로 세로) - background.png
  2. 무대 : 640 * 50 - stage.png
  3. 캐릭터 : 60 * 33 - character.png
  4. 무기 : 20 * 430 - weapon.png
  5. 공 : 160 * 160, 80 * 80, 40 * 40, 20 * 20 - ballon1.png ~ balloon4.png

배경과 캐릭터

# 1. 사용자 게임 초기화 (배경 화면, 게임 이미지, 좌표, 속도, 폰트 등)
current_path = os.path.dirname(__file__)  # 현재 파일의 위치 반환
image_path = os.path.join(current_path, "images")  # images 폴더 위치 반환

# 배경 만들기
import os
background=pygame.image.load(os.path.join(image_path, "background.png"))

# 스테이지 만들기
stage = pygame.image.load(os.path.join(image_path, "stage.png"))
stage_size = stage.get_rect().size
stage_height = stage_size[1]  # 스테이지의 높이 위에 캐릭터를 두기 위해 사용

# 캐릭터 만들기
character = pygame.image.load(os.path.join(image_path, "character.png"))
character_size = character.get_rect().size
character_width = character_size[0]
character_height = character_size[1]
character_x_pos = (screen_width/2) - (character_width/2)
character_y_pos = screen_height - stage_height - character_height
  • 이벤트 loop 속 화면 그리기
# 5. 화면에 그리기
    screen.blit(background, (0, 0))
    screen.blit(stage, (0, screen_height - stage_height))
    screen.blit(character, (character_x_pos, character_y_pos))

무기와 키보드 이벤트

  • 캐릭터 이동 처리
# 캐릭터 이동 방향
character_to_x = 0

# 캐릭터 이동 속도
character_speed = 5
    # 2. 이벤트 처리 (키보드, 마우스 등 )
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                character_to_x -= character_speed
            elif event.key == pygame.K_RIGHT:
                character_to_x += character_speed
        if event.type == pygame.KEYUP:
            if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
                character_to_x = 0

    # 3. 게임 캐릭터 위치 정의
    character_x_pos += character_to_x

    if character_x_pos < 0:
        character_x_pos = 0
    elif character_x_pos > screen_width - character_width:
        character_x_pos = screen_width - character_width
  • 무기와 무기 발사
# 무기 만들기
weapon = pygame.image.load(os.path.join(image_path, "weapon.png"))
weapon_size = weapon.get_rect().size
weapon_width = weapon_size[0]

# 무기는 한 번에 여러 발 발사 가능
weapons = []

# 무기 이동 속도
weapon_speed = 10
if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                character_to_x -= character_speed
            elif event.key == pygame.K_RIGHT:
                character_to_x += character_speed
            elif event.key == pygame.K_SPACE:
                weapon_x_pos = character_x_pos + \
                    (character_width/2) - (weapon_width/2)
                weapon_y_pos = character_y_pos
                weapons.append([weapon_x_pos, weapon_y_pos])
# 무기 위치를 위로 발사되도록 조정
    weapons = [[w[0], w[1] - weapon_speed] for w in weapons]  

for weapon_x_pos, weapon_y_pos in weapons:
        screen.blit(weapon, (weapon_x_pos, weapon_y_pos))
  • 문제 발생
  1. 무기가 캐릭터, 스테이지 위로 발사됨
    -> 화면에 그리기 부분에서 코드 순서대로 화면에 그려지기 때문. 무기 그리는 구문을 캐릭터, 스테이지 그리기 구문보다 앞 순서로 옮겨주어 해결
# 5. 화면에 그리기
    screen.blit(background, (0, 0))
    for weapon_x_pos, weapon_y_pos in weapons:
        screen.blit(weapon, (weapon_x_pos, weapon_y_pos))
    screen.blit(stage, (0, screen_height - stage_height))
    screen.blit(character, (character_x_pos, character_y_pos))
  1. 무기가 끝에 닿아도 안사라짐
    -> 무기의 y 좌표가 0보다 작다는 것은 화면을 벗어났다는 뜻이으로 제거해주는 구문 추가
# 천장에 닿은 무기 없애기
    weapons = [ [ w[0], w[1] ] for w in weapons if w[1] > 0 ]

공만들기

# 공 만들기 (4개 크기에 대해 따로 처리)
ball_images = [
    pygame.image.load(os.path.join(image_path, "balloon1.png")),
    pygame.image.load(os.path.join(image_path, "balloon2.png")),
    pygame.image.load(os.path.join(image_path, "balloon3.png")),
    pygame.image.load(os.path.join(image_path, "balloon4.png"))
]


# 공 크기에 따른 최초 스피드
ball_speed_y = [-18, -15, -12, -9] # index 0, 1, 2, 3 에 해당하는 값
# -가 붙은 이유는 공이 튀겼을 때 올라갈 때 y값이 -를 해줘야 하기 때문이다.


# 공들
balls = []

# 최초 발생하는 큰 공 추가
balls.append({
    "pos_x" : 50, # 공의 x 좌표
    "pos_y" : 50, # 공의 y 좌표
    "img_idx" : 0, # 공의 이미지 인덱스
    "to_x" : 3, # x축 이동방향. -3이면 왼쪽 3이면 오른쪽으로
    "to_y" : -6, # y축 이동방향. 
    "init_spd_y" : ball_speed_y[0] }) # y 최초 속도

공 튕기기

  • 이벤트 loop에 공 튀기기 구문
# 공 위치 정의
    for ball_idx, ball_val in enumerate(balls):
        ball_pos_x = ball_val["pos_x"]
        ball_pos_y = ball_val["pos_y"]
        ball_img_idx = ball_val["img_idx"]

        ball_size = ball_images[ball_img_idx].get_rect().size
        ball_width = ball_size[0]
        ball_height = ball_size[1]

        # 가로벽에 닿았을 때 공 이동 위치 변경 (튕겨 나오는 효과)
        if ball_pos_x < 0 or ball_pos_x > screen_width - ball_width:
            ball_val["to_x"] = ball_val["to_x"] * -1

        # 세로 위치
        # 스테이지에 튕겨서 올라가는 처리
        if ball_pos_y >= screen_height - stage_height - ball_height:
            ball_val["to_y"] = ball_val["init_spd_y"]
        else:  # 그 외의 모든 경우에는 속도를 증가 (포물선)
            ball_val["to_y"] += 0.5

        ball_val["pos_x"] += ball_val["to_x"]
        ball_val["pos_y"] += ball_val["to_y"]
  • 화면에 표시해주기
for idx, val in enumerate(balls):
        ball_pos_x = val["pos_x"]
        ball_pos_y = val["pos_y"]
        ball_img_idx = val["img_idx"]
        screen.blit(ball_images[ball_img_idx], (ball_pos_x, ball_pos_y))

충돌 처리

  • 캐릭터와 공 충돌하면 게임 종료
  • 공과 무기들 충돌하면 공과 충돌한 무기 사라짐
# 사라질 무기, 공 정보 저장 변수
weapon_to_remove = -1
ball_to_remove = -1

# 캐릭터 rect 정보 업데이트
    character_rect = character.get_rect()
    character_rect.left = character_x_pos
    character_rect.top = character_y_pos

    for ball_idx, ball_val in enumerate(balls):
        ball_pos_x = ball_val["pos_x"]
        ball_pos_y = ball_val["pos_y"]
        ball_img_idx = ball_val["img_idx"]

        # 공 rect 정보 업데이트
        ball_rect = ball_images[ball_img_idx].get_rect()
        ball_rect.left = ball_pos_x
        ball_rect.top = ball_pos_y

        # 공과 캐릭터 충돌 처리
        if character_rect.colliderect(ball_rect):
            running = False
            break

        # 공과 무기들 충돌 처리
        for weapon_idx, weapon_val in enumerate(weapons):
            weapon_pos_x = weapon_val[0]
            weapon_pos_y = weapon_val[1]

            # 무기 rect 정보 업데이트
            weapon_rect = weapon.get_rect()
            weapon_rect.left = weapon_pos_x
            weapon_rect.top = weapon_pos_y

            # 충돌 체크
            if weapon_rect.colliderect(ball_rect):
                # 해당 무기 없애기 위한 값 설정
                weapon_to_remove = weapon_idx  
                # 해당 공 없애기 위한 값 설정
                ball_to_remove = ball_idx  
                break

    # 충돌된 공 or 무기 없애기
    if ball_to_remove > -1:
        del balls[ball_to_remove]
        ball_to_remove = -1

    if weapon_to_remove > -1:
        del weapons[weapon_to_remove]
        weapon_to_remove = -1

공 쪼개기

# 충돌 체크
if weapon_rect.colliderect(ball_rect):
    weapon_to_remove = weapon_idx  # 해당 무기 없애기 위한 값 설정
    ball_to_remove = ball_idx  # 해당 공 없애기 위한 값
    
    # 가장 작은 공이 아니라면 다음 단게의 공으로 나눠주기
    if ball_img_idx < 3:
    	# 현재 공 크기 정보를 가지고 옴
        ball_width = ball_rect.size[0]
        ball_height = ball_rect.size[1]
        
        # 나눠진 공 정보
        small_ball_rect= ball_images[ball_img_idx + 1].get_rect()
        small_ball_width= small_ball_rect.size[0]
        small_ball_height= small_ball_rect.size[1]

        # 왼쪽으로 튕겨나가는 작은 공
        balls.append({
            "pos_x": ball_pos_x + ball_width/2 - small_ball_width/2,
            "pos_y": ball_pos_y + ball_height/2 - small_ball_height/2,
            "img_idx": ball_img_idx + 1,  # 공의 이미지 인덱스
            "to_x": -3,  # x축 이동방향. -3이면 왼쪽 3이면 오른쪽으로
            "to_y": -6,  # y축 이동방향.
            "init_spd_y": ball_speed_y[ball_img_idx + 1]
            
        # 오른쪽으로 튕겨나가는 작은 공
        balls.append({
            "pos_x": ball_pos_x + ball_width/2 - small_ball_width/2,
            "pos_y": ball_pos_y + ball_height/2 - small_ball_height/2,
            "img_idx": ball_img_idx + 1,  # 공의 이미지 인덱스
            "to_x": 3,  # x축 이동방향. -3이면 왼쪽 3이면 오른쪽으로
            "to_y": -6,  # y축 이동방향.
            "init_spd_y": ball_speed_y[ball_img_idx + 1]})
    break

게임 오버

    1. 모든 공을 없애면 게임 종료 (성공)
    1. 캐릭터는 공에 닿으면 게임 종료 (실패)
      -> 이미 충돌 처리에서 작성함
    1. 시간 제한 99초 초과 시 게임 종료 (실패)
# 게임 종료 메시지
game_result = "Game Over"
# 시간 초과했다면
    if total_time - elapsed_time < 0:
        game_result = "Time Over"
        running = False
# 모든 공을 없앤 경우 게임 종료 (성공)
    if not balls:
        game_result = "Mission Complete!"
        running = False
# 게임 오버 메시지
msg = game_font.render(game_result, True, (255, 255, 0))  # 노란색
msg_rect = msg.get_rect(center=(int(screen_width/2), int(screen_height/2)))
screen.blit(msg, msg_rect)
pygame.display.update()

버그 수정

  • 가끔 공에 무기를 맞혀도 공이 사라지지 않고 공 1개만 생기는 버그
balls = [1, 2, 3, 4]
weapons = [11, 22, 3, 44]

for ball_idx, ball_val in enumerate(balls):
    print("ball : ", ball_val)
    for weapon_idx, weapon_val in enumerate(weapons):
        print("weapons : ", weapon_val)
        if ball_val == weapon_val:
            print("공과 무기가 충돌")
            break
  • 3에서 충돌하면 멈추길 기대했는데 4까지 수행되는 것을 볼 수 있다.
  • 3에서 충돌한 후 이중 for문을 모두 탈출하기 위해 다음과 같이 고친다.
balls = [1, 2, 3, 4]
weapons = [11, 22, 3, 44]

for ball_idx, ball_val in enumerate(balls):
    print("ball : ", ball_val)
    for weapon_idx, weapon_val in enumerate(weapons):
        print("weapons : ", weapon_val)
        if ball_val == weapon_val:
            print("공과 무기가 충돌")
            break
    else:
        continue
    break

# 3에서 충돌하면 break로 빠져나가길 기대했는데
# 2중 for문이라서 4에 대한 것도 끝까지 실행되는 것을 볼 수 있다.

  • 키 이벤트를 통한 캐릭터 이동 시 방향키를 빠르게 누르면 캐릭터가 멈추는 버그
  • x좌표 이동 방향 처리를 왼쪽, 오른쪽으로 나눠서 key down / key up에서 각각 처리하여 더해주는 방식으로 해결
# 수정1 : 기존의 character_to_x 를 왼쪽 방향, 오른쪽 방향 변수 2개로 나눔
character_to_x_LEFT=0
character_to_x_RIGHT=0

...

for event in pygame.event.get():
	if event.type == pygame.QUIT:
		running = False

	# 수정2 : 키를 누를 때 LEFT, RIGHT 에 따라 서로 다른 변수의 값 조정
	if event.type == pygame.KEYDOWN:
		if event.key == pygame.K_LEFT:
			character_to_x_LEFT -= character_speed # 바뀐 부분
		elif event.key == pygame.K_RIGHT:
			character_to_x_RIGHT += character_speed # 바뀐 부분
		elif event.key == pygame.K_SPACE:
			...

	# 수정3 : 키에서 손을 뗄 때 LEFT, RIGHT 를 각각 처리
	if event.type == pygame.KEYUP:
		if event.key == pygame.K_LEFT: # 이 부분은 모두 다 바뀜
			character_to_x_LEFT = 0
		elif event.key == pygame.K_RIGHT:
			character_to_x_RIGHT = 0


# 수정4 : 두 변수의 값을 모두 더함
character_x_pos += character_to_x_LEFT + character_to_x_RIGHT


...

최종 코드

import os
import pygame
##############################################
# 기본 초기화 (반드시 해야 하는 것들)

pygame.init()  # 초기화 (반드시 필요)


# 화면 크기 설정
screen_width = 640   # 가로
screen_height = 480  # 세로
screen = pygame.display.set_mode((screen_width, screen_height))


# 화면 타이틀 설정
pygame.display.set_caption("Pang Game")  # 게임 이름


# FPS
clock = pygame.time.Clock()
##############################################


# 1. 사용자 게임 초기화 (배경 화면, 게임 이미지, 좌표, 속도, 폰트 등)
current_path = os.path.dirname(__file__)  # 현재 파일의 위치 반환
image_path = os.path.join(current_path, "images")  # images 폴더 위치 반환


# 배경 만들기
background = pygame.image.load(os.path.join(image_path, "background.png"))


# 스테이지 만들기
stage = pygame.image.load(os.path.join(image_path, "stage.png"))
stage_size = stage.get_rect().size
stage_height = stage_size[1]  # 스테이지의 높이 위에 캐릭터를 두기 위해 사용


# 캐릭터 만들기
character = pygame.image.load(os.path.join(image_path, "character.png"))
character_size = character.get_rect().size
character_width = character_size[0]
character_height = character_size[1]
character_x_pos = (screen_width/2) - (character_width/2)
character_y_pos = screen_height - stage_height - character_height


# 캐릭터 이동 방향
character_to_x = 0


# 캐릭터 이동 속도
character_speed = 5


# 무기 만들기
weapon = pygame.image.load(os.path.join(image_path, "weapon.png"))
weapon_size = weapon.get_rect().size
weapon_width = weapon_size[0]


# 무기는 한 번에 여러 발 발사 가능
weapons = []


# 무기 이동 속도
weapon_speed = 10


# 공 만들기 (4개 크기에 대해 따로 처리)
ball_images = [
    pygame.image.load(os.path.join(image_path, "balloon1.png")),
    pygame.image.load(os.path.join(image_path, "balloon2.png")),
    pygame.image.load(os.path.join(image_path, "balloon3.png")),
    pygame.image.load(os.path.join(image_path, "balloon4.png"))
]


# 공 크기에 따른 최초 스피드
ball_speed_y = [-18, -15, -12, -9]  # index 0, 1, 2, 3 에 해당하는 값
# -가 붙은 이유는 공이 튀겼을 때 올라갈 때 y값이 -를 해줘야 하기 때문이다.


# 공들
balls = []

# 최초 발생하는 큰 공 추가
balls.append({
    "pos_x": 50,  # 공의 x 좌표
    "pos_y": 50,  # 공의 y 좌표
    "img_idx": 0,  # 공의 이미지 인덱스
    "to_x": 3,  # x축 이동방향. -3이면 왼쪽 3이면 오른쪽으로
    "to_y": -6,  # y축 이동방향.
    "init_spd_y": ball_speed_y[0]})  # y 최초 속도

# 사라질 무기, 공 정보 저장 변수
weapon_to_remove = -1
ball_to_remove = -1


# Font 정의
game_font = pygame.font.Font(None, 40)
total_time = 100
start_ticks = pygame.time.get_ticks()  # 시작 시간 정의


# 게임 종료 메시지
# Time Over (시간 초과 실패)
# Mission Complete (성공)
# Game Over (캐릭터 공 충돌)
game_result = "Game Over"

running = True
while running:
    dt = clock.tick(30)

    # 2. 이벤트 처리 (키보드, 마우스 등 )
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                character_to_x -= character_speed
            elif event.key == pygame.K_RIGHT:
                character_to_x += character_speed
            elif event.key == pygame.K_SPACE:
                weapon_x_pos = character_x_pos + \
                    (character_width/2) - (weapon_width/2)
                weapon_y_pos = character_y_pos
                weapons.append([weapon_x_pos, weapon_y_pos])

        if event.type == pygame.KEYUP:
            if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
                character_to_x = 0

    # 3. 게임 캐릭터 위치 정의
    character_x_pos += character_to_x

    if character_x_pos < 0:
        character_x_pos = 0
    elif character_x_pos > screen_width - character_width:
        character_x_pos = screen_width - character_width

    # 무기 위치 조정
    weapons = [[w[0], w[1] - weapon_speed] for w in weapons]  # 무기 위치를 위로

    # 천장에 닿은 무기 없애기
    weapons = [[w[0], w[1]] for w in weapons if w[1] > 0]

    # 공 위치 정의
    for ball_idx, ball_val in enumerate(balls):
        # for ball_val in balls:
        ball_pos_x = ball_val["pos_x"]
        ball_pos_y = ball_val["pos_y"]
        ball_img_idx = ball_val["img_idx"]

        ball_size = ball_images[ball_img_idx].get_rect().size
        ball_width = ball_size[0]
        ball_height = ball_size[1]

        # 가로벽에 닿았을 때 공 이동 위치 변경 (튕겨 나오는 효과)
        if ball_pos_x < 0 or ball_pos_x > screen_width - ball_width:
            ball_val["to_x"] = ball_val["to_x"] * -1

        # 세로 위치
        # 스테이지에 튕겨서 올라가는 처리
        if ball_pos_y >= screen_height - stage_height - ball_height:
            ball_val["to_y"] = ball_val["init_spd_y"]
        else:  # 그 외의 모든 경우에는 속도를 증가 (포물선)
            ball_val["to_y"] += 0.5

        ball_val["pos_x"] += ball_val["to_x"]
        ball_val["pos_y"] += ball_val["to_y"]

    # 4. 충돌 처리

    # 캐릭터 rect 정보 업데이트
    character_rect = character.get_rect()
    character_rect.left = character_x_pos
    character_rect.top = character_y_pos

    for ball_idx, ball_val in enumerate(balls):
        ball_pos_x = ball_val["pos_x"]
        ball_pos_y = ball_val["pos_y"]
        ball_img_idx = ball_val["img_idx"]

        # 공 rect 정보 업데이트
        ball_rect = ball_images[ball_img_idx].get_rect()
        ball_rect.left = ball_pos_x
        ball_rect.top = ball_pos_y

        # 공과 캐릭터 충돌 처리
        if character_rect.colliderect(ball_rect):
            running = False
            break

        # 공과 무기들 충돌 처리
        for weapon_idx, weapon_val in enumerate(weapons):
            weapon_pos_x = weapon_val[0]
            weapon_pos_y = weapon_val[1]

            # 무기 rect 정보 업데이트
            weapon_rect = weapon.get_rect()
            weapon_rect.left = weapon_pos_x
            weapon_rect.top = weapon_pos_y

            # 충돌 체크
            if weapon_rect.colliderect(ball_rect):
                weapon_to_remove = weapon_idx  # 해당 무기 없애기 위한 값 설정
                ball_to_remove = ball_idx  # 해당 공 없애기 위한 값 설정

                # 가장 작은 공이 아니라면 다음 단게의 공으로 나눠주기
                if ball_img_idx < 3:
                    # 현재 공 크기 정보를 가지고 옴
                    ball_width = ball_rect.size[0]
                    ball_height = ball_rect.size[1]

                    # 나눠진 공 정보
                    small_ball_rect = ball_images[ball_img_idx + 1].get_rect()
                    small_ball_width = small_ball_rect.size[0]
                    small_ball_height = small_ball_rect.size[1]

                    # 왼쪽으로 튕겨나가는 작은 공
                    balls.append({
                        "pos_x": ball_pos_x + ball_width/2 - small_ball_width/2,  # 공의 x 좌표
                        "pos_y": ball_pos_y + ball_height/2 - small_ball_height/2,  # 공의 y 좌표
                        "img_idx": ball_img_idx + 1,  # 공의 이미지 인덱스
                        "to_x": -3,  # x축 이동방향. -3이면 왼쪽 3이면 오른쪽으로
                        "to_y": -6,  # y축 이동방향.
                        "init_spd_y": ball_speed_y[ball_img_idx + 1]})

                    # 오른쪽으로 튕겨나가는 작은 공
                    balls.append({
                        "pos_x": ball_pos_x + ball_width/2 - small_ball_width/2,  # 공의 x 좌표
                        "pos_y": ball_pos_y + ball_height/2 - small_ball_height/2,  # 공의 y 좌표
                        "img_idx": ball_img_idx + 1,  # 공의 이미지 인덱스
                        "to_x": 3,  # x축 이동방향. -3이면 왼쪽 3이면 오른쪽으로
                        "to_y": -6,  # y축 이동방향.
                        "init_spd_y": ball_speed_y[ball_img_idx + 1]})
                break

    # 충돌된 공 or 무기 없애기
    if ball_to_remove > -1:
        del balls[ball_to_remove]
        ball_to_remove = -1

    if weapon_to_remove > -1:
        del weapons[weapon_to_remove]
        weapon_to_remove = -1

    

    # 5. 화면에 그리기
    screen.blit(background, (0, 0))
    for weapon_x_pos, weapon_y_pos in weapons:
        screen.blit(weapon, (weapon_x_pos, weapon_y_pos))

    for idx, val in enumerate(balls):
        ball_pos_x = val["pos_x"]
        ball_pos_y = val["pos_y"]
        ball_img_idx = val["img_idx"]
        screen.blit(ball_images[ball_img_idx], (ball_pos_x, ball_pos_y))

    screen.blit(stage, (0, screen_height - stage_height))
    screen.blit(character, (character_x_pos, character_y_pos))

    # 경과 시간 계산
    elapsed_time = (pygame.time.get_ticks() - start_ticks) / 1000
    timer = game_font.render(
        f"Time : {int(total_time - elapsed_time)}", True, (255, 255, 255))
    screen.blit(timer, (10, 10))

    # 시간 초과했다면
    if total_time - elapsed_time < 0:
        game_result = "Time Over"
        running = False

    pygame.display.update()  # 게임화면을 다시 그리기!

    # 모든 공을 없앤 경우 게임 종료 (성공)
    if not balls:
        game_result = "Mission Complete!"
        running = False

# 게임 오버 메시지
msg = game_font.render(game_result, True, (255, 255, 0))  # 노란색
msg_rect = msg.get_rect(center=(int(screen_width/2), int(screen_height/2)))
screen.blit(msg, msg_rect)
pygame.display.update()

# 2초 대기
pygame.time.delay(2000)

pygame.quit()
profile
완전쌩초보

0개의 댓글