[파이썬 크래시 코스 예제] 외계인 침공 -최종

 

책 "파이썬 크래스 코드"의 실전 예제코드 완성본입니다.

settings.py

"""settings.py"""
class Settings:
    """외계인 침공의 설정을 저장하는 클래스"""
    def __init__(self):
        """게임 설정 초기화"""
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230,230,230)

        # 우주선 설정
        self.ship_speed = 2.5
        self.ship_limit = 2

        # 탄환 설정
        self.bullet_speed = 5.0
        self.bullet_width = 3
        self.bullet_height = 15
        self.bullet_color = (60,60,60)
        self.bullet_allowed = 10

        # 외계인 설정
        self.alien_speed = 3.0
        self.fleet_drop_speed = 10
        # 1은 오른쪽, -1은 왼쪽입니다.
        self.fleet_direction = 1
        # 외계인 군단 최대 row
        self.fleet_row = 4

        # 게임을 빠르게 만드는 속도
        self.speedup_scale = 1.1

        # 외계인 점수가 늘어나는 속도
        self.score_scale = 1.5

        self.initialize_dynamic_settings()

    def initialize_dynamic_settings(self):
        """게임을 진행하는 동안 변하는 설정 초기화"""
        self.ship_speed = 1.5
        self.bullet_speed = 2.5
        self.alien_speed = 1.0

        # 1은 오른쪽, -1은 왼쪽입니다.
        self.fleet_direction = 1

        # 점수 설정
        self.alien_points = 50

    def increase_speed(self):
        """속도 설정을 높입니다."""
        self.ship_speed *= self.speedup_scale
        self.bullet_speed *= self.speedup_scale
        self.alien_speed *= self.speedup_scale

        self.alien_points = int(self.alien_points * self.score_scale)
        print(self.alien_points)

 

이 파일은 게임의 모든 설정을 관리합니다.

• __init__: 게임 설정을 초기화합니다. 화면 크기, 배경색, 우주선, 탄환, 외계인의 속도 및 크기 설정 등을 정의합니다.
• initialize_dynamic_settings: 게임 진행 중 변하는 설정을 초기화합니다. 이는 게임 난이도가 점차 증가할 때 사용됩니다.
• increase_speed: 게임의 난이도를 증가시키는 메서드로, 속도 관련 변수들을 speedup_scale과 score_scale에 따라 조정합니다.

alien_invasion.py

"""alien_invasion.py"""
import sys
import pygame
from time import sleep

from settings import Settings
from game_stats import GameStats
from scoreboard import Scoreboard
from button import Button

from ship import Ship
from bullet import Bullet
from alien import Alien

