👦 내일배움캠프/TIL(Today I Learned)

TIL_220426

개인 프로젝트 주간

무엇을 느꼈는가.

개인 프로젝트를 진행하면서, 배운 것보다 코드 오류로 해결하는 시간의 소요가 가장 크다.

나에게는 실력이 되겠지만, 아무리 생각해도 너무 아쉽고, 너무 아깝다.

단시간에 찾을 수 있었던 오류였다.

하지만 이런 오류에 대해서 어느 부분을 중점으로 두고 확인해야 하는지, 사전 지식이 없으니 처음부터 끝까지 다시 보는 미련한 행동을 보였다.

이제보니 오류는 가장 맨 마지막에 오탈자로 발견되어 마무리 되었다.

그 외에도 오류는 아니지만, 코드 활용에 있어서 어느 부분에 적용시켜 게임이 동작되는지 하나 하나를 넣어보며 확인해야만 했다.

이렇게 보낸 시간이 벌써 2일이 끝나고 당장 발표일이 되었다.

하지만 나는 무엇을 느꼈는가.

그렇게 매달리고, 쫒고, 파헤쳤던 그 과정을 거쳐 해결로 도달했을 때의 성취감.

내 머리속으로 그려 나아가며, 실제로 코드에 적용해 동작되는 것을 보고 느끼는 희열감.

그리고 내가 배우고 성장하고 있다는 것을 느끼게 해주는 지금의 결과.

실패로 끝났다가 아니라 한 걸음 더 나아갈 발판이 되었음을 마음속에 품고,

부디 포기말고,

계속 나아가자.

개인 프로젝트 기획 [22. 04. 27. 수정]

1. 창 화면

- 640 * 640 크기

2. 게임 이미지

- 배경 이미지, 점수 화면 이미지 640 * 640

- 게임 메뉴 화면 이미지 640 * 640

- 우주선 이미지 42 * 40

- 폭발 이미지 70 * 55

- 미사일 이미지 20 * 20

- 운석 이미지 (75 * 37, 75 * 55, , 75 * 25, 75 * 52, , 75 * 61)

3. 좌표

- 우주선 고정 위치 : 창 화면의 중앙

- 미사일 이동 위치(우주선 중심으로) : 네 방향 직진

- 운석 이동 위치(네 방향 창 중심으로 우주선을 향해) : 네 방향 안쪽 이동

- 배경 이미지 위치 : (0, 0)

- 게임 메뉴 화면 이미지 위치 : (0, 0)

- 폭발 이미지 위치

- 최고 점수 기록 위치 : (150, 20)

- 게임 제목 텍스트 위치 : (창 너비 중심, 창 높이 중심)

- 엔터 키 안내 텍스트 위치 : (창 너비 중심, 창 높이 중심 + 200)

- 게임 시작 텍스트 위치 : (창 너비 중심, 창 높이 중심 + 250)

- 점수 확인 안내 텍스트 위치 : (창 너비 중심, 창 높이 중심 + 350)

- 점수 텍스트 위치 1 : (창 너비 중심, 창 높이 / 4 + 100)

- 점수 텍스트 위치 2 : (창 너비 중심, 창 높이 / 4 + 200)

4. FPS

- 초당 60

5. 색상

- BLACK = (0, 0, 0)
- WHITE = (255, 255, 255)
- YELLOW = (250, 250, 50)
- RED = (250, 50, 50)

6. 위치 정의

- 우주선의 화면 위치 고정

- 이벤트 키 입력에 따른 네 방향 미사일 사출 위치 정의

-- 미사일이 화면 밖으로 나갈 경우 미사일 제거

- 창의 중심 네 방향으로 우주선을 향하게 운석의 이동 위치 정의

7. 충돌 처리

- 우주선과 운석의 충돌 처리

- 미사일과 운석의 충돌 처리

8. 규칙 정의

- 우주선으로 향하는 운석의 충돌을 막아야 함.

- 우주선은 네 방향으로 미사일을 발사

- 운석은 네 방향에서 랜덤의 확률로 5가지의 운석 종류 출현

- 100/ 200/ 300 의 운석 격추에 따른 난이도 증가

기반이 되는 소스 따라쓰며 이해하기

import random
from time import sleep

import pygame as pg
from pygame.locals import *

# 창 사이즈 전역변수
WINDOW_WIDTH = 480
WINDOW_HEIGHT = 640

# 색상 정의
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
YELLOW = (250, 250, 50)
RED = (250, 50, 50)

# 초당 프레임
FPS = 60


# 우주선 클래스
# 게임에서 나타내는 모든 캐릭터, 장애물등을 표현할 때 사용하는 Surface 상속을 받아온다.
class Fighter(pg.sprite.Sprite):
    # 다른 객체지향 언어에서는 생성자(constructor)라고 부른답니다
    # 초기화 메서드, 어떤 클래스의 객체가 만들어질 때 자동으로 호출되어서 그 객체가 갖게 될 여러 가지 성질을 정해주는 일
    def __init__(self):  # 단일
        super(Fighter, self).__init__()  # 상위 클래스 __init__ 호출
        self.image = pg.image.load('fighter.png')  # self(Fighter의 초기화 값) 에 입힐 이미지를 가져온다.
        self.rect = self.image.get_rect()  # 이미지 크기 조정 .get_rect(none)[크기 정보 + 좌표 정보]
        self.rect.x = int(WINDOW_WIDTH / 2)  # 처음 우주선의 등장 위치 (WINDOW_WIDTH / 2 = 창의 너비의 중앙)
        self.rect.y = WINDOW_HEIGHT - self.rect.height  # 우주선의 높이 만큼 빼서 y 값을 지정
        self.dx = 0  # x 방향
        self.dy = 0  # y 방향

    # 화면 밖으로 나갔을 경우를 대비한 루트
    def update(self):
        self.rect.x += self.dx  # 우주선.rect.x 위치가 우주선.dx 이동한 위치 만큼 더해진다.
        self.rect.y += self.dy  # 움직임 필수적인 부분

        # 우주선.rect.x 좌표가 0 보다 작은 경우는 = 화면 밖으로 나가는 경우
        # 만약 X 위치가 우주선의 너비를 포함한 좌표가 창의 너비보다 클 경우
        if self.rect.x < 0 or self.rect.x + self.rect.width > WINDOW_WIDTH:  # 창의 밖으로 나갔을 경우를 대비
            self.rect.x -= self.dx  # 나가면 움직임을 멈춤

        # 우주선.rect.y 좌표가 0 보다 작은 경우는 = 화면 밖으로 나가는 경우
        # 만약 Y 위치가 우주선의 높이를 포함한 좌표가 창의 높이보다 클 경우
        if self.rect.y < 0 or self.rect.y + self.rect.height > WINDOW_HEIGHT:
            self.rect.y -= self.dy

    # 그려주는 부분
    def draw(self, screen):  # self 에서 스크린 값을 받아온다.
        screen.blit(self.image, self.rect)  # 화면에 그려줌 우주선(self) 의 이미지와 우주선(self) 의 사이즈

    def collide(self, sprites):
        for sprite in sprites:  # 객체 관리를 편하게 하기 위한 방법
            if pg.sprite.collide_rect(self, sprite):  # 검사 중 우주선과 sprite 와 충돌했을 경우 / .collide_rect = 충돌 체크
                return sprite  # 충돌 난 sprite return


# 미사일 클래스
class Missile(pg.sprite.Sprite):
    def __init__(self, xpos, ypos, speed):  # 초기화 메서드, 불러올 값 지정
        super(Missile, self).__init__()
        self.image = pg.image.load('missile.png')
        self.rect = self.image.get_rect()  # 미사일 사이즈
        self.rect.x = xpos  # 미사일 호출하는 위치 값 지정 / 우주선에서 발사할 수 있게 만들기 위한
        self.rect.y = ypos
        self.speed = speed
        self.sound = pg.mixer.Sound('missile.wav')

    def launch(self):  # 발사에 대한 소리
        self.sound.play()  # 소리 재생

    # 미사일의 위치
    def update(self):
        self.rect.y -= self.speed  # 아래에서 위로 발사되는 좌표 - / 해당하는 속도 만큼
        if self.rect.y + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
            self.kill()  # 화면 밖으로 나간 미사일은 없애줌

    # 미사일 충돌 체크
    def collide(self, sprites):
        for sprite in sprites:
            if pg.sprite.collide_rect(self, sprite):
                return sprite


# 운석 클래스
class Rock(pg.sprite.Sprite):
    def __init__(self, xpos, ypos, speed):  # 초기화 메서드, 운석의 좌표 및 스피드
        super(Rock, self).__init__()
        rock_images = ('rock01.png', 'rock02.png', 'rock03.png', 'rock04.png', 'rock05.png', \
                       'rock06.png', 'rock07.png', 'rock08.png', 'rock09.png', 'rock10.png', \
                       'rock11.png', 'rock12.png', 'rock13.png', 'rock14.png', 'rock15.png', \
                       'rock16.png', 'rock17.png', 'rock18.png', 'rock19.png', 'rock20.png', \
                       'rock21.png', 'rock22.png', 'rock23.png', 'rock24.png', 'rock25.png', \
                       'rock26.png', 'rock27.png', 'rock28.png', 'rock29.png', 'rock30.png')  # 운석 1 ~ 30 정의 / 튜플 적용
        self.image = pg.image.load(random.choice(rock_images))  # rock_images 에서 랜덤으로 이미지를 골라줘
        self.rect = self.image.get_rect()
        self.rect.x = xpos
        self.rect.y = ypos
        self.speed = speed

    # 운석 업데이트
    def update(self):
        self.rect.y += self.speed  # 위에서 밑으로 내려오는 값 +

    # 운석이 화면 밖으로 나갔을 경우
    def out_of_screen(self):
        if self.rect.y > WINDOW_HEIGHT:  # 운석의 y 값이 만약에 화면의 높이보다 커지면 = 운석이 아래 화면 끝까지 나갔을 때
            return True  # 나갔을 경우의 상황을 호출하기 위한 True


# 게임 화면 상에 표시 되는 텍스트 출력
def draw_text(text, font, surface, x, y, main_color):
    text_obj = font.render(text, True, main_color)  # font.render 로 폰트 정의 / 원하는 텍스트 색상 지정
    text_rect = text_obj.get_rect()  # 텍스트의 위치 지정
    text_rect.centerx = x
    text_rect.centery = y
    surface.blit(text_obj, text_rect)  # .blit(화면 출력할 개체, 출력할 위치)


# 폭발 효과
def occur_explosion(surface, x, y):
    explosion_image = pg.image.load('explosion.png')
    explosion_rect = explosion_image.get_rect()
    explosion_rect.x = x
    explosion_rect.y = y
    surface.blit(explosion_image, explosion_rect)

    explosion_sounds = ('explosion01.wav', 'explosion02.wav', 'explosion03.wav')
    explosion_sound = pg.mixer.Sound(random.choice(explosion_sounds))
    explosion_sound.play()