class AlienInvasion:
    """게임 자원과 동작을 전체적으로 관리하는 클래스"""

    def __init__(self):
        """게임을 초기화 하고 자원을 만듭니다."""
        pygame.init()

        self.clock = pygame.time.Clock()
        self.settings = Settings()

        # 전체화면으로 실행하기
        # self.screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
        # self.settings.screen_width = self.screen.get_rect().width
        # self.settings.screen_height = self.screen.get_rect().height

        self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("Alien Invasion")

        # 게임 기록을 저장할 인스턴스를 만든다.
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()

        self._create_fleet()
        # 게임을 활성화 상태로 시작합니다.
        self.game_active = False

        # [플레이] 버튼을 만듭니다.
        self.play_button = Button(self, "Play")

    def run_game(self):
        """게임의 메인 루프를 시작합니다."""

        while True:
            self._check_events()

            if self.game_active:
                self.ship.update()
                self._update_bullets()
                self._update_alien()

            self._update_screen()

            # 게임 프레임 속도를 인수로 받는다. 60은 초다 60회 실행되도록 조정한다.
            self.clock.tick(60)

    def _check_events(self):
        """키입력과 마우스 이벤트에 응답합니다."""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                self._check_keydown_events(event)
            elif event.type == pygame.KEYUP:
                self._check_keyup_events(event)
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self._check_play_button(mouse_pos)
    def _check_keydown_events(self, event) -> None:
        """키를 누를때 실행됩니다."""
        if event.key == pygame.K_RIGHT:
            # 우주선을 오른쪽으로 이동시킵니다.
            self.ship.moving_right = True
        elif event.key == pygame.K_LEFT:
            # 우주선을 왼쪽으로 이동시킵니다.
            self.ship.moving_left = True
        elif event.key == pygame.K_q:
            sys.exit()
        elif event.key == pygame.K_SPACE:
            self._fire_bullet()

    def _check_keyup_events(self, event) -> None:
        """키에서 손을 뗄 때 응답힙니다."""
        if event.key == pygame.K_RIGHT:
            # 우주선을 오른쪽으로 이동중지합니다.
            self.ship.moving_right = False
        elif event.key == pygame.K_LEFT:
            # 우주선을 왼쪽으로 이동중지합니다.
            self.ship.moving_left = False

    def _fire_bullet(self):
        """새 탄환을 만들어 탄환 그룹에 추가합니다."""
        if len(self.bullets) < self.settings.bullet_allowed:
            new_bullet = Bullet(self)
            self.bullets.add(new_bullet)

    def _update_bullets(self):
        """탄환 위치를 업데이트하고 사라진 탄환을 제거 합니다."""
        # 탄호나 위치를 업데이트 합니다.
        self.bullets.update()

        # 사라진 탄환을 제거합니다.
        for bullet in self.bullets.copy():
            if bullet.rect.bottom <= 0:
                self.bullets.remove(bullet)
        self._check_bullet_alien_collisions()

        # 현재 화면에 있는 탄환 수 로그
        #print(len(self.bullets))

    def _check_bullet_alien_collisions(self):
        """탄환과 외게인의 충돌을 관리합니다."""
        # 외계인을 맞힌 탄환이 있는지 확인합니다.
        # 맞흰 탄환이 있으면 탄환과 외계인을 제거합니다.

        collisions = pygame.sprite.groupcollide(
            self.bullets, self.aliens, True, True)

        if collisions:
            for aliens in collisions.values():
                self.stats.score += self.settings.alien_points * len(aliens)

            self.sb.prep_score()
            self.sb.check_high_core()

        if not self.aliens:
            # 남아 있는 탄환을 제거하고 함대를 새로 만듭니다.
            self.bullets.empty()
            self._create_fleet()
            self.settings.increase_speed()

            # 레벨을 올립니다.
            self.stats.level += 1
            self.sb.prep_level()

    def _ship_hit(self):
        """외계인이 우주선에 충돌할 때 할 작업"""

        if self.stats.ships_left > 0:
            # ships_left에서 1을 뺍니다
            self.stats.ships_left -= 1  # 1
            self.sb.prep_ship()

            # 남아 있는 탄환과 외계인을 모두 제거합니다
            self.bullets.empty()  # 2
            self.aliens.empty()

            # 함대를 새로 만들고 우주선을 화면 하단 중앙으로 이동시킵니다
            self._create_fleet()
            self.ship.center_ship()

            # 일시 중지
            sleep(0.5)  # 4
        else:
            self.game_active = False
            pygame.mouse.set_visible(True)

    def _update_alien(self):
        """함대에 속한 외계인의 위치를 모두 업데이트 한다."""
        self._check_fleet_edges()
        self.aliens.update()

        # 외계인과 우주선의 충돌 검색
        if pygame.sprite.spritecollideany(self.ship,self.aliens):
            self._ship_hit()
        # 화면 하단에 도달한 외계인을 찾습니다.
        self._check_aliens_bottom()

    def _update_screen(self):
        """화면의 이미지를 업데이트 하고 화면을 새로 그립니다."""
        # 루프를 반복할 때마다 화면을 다시 그린다.
        self.screen.fill(self.settings.bg_color)
        for bullet in self.bullets.sprites():
            bullet.draw_bullet()
        self.ship.blitme()
        self.aliens.draw(self.screen)

        # 점수 정보를 그립니다.
        self.sb.show_score()

        # 게임이 비활성 상태이면 [플레이] 버튼을 그립니다.
        if not self.game_active:
            self.play_button.draw_button()

        # 가장 최근 그린 화면을 표시합니다.
        pygame.display.flip()

    def _create_fleet(self):
        """외계인 함대를 만듭니다."""
        # 외계인 하나를 만들고, 공간이 없을 때까지 계속 추가합니다.
        # 외계인 사이으이 공간은 외계인의 너비와 높이와 같습니다.
        alien = Alien(self)
        alien_with, alien_height = alien.rect.size

        current_x, current_y = alien_with, alien_height
        current_fleet_row = 0
        while (current_y < (self.settings.screen_height -(3 * alien_height) - self.ship.rect.height)
               and current_fleet_row < self.settings.fleet_row):

            while current_x < (self.settings.screen_width -2 * alien_with):
                self._create_alien(current_x, current_y)
                current_x +=2 * alien_with
            # 한줄이 끝나으니 x 값을 초기화 하고 y 값은 늘립니다.
            current_x = alien_with
            current_y += 2*alien_height
            current_fleet_row += 1

    def _create_alien(self, x_position, y_position):
        """외계인 하나를 만들어 배치합니다."""
        new_alien = Alien(self)
        new_alien.x = x_position
        new_alien.rect.x = x_position
        new_alien.rect.y = y_position
        self.aliens.add(new_alien)

    def _check_fleet_edges(self):
        """"외계인이 화면 경계에 도달했을 때 반응합니다"""
        for alien in self.aliens.sprites(): # 0
            if alien.check_edges():
                self._change_fleet_direction() # 2
                break

    def _change_fleet_direction(self):
        """"함대 전체를 한 줄 내리고 좌우 방향을 바꿉니다"""
        for alien in self.aliens.sprites():
            alien.rect.y += self.settings.fleet_drop_speed # 3
        self.settings.fleet_direction *= -1

    def _check_aliens_bottom(self):
        """화면 하단에 도달한 외계인이 있는지 확인합니다. """
        for alien in self.aliens.sprites():
            if alien.rect.bottom >= self.settings.screen_height:
                # 우주선에 외계인이 충돌할 때와 똑같이 반응한다.
                self._ship_hit()
                break

    def _check_play_button(self, mouse_pos):
        """플레이어가 [플레이] 버튼을 클릭하면 게임이 시작합니다."""
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)

        if button_clicked and not self.game_active:
            # 게임 설정 초기화
            self.settings.initialize_dynamic_settings()

            # 게임 기록 초기화
            self.stats.reset_stats()
            self.sb.prep_score()
            self.sb.prep_level()
            self.sb.prep_ship()
            self.game_active = True

            # 남아 있는 탄환과 외계인을 모두 제거합니다.
            self.bullets.empty()
            self.aliens.empty()

            # 함대를 새로 만들고 우주선을 화면 하단 중앙으로 이동시킵니다.
            self._create_fleet()
            self.ship.center_ship()

            # 마우스 커서를 숨깁니다.
            pygame.mouse.set_visible(False)