# 메인 게임의 루프
def game_loop():
    default_font = pg.font.Font('NanumGothic.ttf', 28)  # 게임 폰트
    background_image = pg.image.load('background.png')  # 게임 배경 이미지
    gameover_sound = pg.mixer.Sound('gameover.wav')  # 게임 종료
    pg.mixer.music.load('music.wav')  # 게임 음악
    pg.mixer.music.play(-1)  # 몇 번 재생할 것인가 (-1 = 무한)
    fps_clock = pg.time.Clock()  # 프레임

    fighter = Fighter()  # 만들었던 클래스를 인스턴스로 지정
    missiles = pg.sprite.Group()  # 여러 개의 미사일을 .Group() 으로 묶음
    rocks = pg.sprite.Group()  # 여러 개의 운석을 묶음

    occur_prob = 40  # 확률적으로 얼만큼 나오게 하는가
    shot_count = 0  # 맞춘 개수
    count_missed = 0  # 놓친 개수

    # 게임의 반복
    done = False
    while not done:  # done 이 만약에 True 가 된다면 반복문 종료
        for event in pg.event.get():  # event 에 pg.event.get() 를 가져오고
            if event.type == pg.KEYDOWN:  # event.type 이 키 다운 상태일 때 = 입력 상태일 때
                if event.key == pg.K_LEFT:  # 근데 만약에 event.key 가 왼쪽이 눌렸다면
                    fighter.dx -= 5  # 왼쪽(-x이동) 으로 5 만큼 이동
                elif event.key == pg.K_RIGHT:
                    fighter.dx += 5  # 오른쪽(+x이동) 으로 5 만큼 이동
                elif event.key == pg.K_UP:
                    fighter.dy -= 5  # 위(-y이동) 로 5 만큼 이동
                elif event.key == pg.K_DOWN:
                    fighter.dy += 5  # 아래(+y이동) 로 5 만큼 이동
                elif event.key == pg.K_SPACE:
                    missile = Missile(fighter.rect.centerx, fighter.rect.y, 10)  # Missle class > (xpos, ypos, speed)
                    missile.launch()
                    missiles.add(missile)  # 왜 넣어주는데?

            if event.type == pg.KEYUP:  # 키업 인 상태에서
                if event.key == pg.K_LEFT or event.key == pg.K_RIGHT:  # 왼쪽 or 오른쪽 키를 땠다면
                    fighter.dx = 0  # x 이동을 멈춘다
                elif event.key == pg.K_UP or event.key == pg.K_DOWN:  # 위 or 아래 키를 땠다면
                    fighter.dy = 0  # y 이동을 멈춘다

        screen.blit(background_image, background_image.get_rect())  # 화면 출력(백그라운드 이미지, 백그라운드 위치 좌표)

        # 만약의 운석을 100개 파괴 했다면, 스피드와 운석 수를 증가시킨다 = 난이도 상승
        occur_of_rocks = 1 + int(shot_count / 300)  # shot_count = 얼만큼 운석을 맞췄는가
        min_rock_speed = 1 + int(shot_count / 200)
        max_rock_speed = 1 + int(shot_count / 100)

        if random.randint(1, occur_prob) == 1:  # 1 부터 occur_prob(40) 사이의 1이 등장할 확률 = 1/40
            for i in range(occur_of_rocks):
                speed = random.randint(min_rock_speed, max_rock_speed)  # 스피드를 랜덤으로 선택
                rock = Rock(random.randint(0, WINDOW_WIDTH - 30), 0, speed)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지
                rocks.add(rock)

        # ('표시할 텍스트', 사용할 폰트, 표시할 화면, x좌표, y좌표, 색상)
        draw_text('파괴한 운석 : {}'.format(shot_count), default_font, screen, 100, 20, YELLOW)  # 파괴한 운석 표시
        draw_text('놓친 운석 : {}'.format(count_missed), default_font, screen, 400, 20, RED)  # 놓친 운석 표시

        # 미사일이 여러개 발사 됐을 때
        for missile in missiles:
            rock = missile.collide(rocks)  # 미사일이 운석과의 충돌 체크
            if rock:  # 충돌이 났다면
                missile.kill()  # 미사일 터짐
                rock.kill()  # 운석 터짐
                occur_explosion(screen, rock.rect.x, rock.rect.y)  # 운석이 터지는 효과(출력할 화면, x 위치, y 위치)
                shot_count += 1  # 운석을 파괴했을 때 점수 습득

        # 전체 운석들 중에서
        for rock in rocks:
            if rock.out_of_screen():  # 만약 운석이 화면 밖으로 나갔다면
                rock.kill()  # 운석 소멸
                count_missed += 1  # 놓친 수 증가

        rocks.update()
        rocks.draw(screen)
        missiles.update()
        missiles.draw(screen)
        fighter.update()
        fighter.draw(screen)
        pg.display.flip()

        # 게임이 끝나는 조건
        if fighter.collide(rocks) or count_missed >= 3:  # 우주선이 충돌이 났을 때 or 운석 놓친 개수가 3개 이상일 때
            pg.mixer_music.stop()  # 게임 음악이 꺼짐
            occur_explosion(screen, fighter.rect.x, fighter.rect.y)  # 우주선이 위치한 곳에서 터지는 효과
            pg.display.update()
            gameover_sound.play()  # 게임이 종료되는 음악
            sleep(1)  # 잠시 대기 1초
            done = True  # done 이 True 가 될 경우 게임은 종료된다. 153열 참조

        fps_clock.tick(FPS)  # 프레임 지정

    return 'game_menu'  # 게임 메뉴로 돌아감