if __name__ == '__main__':
    # 게임 인스턴스를 만들고 게임을 실행합니다.
    ai = AlienInvasion()
    ai.run_game()

게임의 메인 파일로, 게임 실행과 관리의 핵심 로직을 포함합니다.

• __init__: 게임을 초기화하고 필요한 자원을 생성합니다. Pygame을 초기화하고 설정, 게임 통계, 점수판, 우주선, 탄환, 외계인을 설정합니다.
• run_game: 게임의 메인 루프를 실행합니다. 이벤트를 확인하고, 게임 상태를 업데이트하며, 화면을 갱신합니다.
• _check_events: 입력 이벤트(키보드, 마우스)를 체크합니다.
• _check_keydown_events와 _check_keyup_events: 키 입력에 따라 우주선을 이동시키거나 게임을 종료합니다.
• _fire_bullet: 우주선에서 탄환을 발사합니다.
• _update_bullets: 탄환의 위치를 업데이트하고 화면 밖으로 나간 탄환을 제거합니다.
• _update_screen: 게임 화면을 업데이트하고 모든 게임 요소를 다시 그립니다.

ship.py

"""ship.py"""
import pygame
from pygame.sprite import Sprite

class Ship(Sprite):
    """ 우주선을 관리하는 클래스"""

    def __init__(self, ai_game):
        """우주선을 초기화하고 시작 위치를 설정합니다."""
        super().__init__()
        self.screen = ai_game.screen
        self.settings = ai_game.settings
        self.screen_rect = ai_game.screen.get_rect()

        # 우주선 이미지를 불러오고 사각형을 가져옵니다.
        self.image = pygame.image.load('images/ship.png')
        self.rect = self.image.get_rect()

        # 우주선의 초기 위치는 화면 하단 중앙입니다.
        self.rect.midbottom = self.screen_rect.midbottom

        # 우주선의 정확한 가로 위치 설정을 위해 부동 소수점 숫자를 저장합니다.
        self.x = float(self.rect.x)

        # 움직임 플래그는 정지 상태로 시작합니다.
        self.moving_right = False
        self.moving_left = False

    def update(self):
        """움직임 플래그를 바탕으로 우주선 위치를 업데이트 합니다."""
        if self.moving_right and self.rect.right < self.screen_rect.right:
            self.x += self.settings.ship_speed

        if self.moving_left and self.rect.left > 0:
            self.x -= self.settings.ship_speed

        # self.x 를 통해 rect 객체를 업테이트 합니다.
        self.rect.x = self.x
    def blitme(self):
        """우주선을 현재 위치에 그립니다."""
        self.screen.blit(self.image, self.rect)

    def center_ship(self):
        """우주선을 화면 상단 중앙으로 이동시킵니다."""
        self.rect.midbottom = self.screen_rect.midbottom
        self.x = float(self.rect.x)