# 게임 메뉴
def game_menu():
    start_image = pg.image.load('background.png')
    screen.blit(start_image, [0, 0])
    draw_x = int(WINDOW_WIDTH / 2)
    draw_y = int(WINDOW_HEIGHT / 4)
    font_70 = pg.font.Font('NanumGothic.ttf', 70)
    font_40 = pg.font.Font('NanumGothic.ttf', 40)

    draw_text('지구를 지켜라!', font_70, screen, draw_x, draw_y, YELLOW)
    draw_text('엔터 키를 누르면', font_40, screen, draw_x, draw_y + 200, WHITE)
    draw_text('게임이 시작됩니다.', font_40, screen, draw_x, draw_y + 250, WHITE)

    pg.display.update()

    # 이 화면 내에서 받아오는 키 값을 이벤트 처리
    for event in pg.event.get():
        if event.type == pg.KEYDOWN:
            if event.key == pg.K_RETURN:  # K_RETURN = 엔터 값
                return 'play'
        if event.type == QUIT:  # 게임 종료
            return 'quit'

    return 'game_menu'


# 게임 셋팅
def main():
    global screen

    pg.init()  # 초기화
    screen = pg.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))  # 화면 셋팅 .set_mode
    pg.display.set_caption('PyShooting')  # 화면 이름

    action = 'game_menu'
    while action != 'quit':  # 만약에 action 이 quit 이 아니면
        if action == 'game_menu':  # 만약에 action 이 게임 메뉴이면
            action = game_menu()
        elif action == 'play':  # 아니라면 action 이 플레이 라면
            action = game_loop()  # 게임 수행

    pg.quit()


# main 을 실행시키기 위해 __name__ 이 __main__ 일 경우에
if __name__ == "__main__":
    main()  # main() 을 실행 시켜라 > 게임 셋팅을 수행

출처 : https://youtu.be/W92RjjptAsM

나의 스타일 arrange

- 기존의 속성을 깨고 자신만의 코드로 바꾸어 실력 키우기
- 클래스의 사용방법과 부분 함수의 활용 이해

- 코드의 흐름 이해

게임 목표 : 네 방향 운석 막기

기능 정의

- 우주선 위치 고정

- 우주선 발사 방향 전환

- 우주선 미사일 사출 방향

- 우주선 미사일 이미지 방향

- 운석 충돌 방향

- 경로 : Route

- 다양해진 파일들을 폴더화 해서 정리하고, os 를 임포트 해서 폴더의 경로 설정과 지정 폴더의 파일 호출을 간편하게 사용

import os

# 이미지 폴더 경로 설정 / 파일명 지정
current_path = os.path.dirname(__file__)
image_path = os.path.join(current_path, "image")
sound_path = os.path.join(current_path, "sound")
font_path = os.path.join(current_path, "font")

user_image = pg.image.load(os.path.join(image_path, "fighter.png"))

- 미사일 이미지 방향

- 우주선의 일관적인 미사일 이미지를 회전시켜 나아가는 방향으로 정의

- Missile 메서드에서 rotate 함수를 정의하고 방향 입력값에 따른 이미지를 전환

def rotate(self, direction):  # 이미지 회전
    self.direction = direction
    if self.direction == 2:
        self.image = pg.transform.rotate(self.image, 180)
    elif self.direction == 3:
        self.image = pg.transform.rotate(self.image, 90)
    elif self.direction == 4:
        self.image = pg.transform.rotate(self.image, 270)

- 미사일 사출 방향

- 우주선의 한 방향으로만 사출되는 미사일을 네 방향으로 정의

- 회전과 마찬가지로 정의된 방향값에 따라 Missile 클래스의 이동 좌표 방향을 정의

- 화면 밖으로 나갈 시 미사일 제거

# 미사일 사출 방향
# 우주선 기준 상하좌우 방향으로 발사
def update(self):
    if self.direction == 1:
        self.rect.y -= self.speed  # 우주선에서 위로 발사되는 좌표 - / 해당하는 속도 만큼
        if self.rect.y + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
            self.kill()  # 화면 밖으로 나간 미사일은 없애줌
    elif self.direction == 2:
        self.rect.y += self.speed  # 우주선에서 아래로 발사되는 좌표 - / 해당하는 속도 만큼
        if self.rect.y + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
            self.kill()  # 화면 밖으로 나간 미사일은 없애줌
    elif self.direction == 3:
        self.rect.x -= self.speed  # 우주선에서 왼쪽으로 발사되는 좌표 - / 해당하는 속도 만큼
        if self.rect.x + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
            self.kill()  # 화면 밖으로 나간 미사일은 없애줌
    elif self.direction == 4:
        self.rect.x += self.speed  # 우주선에서 오른쪽으로 발사되는 좌표 - / 해당하는 속도 만큼
        if self.rect.x + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
            self.kill()  # 화면 밖으로 나간 미사일은 없애줌

- 우주선 키 이벤트 설정

- 고정 좌표의 우주선에서 키 이벤트를 통해 네 방향으로 키 이벤트 정의

- missile 을 키 이벤트에 따른 사출 지점과 속도 방향을 정의한 Missile 클래스를 담는다. 다음 사전 정의된 missiles의 sprite.Group() 으로 담는다.

missiles = pg.sprite.Group()  # 여러 개의 미사일을 .Group() 으로 묶음

# 게임의 반복
done = False
while not done:  # done 이 만약에 True 가 된다면 반복문 종료
    for event in pg.event.get():  # event 에 pg.event.get() 를 가져오고
        if event.type == pg.KEYDOWN:  # event.type 이 키 다운 상태일 때 = 입력 상태일 때
            if event.key == pg.K_UP:
                missile = Missile(fighter.rect.centerx - 9, fighter.rect.centery - 5, 10, 1)  # Missle class > (xpos, ypos, speed)
                # missile.launch()
                missiles.add(missile)
            elif event.key == pg.K_DOWN:
                missile = Missile(fighter.rect.centerx - 9, fighter.rect.centery - 5, 10, 2)  # Missle class > (xpos, ypos, speed)
                missile.rotate(2)
                # missile.launch()
                missiles.add(missile)
            elif event.key == pg.K_LEFT:  # 근데 만약에 event.key 가 왼쪽이 눌렸다면
                missile = Missile(fighter.rect.centerx - 5, fighter.rect.centery - 5, 10, 3)  # Missle class > (xpos, ypos, speed)
                missile.rotate(3)
                # missile.launch()
                missiles.add(missile)
            elif event.key == pg.K_RIGHT:
                missile = Missile(fighter.rect.centerx - 5, fighter.rect.centery - 5, 10, 4)  # Missle class > (xpos, ypos, speed)
                missile.rotate(4)
                # missile.launch()
                missiles.add(missile)
                
        # 미사일이 여러개 발사 됐을 때
        for missile in missiles:
            rock = missile.collide(rocks)  # 미사일이 운석과의 충돌 체크
            if rock:  # 충돌이 났다면
                missile.kill()  # 미사일 터짐
                rock.kill()  # 운석 터짐
                occur_explosion(screen, rock.rect.x, rock.rect.y)  # 운석이 터지는 효과(출력할 화면, x 위치, y 위치)
                shot_count += 1  # 운석을 파괴했을 때 점수 습득

- 운석 충돌 방향

- 게임의 창 WIDTH 와 HEIGHT 의 값으로 중간 지점 좌표를 계산

# 운석 충돌 방향 & 등장 확률
if random.randint(1, occur_prob) == 1:  # 1 부터 occur_prob(40) 사이의 1이 등장할 확률 = 1/40
    for i in range(occur_of_rocks):
        speed = random.randint(min_rock_speed, max_rock_speed)  # 스피드를 랜덤으로 선택
        rock_direction = random.randint(1, 4)
        if rock_direction == 1:
            rock = Rock(WINDOW_WIDTH / 2 - 40, 640, speed, 1)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지
        elif rock_direction == 2:
            rock = Rock(WINDOW_WIDTH / 2 - 40, 0, speed, 2)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지
        elif rock_direction == 3:
            rock = Rock(640, WINDOW_HEIGHT / 2 - 20, speed, 3)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지
        elif rock_direction == 4:
            rock = Rock(0, WINDOW_HEIGHT / 2 - 20, speed, 4)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지

        rocks.add(rock)

- 미구현 기능

- 운석간의 중첩 방지

- 최고점 스코어 기록 기능

- 난이도 상승 시 구분 표시 기능

- 1차 완성

import random
from time import sleep

import os
import pygame as pg
from pygame.locals import *

# 창 사이즈 전역변수
WINDOW_WIDTH = 640
WINDOW_HEIGHT = 640

# 색상 정의
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
YELLOW = (250, 250, 50)
RED = (250, 50, 50)

# 이미지 경로 설정
current_path = os.path.dirname(__file__)
image_path = os.path.join(current_path, "../image")
sound_path = os.path.join(current_path, "../sound")
font_path = os.path.join(current_path, "../font")

# 초당 프레임
FPS = 60