우주선을 관리하는 클래스 파일입니다.

• __init__: 우주선을 초기화하고 화면 하단 중앙에 위치시킵니다.
• update: 우주선의 위치를 업데이트합니다. 우주선이 화면 경계 내에서만 움직이도록 제한합니다.
• blitme: 우주선을 현재 위치에 그립니다.
• center_ship: 우주선을 화면 하단 중앙으로 재배치합니다.

alien.py

"""alien.py"""

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
    """함대에 속한 외계인 하나를 나타내는 클래스"""

    def __init__(self, ai_game):
        """외계인을 초기화하고 시작 위치를 설정합니다"""
        super().__init__()
        self.screen = ai_game.screen
        self.settings = ai_game.settings

        # 외계인 이미지를 불러와 rect 속성을 설정합니다
        self.image = pygame.image.load('images/alien.png')
        self.rect = self.image.get_rect()

        # 외계인은 화면 좌측 상단 근처에 만듭니다
        self.rect.x = self.rect.width # 1
        self.rect.y = self.rect.height

        # 외계인의 정확한 가로 위치를 저장합니다
        self.x = float(self.rect.x) # 2

    def check_edges(self):
        """외계인이 화면 경계에 도달하면 true을 반환한다."""
        screen_rec = self.screen.get_rect()
        return (self.rect.right >= screen_rec.right) or (self.rect.left <= 0)

    def update(self):
        """외계인을 오른쪽으로 움직입니다."""
        self.x += self.settings.alien_speed * self.settings.fleet_direction
        self.rect.x = self.x

외계인을 관리하는 클래스 파일입니다.

• __init__: 외계인을 초기화하고 시작 위치를 설정합니다.
• check_edges: 외계인이 화면 경계에 도달했는지 확인합니다.
• update: 외계인을 오른쪽이나 왼쪽으로 움직입니다.

bullet.py

import pygame
from pygame.sprite import Sprite

class Bullet(Sprite):
    """우주선이 발사하는 탄환을 관리하는 클래스"""

    def __init__(self, ai_game):
        """우주선의 현재 위치에서 탄환 객체를 만듭니다."""
        super().__init__()
        self.screen = ai_game.screen
        self.settings = ai_game.settings
        self.color = self.settings.bullet_color

        # (0, 0)에 탄환 사각형을 만들고 위치를 설정합니다.
        self.rect = pygame.Rect(0,0,self.settings.bullet_width, self.settings.bullet_height)
        # 중앙에 맞춘다.
        self.rect.midtop = ai_game.ship.rect.midtop

        # 탄환 위치를 부동 소수점 숫자로 저장합니다.
        self.y = float(self.rect.y)

    def update(self):
        """탄환이 화면 위 방향으로 이동합니다."""
        # 탄환 위치를 정확히 업데이트 합니다.
        self.y -= self.settings.bullet_speed

        # 사각현 위치를 업데이트 합니다.
        self.rect.y = self.y

    def draw_bullet(self):
        """화면에 탄환을 그립니다."""
        pygame.draw.rect(self.screen, self.color,self.rect)