# 우주선 클래스
# 게임에서 나타내는 모든 캐릭터, 장애물등을 표현할 때 사용하는 Surface 상속을 받아온다.
class Fighter(pg.sprite.Sprite):
    # 다른 객체지향 언어에서는 생성자(constructor)라고 부른답니다
    # 초기화 메서드, 어떤 클래스의 객체가 만들어질 때 자동으로 호출되어서 그 객체가 갖게 될 여러 가지 성질을 정해주는 일
    def __init__(self):  # 단일
        super(Fighter, self).__init__()  # 상위 클래스 __init__ 호출
        self.image = pg.image.load(os.path.join(image_path, "fighter3.svg"))  # self(Fighter의 초기화 값) 에 입힐 이미지를 가져온다.
        self.rect = self.image.get_rect()  # 이미지 크기 조정 .get_rect(none)[크기 정보 + 좌표 정보]
        self.rect.x = int(WINDOW_WIDTH / 2 - self.rect.width / 2)  # 처음 우주선의 등장 위치 (WINDOW_WIDTH / 2 = 창의 너비의 중앙)
        self.rect.y = int(WINDOW_HEIGHT / 2 - self.rect.height / 2)  # 우주선의 높이 만큼 빼서 y 값을 지정
        self.dx = 0  # x 방향
        self.dy = 0  # y 방향

    # 화면 밖으로 나갔을 경우를 대비한 루트
    def update(self):
        self.rect.x += self.dx  # 우주선.rect.x 위치가 우주선.dx 이동한 위치 만큼 더해진다.
        self.rect.y += self.dy  # 움직임 필수적인 부분

        # 우주선.rect.x 좌표가 0 보다 작은 경우는 = 화면 밖으로 나가는 경우
        # 만약 X 위치가 우주선의 너비를 포함한 좌표가 창의 너비보다 클 경우
        if self.rect.x < 0 or self.rect.x + self.rect.width > WINDOW_WIDTH:  # 창의 밖으로 나갔을 경우를 대비
            self.rect.x -= self.dx  # 나가면 움직임을 멈춤

        # 우주선.rect.y 좌표가 0 보다 작은 경우는 = 화면 밖으로 나가는 경우
        # 만약 Y 위치가 우주선의 높이를 포함한 좌표가 창의 높이보다 클 경우
        if self.rect.y < 0 or self.rect.y + self.rect.height > WINDOW_HEIGHT:
            self.rect.y -= self.dy

    # 그려주는 부분
    def draw(self, screen):  # self 에서 스크린 값을 받아온다.
        screen.blit(self.image, self.rect)  # 화면에 그려줌 우주선(self) 의 이미지와 우주선(self) 의 사이즈

    def collide(self, sprites):
        for sprite in sprites:  # 객체 관리를 편하게 하기 위한 방법
            if pg.sprite.collide_rect(self, sprite):  # 검사 중 우주선과 sprite 와 충돌했을 경우 / .collide_rect = 충돌 체크
                return sprite  # 충돌 난 sprite return


# 미사일 클래스
class Missile(pg.sprite.Sprite):
    def __init__(self, xpos, ypos, speed, direction):  # 초기화 메서드, 불러올 값 지정
        super(Missile, self).__init__()
        self.image = pg.image.load(os.path.join(image_path, "firetrail.png"))
        self.rect = self.image.get_rect()  # 미사일 사이즈
        self.rect.x = xpos  # 미사일 호출하는 위치 값 지정 / 우주선에서 발사할 수 있게 만들기 위한
        self.rect.y = ypos
        self.speed = speed
        self.direction = direction
        self.sound = pg.mixer.Sound(os.path.join(sound_path, "missile.wav"))

    def launch(self):  # 발사에 대한 소리
        self.sound.play()  # 소리 재생

    def rotate(self, direction):  # 이미지 회전
        self.direction = direction
        if self.direction == 2:
            self.image = pg.transform.rotate(self.image, 180)
        elif self.direction == 3:
            self.image = pg.transform.rotate(self.image, 90)
        elif self.direction == 4:
            self.image = pg.transform.rotate(self.image, 270)

    # 미사일 사출 방향
    # 우주선 기준 상하좌우 방향으로 발사
    def update(self):
        if self.direction == 1:
            self.rect.y -= self.speed  # 우주선에서 위로 발사되는 좌표 - / 해당하는 속도 만큼
            if self.rect.y + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
                self.kill()  # 화면 밖으로 나간 미사일은 없애줌
        elif self.direction == 2:
            self.rect.y += self.speed  # 우주선에서 아래로 발사되는 좌표 - / 해당하는 속도 만큼
            if self.rect.y + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
                self.kill()  # 화면 밖으로 나간 미사일은 없애줌
        elif self.direction == 3:
            self.rect.x -= self.speed  # 우주선에서 왼쪽으로 발사되는 좌표 - / 해당하는 속도 만큼
            if self.rect.x + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
                self.kill()  # 화면 밖으로 나간 미사일은 없애줌
        elif self.direction == 4:
            self.rect.x += self.speed  # 우주선에서 오른쪽으로 발사되는 좌표 - / 해당하는 속도 만큼
            if self.rect.x + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
                self.kill()  # 화면 밖으로 나간 미사일은 없애줌


        # self.rect.x -= self.speed  # 아래에서 위로 발사되는 좌표 - / 해당하는 속도 만큼
        # if self.rect.x + self.rect.height < 0:  # 만약에 y 값에 높이가 더해진 값으로 0 보다 작으면 = 미사일이 화면 밖으로 나감
        #     self.kill()  # 화면 밖으로 나간 미사일은 없애줌

    # 미사일 충돌 체크
    def collide(self, sprites):
        for sprite in sprites:
            if pg.sprite.collide_rect(self, sprite):
                return sprite


# 운석 클래스
class Rock(pg.sprite.Sprite):
    def __init__(self, xpos, ypos, speed, direction):  # 초기화 메서드, 운석의 좌표 및 스피드
        super(Rock, self).__init__()
        rock_images = (os.path.join(image_path, "rock01.png"), os.path.join(image_path, "rock02.png"), os.path.join(image_path, "rock03.png"), os.path.join(image_path, "rock04.png"), os.path.join(image_path, "rock05.png"))  # 운석 1 ~ 5 정의 / 튜플 적용
        self.image = pg.image.load(random.choice(rock_images))  # rock_images 에서 랜덤으로 이미지를 골라줘
        self.rect = self.image.get_rect()
        self.rect.x = xpos
        self.rect.y = ypos
        self.speed = speed
        self.direction = direction

    # 운석 업데이트
    def update(self):
        # self.rect.y += self.speed  # 위에서 밑으로 내려오는 값 +

        if self.direction == 1:  # 아래에서 위로
            self.rect.y -= self.speed
        elif self.direction == 2:  # 위에서 아래로
            self.rect.y += self.speed
        elif self.direction == 3:  # 오른쪽에서 왼쪽으로
            self.rect.x -= self.speed
        elif self.direction == 4:  # 왼쪽에서 오른쪽으로
            self.rect.x += self.speed

    # 운석이 화면 밖으로 나갔을 경우
    def out_of_screen(self):
        if self.rect.y > WINDOW_HEIGHT:  # 운석의 y 값이 만약에 화면의 높이보다 커지면 = 운석이 아래 화면 끝까지 나갔을 때
            return True  # 나갔을 경우의 상황을 호출하기 위한 True