탄환을 관리하는 클래스 파일입니다.

• __init__: 탄환을 초기화하고 위치를 설정합니다.
• update: 탄환을 위로 움직이게 하고, 화면 밖으로 나간 탄환을 관리합니다.
• draw_bullet: 탄환을 화면에 그립니다.

game_stats.py

"""game_stats.py"""

class GameStats:
    """'외계인 침공 게임 기록"""
    def __init__(self, ai_game):
        """기록 초기화"""
        self.settings = ai_game.settings
        self.reset_stats() # 1

        # 최고 점수는 최기화 하지 않습니다.
        self.high_score=0

    def reset_stats(self):
        """게임을 진행하는 동안 변하는 기록 초기화"""
        self.ships_left = self.settings.ship_limit
        self.score = 0
        self.level = 1

게임 통계를 관리하는 클래스 파일입니다.

• __init__: 게임 통계를 초기화합니다.
• reset_stats: 게임을 진행하는 동안 변하는 기록(남은 우주선 수, 점수, 레벨)을 초기화합니다.

button.py

"""button.py"""

import pygame.font

class Button:
    """게임에 사용할 버튼을 만드는 클래스"""

    def __init__(self, ai_game, msg):
        """버튼 속성을 초기화 합니다."""
        self.screen = ai_game.screen
        self.screen_rect  = self.screen.get_rect()

        # 버튼 크기와 속성을 설정합니다.
        self.width, self.height = 200,50
        self.button_color = (0,135,0)
        self.text_color = (255,255,255)
        self.font = pygame.font.SysFont(None,48)

        # 버튼의 rect 객체를 만들고 중앙에 배치합니다.
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.center = self.screen_rect.center

        # 버튼에 표시할 메시지
        self._prep_msg(msg)

    def _prep_msg(self, msg):
        """msg를 이미지로 렌더링하고 버튼 중앙에 배치합니다."""
        self.msg_image = self.font.render(msg, True, self.text_color, self.button_color)
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    def draw_button(self):
        """빈 버튼을 그리고 메시지를 그립니다."""
        self.screen.fill(self.button_color, self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)

button.py 파일은 게임 내에서 사용자 인터페이스 요소 중 하나인 버튼을 관리합니다. 주로 게임 시작 버튼이나 메뉴 버튼으로 사용됩니다.

• __init__: 버튼의 초기화 메소드입니다. 버튼의 크기, 색상, 텍스트 색상, 폰트를 설정하고, 게임 화면에 버튼을 중앙에 배치합니다.
  • self.width, self.height: 버튼의 너비와 높이를 지정합니다.
  • self.button_color: 버튼의 배경색을 설정합니다.
  • self.text_color: 버튼의 텍스트 색상을 설정합니다.
  • self.font: 텍스트에 사용될 폰트를 설정합니다.
  • self.rect: 버튼의 위치와 크기를 정의하는 Pygame 사각형(rect) 객체를 생성하고 화면 중앙에 위치시킵니다.
• _prep_msg: 버튼에 표시될 메시지를 준비하는 메소드입니다. 메시지를 이미지로 렌더링하고, 이 이미지를 버튼의 중앙에 위치시킵니다.
  • self.msg_image: 메시지 텍스트를 이미지로 변환합니다.
  • self.msg_image_rect: 메시지 이미지의 위치를 정의합니다.
• draw_button: 실제로 화면에 버튼을 그리는 메소드입니다. 설정된 버튼 색상으로 버튼 영역을 채우고, 그 위에 렌더링된 텍스트 이미지를 배치합니다.

scoreboard.py

"""scoreboard.py"""

import pygame.font
from pygame.sprite import Group

from ship import Ship