# 게임 화면 상에 표시 되는 텍스트 출력
def draw_text(text, font, surface, x, y, main_color):
    text_obj = font.render(text, True, main_color)  # font.render 로 폰트 정의 / 원하는 텍스트 색상 지정
    text_rect = text_obj.get_rect()  # 텍스트의 위치 지정
    text_rect.centerx = x
    text_rect.centery = y
    surface.blit(text_obj, text_rect)  # .blit(화면 출력할 개체, 출력할 위치)


# 폭발 효과
def occur_explosion(surface, x, y):
    explosion_image = pg.image.load(os.path.join(image_path, "explosion.png"))
    explosion_rect = explosion_image.get_rect()
    explosion_rect.x = x
    explosion_rect.y = y
    surface.blit(explosion_image, explosion_rect)

    explosion_sounds = (os.path.join(sound_path, "explosion01.wav"), os.path.join(sound_path, "explosion02.wav"), os.path.join(sound_path, "explosion03.wav"))
    explosion_sound = pg.mixer.Sound(random.choice(explosion_sounds))
    explosion_sound.play()


# 메인 게임의 루프
def game_loop():
    default_font = pg.font.Font(os.path.join(font_path, "NanumGothic.ttf"), 28)  # 게임 폰트
    background_image = pg.image.load(os.path.join(image_path, "background3.jpg"))  # 게임 배경 이미지
    gameover_sound = pg.mixer.Sound(os.path.join(sound_path, "gameover.wav"))  # 게임 종료
    pg.mixer.music.load(os.path.join(sound_path, "music.wav"))  # 게임 음악
    pg.mixer.music.play(-1)  # 몇 번 재생할 것인가 (-1 = 무한)
    fps_clock = pg.time.Clock()  # 프레임

    fighter = Fighter()  # 만들었던 클래스를 인스턴스로 지정
    missiles = pg.sprite.Group()  # 여러 개의 미사일을 .Group() 으로 묶음
    rocks = pg.sprite.Group()  # 여러 개의 운석을 묶음

    occur_prob = 30  # 확률적으로 얼만큼 나오게 하는가
    shot_count = 0  # 맞춘 개수
    # count_missed = 0  # 놓친 개수

    # 게임의 반복
    done = False
    while not done:  # done 이 만약에 True 가 된다면 반복문 종료
        for event in pg.event.get():  # event 에 pg.event.get() 를 가져오고
            if event.type == pg.KEYDOWN:  # event.type 이 키 다운 상태일 때 = 입력 상태일 때
                if event.key == pg.K_UP:
                    missile = Missile(fighter.rect.centerx - 9, fighter.rect.centery - 5, 10, 1)  # Missle class > (xpos, ypos, speed)
                    # missile.launch()
                    missiles.add(missile)
                elif event.key == pg.K_DOWN:
                    missile = Missile(fighter.rect.centerx - 9, fighter.rect.centery - 5, 10, 2)  # Missle class > (xpos, ypos, speed)
                    missile.rotate(2)
                    # missile.launch()
                    missiles.add(missile)
                elif event.key == pg.K_LEFT:  # 근데 만약에 event.key 가 왼쪽이 눌렸다면
                    missile = Missile(fighter.rect.centerx - 5, fighter.rect.centery - 5, 10, 3)  # Missle class > (xpos, ypos, speed)
                    missile.rotate(3)
                    # missile.launch()
                    missiles.add(missile)
                elif event.key == pg.K_RIGHT:
                    missile = Missile(fighter.rect.centerx - 5, fighter.rect.centery - 5, 10, 4)  # Missle class > (xpos, ypos, speed)
                    missile.rotate(4)
                    # missile.launch()
                    missiles.add(missile)

            # if event.type == pg.KEYUP:  # 키업 인 상태에서
            #     if event.key == pg.K_LEFT or event.key == pg.K_RIGHT:  # 왼쪽 or 오른쪽 키를 땠다면
            #         fighter.dx = 0  # x 이동을 멈춘다
            #     elif event.key == pg.K_UP or event.key == pg.K_DOWN:  # 위 or 아래 키를 땠다면
            #         fighter.dy = 0  # y 이동을 멈춘다

        screen.blit(background_image, background_image.get_rect())  # 화면 출력(백그라운드 이미지, 백그라운드 위치 좌표)

        # 만약의 운석을 100개 파괴 했다면, 스피드와 운석 수를 증가시킨다 = 난이도 상승
        occur_of_rocks = 1 + int(shot_count / 300)  # shot_count = 얼만큼 운석을 맞췄는가
        min_rock_speed = 1 + int(shot_count / 200)
        max_rock_speed = 1 + int(shot_count / 100)

        # 운석 등장 확률
        if random.randint(1, occur_prob) == 1:  # 1 부터 occur_prob(40) 사이의 1이 등장할 확률 = 1/40
            for i in range(occur_of_rocks):
                speed = random.randint(min_rock_speed, max_rock_speed)  # 스피드를 랜덤으로 선택
                rock_direction = random.randint(1, 4)
                if rock_direction == 1:
                    rock = Rock(WINDOW_WIDTH / 2 - 40, 640, speed, 1)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지
                elif rock_direction == 2:
                    rock = Rock(WINDOW_WIDTH / 2 - 40, 0, speed, 2)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지
                elif rock_direction == 3:
                    rock = Rock(640, WINDOW_HEIGHT / 2 - 20, speed, 3)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지
                elif rock_direction == 4:
                    rock = Rock(0, WINDOW_HEIGHT / 2 - 20, speed, 4)  # 0 부터 X 좌표(너비 좌표에서 30정도 뺀 값)까지

                rocks.add(rock)

        # ('표시할 텍스트', 사용할 폰트, 표시할 화면, x좌표, y좌표, 색상)
        draw_text('파괴한 운석 : {}'.format(shot_count), default_font, screen, 100, 20, YELLOW)  # 파괴한 운석 표시
        # draw_text('놓친 운석 : {}'.format(count_missed), default_font, screen, 400, 20, RED)  # 놓친 운석 표시

        # 미사일이 여러개 발사 됐을 때
        for missile in missiles:
            rock = missile.collide(rocks)  # 미사일이 운석과의 충돌 체크
            if rock:  # 충돌이 났다면
                missile.kill()  # 미사일 터짐
                rock.kill()  # 운석 터짐
                occur_explosion(screen, rock.rect.x, rock.rect.y)  # 운석이 터지는 효과(출력할 화면, x 위치, y 위치)
                shot_count += 1  # 운석을 파괴했을 때 점수 습득

        rocks.update()
        rocks.draw(screen)
        missiles.update()
        missiles.draw(screen)
        fighter.update()
        fighter.draw(screen)
        pg.display.flip()

        # 게임이 끝나는 조건
        # if fighter.collide(rocks) or count_missed >= 3:  # 우주선이 충돌이 났을 때 or 운석 놓친 개수가 3개 이상일 때
        if fighter.collide(rocks):  # 우주선이 충돌이 났을 때 or 운석 놓친 개수가 3개 이상일 때
            pg.mixer_music.stop()  # 게임 음악이 꺼짐
            occur_explosion(screen, fighter.rect.x, fighter.rect.y)  # 우주선이 위치한 곳에서 터지는 효과
            pg.display.update()
            gameover_sound.play()  # 게임이 종료되는 음악
            sleep(1)  # 잠시 대기 1초
            done = True  # done 이 True 가 될 경우 게임은 종료된다. 153열 참조

        fps_clock.tick(FPS)  # 프레임 지정

    return 'game_menu'  # 게임 메뉴로 돌아감

#

# 게임 메뉴
def game_menu():
    start_image = pg.image.load(os.path.join(image_path, "background_menu.png"))
    screen.blit(start_image, [0, 0])
    draw_x = int(WINDOW_WIDTH / 2)
    draw_y = int(WINDOW_HEIGHT / 4)
    font_70 = pg.font.Font(os.path.join(font_path, "NanumGothic.ttf"), 70)
    font_40 = pg.font.Font(os.path.join(font_path, "NanumGothic.ttf"), 40)

    draw_text('지구를 지켜라!', font_70, screen, draw_x, draw_y, YELLOW)
    draw_text('엔터 키를 누르면', font_40, screen, draw_x, draw_y + 200, WHITE)
    draw_text('게임이 시작됩니다.', font_40, screen, draw_x, draw_y + 250, WHITE)

    # draw_text('파괴한 운석 : {}'.format(shot_count), default_font, screen, 100, 20, YELLOW)  # 파괴한 운석 표시

    pg.display.update()

    # 게임 최고점

    # 이 화면 내에서 받아오는 키 값을 이벤트 처리
    for event in pg.event.get():
        if event.type == pg.KEYDOWN:
            if event.key == pg.K_RETURN:  # K_RETURN = 엔터 값
                return 'play'
        if event.type == QUIT:  # 게임 종료
            return 'quit'

    return 'game_menu'


# 게임 셋팅
def main():
    global screen

    pg.init()  # 초기화
    screen = pg.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))  # 화면 셋팅 .set_mode
    pg.display.set_caption('PyShooting')  # 화면 이름

    action = 'game_menu'
    while action != 'quit':  # 만약에 action 이 quit 이 아니면
        if action == 'game_menu':  # 만약에 action 이 게임 메뉴이면
            action = game_menu()
        elif action == 'play':  # 아니라면 action 이 플레이 라면
            action = game_loop()  # 게임 수행

    pg.quit()


# main 을 실행시키기 위해 __name__ 이 __main__ 일 경우에
if __name__ == "__main__":
    main()  # main() 을 실행 시켜라 > 게임 셋팅을 수행

'👦 내일배움캠프 > TIL(Today I Learned)' 카테고리의 다른 글

TIL_220428_인스타 데스크탑 UI 클론 (0)	2023.01.01
TIL_220427 (0)	2023.01.01
TIL_220425 (0)	2023.01.01
TIL_220422_미니 팀 프로젝트 (0)	2023.01.01
TIL_220421_미니 팀 프로젝트 (1)	2023.01.01

Contents

새소식

인기 검색어

TIL_220426

'👦 내일배움캠프 > TIL(Today I Learned)' 카테고리의 다른 글

당신이 좋아할만한 콘텐츠

티스토리툴바