class Scoreboard:
    """점수를 기록할 클래스"""

    def __init__(self, ai_game):
        """점수 기록에 필요한 속성 초기화"""
        self.ai_game = ai_game
        self.screen = ai_game.screen
        self.screen_rect = self.screen.get_rect()
        self.settings = ai_game.settings
        self.stats = ai_game.stats

        # 점수 정보에 쓸 폰트 설정
        self.text_color = (30, 30, 30)
        self.font = pygame.font.SysFont(None, 48)

        # 초기 점수 이미지
        self.prep_score()
        self.prep_high_score()
        self.prep_level()
        self.prep_ship()


    def prep_score(self):
        """점수를 이미지로 렌터링 합니다."""
        rounded_score = round(self.stats.score, -1)
        score_str = f"{rounded_score:,}"
        self.score_image = self.font.render(score_str, True,
                                            self.text_color, self.settings.bg_color)

        # 화면 우측 상단에 접수를 표시합니다.
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right - 20
        self.score_rect.top = 20

    def show_score(self):
        """점수를 화면에 그립니다."""
        self.screen.blit(self.score_image, self.score_rect)
        self.screen.blit(self.high_score_image, self.high_score_rect)
        self.screen.blit(self.level_image, self.level_rect)
        # 남은 우주선을 그립니다.
        self.ships.draw(self.screen)

    def prep_high_score(self):
        """최고 점수를 이미지로 렌더링 합니다."""
        high_score = round(self.stats.high_score, -1)
        high_score_str = f"{high_score:,}"
        self.high_score_image = self.font.render(high_score_str, True,
                                                 self.text_color, self.settings.bg_color)

        # 최고 점수를 화면 상단 중앙에 표시합니다.
        self.high_score_rect = self.high_score_image.get_rect()
        self.high_score_rect.centerx = self.screen_rect.centerx
        self.high_score_rect.top = self.screen_rect.top

    def check_high_core(self):
        """최고 점수가 갱신됐는지 확인합니다."""
        if self.stats.score > self.stats.high_score:
            self.stats.high_score = self.stats.score
            self.prep_high_score()


    def prep_level(self):
        """레벨을 이미지로 렌더링 합니다."""
        level_str = str(self.stats.level)
        self.level_image = self.font.render(level_str, True,
                                            self.text_color, self.settings.bg_color)

        # 레벨 점수 아래에 표시합니다.
        self.level_rect = self.level_image.get_rect()
        self.level_rect.right = self.score_rect.right
        self.level_rect.top = self.score_rect.bottom + 10


    def prep_ship(self):
        """우주선이 몇대 남아있는지 표시합니다."""
        self.ships = Group()
        for ship_number in range(self.stats.ships_left):
            ship = Ship(self.ai_game)
            ship.rect.x = 10+ ship_number * ship.rect.width
            ship.rect.y = 10
            self.ships.add(ship)

scoreboard.py 파일은 게임의 점수판을 관리합니다. 게임의 현재 점수, 최고 점수, 현재 레벨, 남은 우주선 수 등을 화면에 표시합니다.

• __init__: 점수판의 초기화 메소드입니다. 점수판에 필요한 폰트와 색상을 설정하고, 점수, 최고 점수, 레벨, 우주선의 수를 준비하여 화면에 표시할 준비를 합니다.
  • self.font: 점수 정보에 사용될 폰트를 설정합니다.
  • 각 점수 요소를 렌더링하는 메소드(prep_score, prep_high_score, prep_level, prep_ship)를 호출합니다.
• prep_score: 현재 점수를 렌더링합니다. 점수를 반올림하고, 문자열 형태로 포맷팅하여 이미지로 변환한 후, 화면의 우측 상단에 위치시킵니다.
• show_score: 점수판을 화면에 그립니다. 현재 점수, 최고 점수, 레벨, 남은 우주선의 이미지를 화면에 표시합니다.
• prep_high_score: 최고 점수를 렌더링합니다. 현재 점수가 최고 점수보다 높을 경우 최고 점수를 업데이트하고, 새로운 최고 점수를 이미지로 렌더링하여 화면 상단 중앙에 위치시킵니다.
• check_high_score: 최고 점수를 확인하고 필요한 경우 업데이트합니다. 최고 점수가 갱신되면, 새로운 최고 점수를 렌더링하는 prep_high_score 메소드를 호출합니다.
• prep_level: 현재 레벨을 렌더링합니다. 레벨 번호를 이미지로 변환하고, 점수 영역 바로 아래에 위치시킵니다.
• prep_ship: 남은 우주선의 수를 표시합니다. 남은 우주선의 수만큼 우주선 이미지를 생성하고,
• 화면의 좌측 상단에 표시합니다.