프로젝트 개요

• pygame을 사용하여 Pirate Mario제작
• Youtube Clear Code의 Platformer in Pygame을 따라하며 진행
• 주요 과제: 키보드 입력을 받아 플레이어를 움직이고 맵에서 벽과 바닥을 구현, 플레이어가 좌우측 끝으로 이동하는 경우를 위한 카메라 구현

프로젝트 내용

main.py

import pygame
from sys import exit
from settings import *
from level import Level

pygame.init()

screen = pygame.display.set_mode((1200, 700))
clock = pygame.time.Clock()

level = Level(level_map, screen)

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

    screen.fill('black')
    level.run()

    pygame.display.update()
    clock.tick(60)

settings.py

level_map = [
'                            ',
'                            ',
'                            ',
' XX    XXX            XX    ',
' XX P                       ',
' XXXX         XX         XX ',
' XXXX       XX              ',
' XX    X  XXXX    XX  XX    ',
'       X  XXXX    XX  XXX   ',
'    XXXX  XXXXXX  XX  XXXX  ',
'XXXXXXXX  XXXXXX  XX  XXXX  ']

tile_size = 64
screen_width = 1200
screen_height = len(level_map) * tile_size

tiles.py

import pygame

class Tile(pygame.sprite.Sprite):
    def __init__(self, size, pos):
        super().__init__()
        self.image = pygame.Surface((size, size))
        self.image.fill('grey')
        self.rect = self.image.get_rect(topleft = pos)

    def update(self, world_shift):
        # update for camera
        # move the entire map by the variable, world_shift
        self.rect.x += world_shift

• 카메라 구현을 위해 맵 전체를 이동시킬 수 있는 변수 생성

player.py

import pygame

class Player(pygame.sprite.Sprite):
    def __init__(self, pos):
        super().__init__()
        self.image = pygame.Surface((32, 64))
        self.image.fill('red')
        self.rect = self.image.get_rect(topleft = pos)

        self.direction = pygame.math.Vector2(0, 0)      # a 2-dimensional vector
        self.player_speed = 8
        self.gravity = 0.8
        self.jump_speed = -16

    def get_input(self):
        keys = pygame.key.get_pressed()

        if keys[pygame.K_RIGHT]: self.direction.x = 1
        elif keys[pygame.K_LEFT]: self.direction.x = -1
        else: self.direction.x = 0

        if keys[pygame.K_SPACE]: self.jump()

    def apply_gravity(self):
        self.direction.y += self.gravity
        self.rect.y += self.direction.y

    def jump(self):
        self.direction.y = self.jump_speed

    def update(self):
        self.get_input()

• key를 입력받아 플레이어를 좌, 우 그리고 점프를 할 수 있도록 설정
• 바닥이 구현될 경우 플레이어가 설 수 있도록 중력을 구현

level.py

import pygame
from settings import tile_size, screen_width
from tiles import Tile
from player import Player

class Level:
    def __init__(self, level_data, surface):
        super().__init__()
        self.display_surface = surface
        self.setup_level(level_data)
        self.world_shift = 0

    def setup_level(self, level_data):
        self.tiles = pygame.sprite.Group()              # a container class to hold and manage multiple sprite objects
                                                        # there are tiles
        self.player = pygame.sprite.GroupSingle()       # group container that holds a single sprite
                                                        # there is just one player

        for row_index, row in enumerate(level_data):
            for col_index, cell in enumerate(row):

                x = col_index * tile_size
                y = row_index * tile_size

                if cell == 'X':
                    tile = Tile(tile_size, (x, y))
                    self.tiles.add(tile)        # add sprites to this group

                elif cell == 'P':
                    player = Player((x, y))
                    self.player.add(player)     # add a single sprite to this group

    def scroll_x(self):
        player = self.player.sprite
        player_x = player.rect.centerx
        direction_x = player.direction.x

        if player_x < screen_width / 4 and direction_x < 0:
            # when player moves to the left
            # if player moves too far from the right
            # then camera moves to the left by moving the entire map to the right
            self.world_shift = 8
            player.player_speed = 0

        elif player_x > screen_width - (screen_width / 4) and direction_x > 0:
            # when player moves to the right
            # if player moves too far from the left
            # then camera moves to the right by moving the entire map to the left
            self.world_shift = -8
            player.player_speed = 0

        else:
            self.world_shift = 0
            player.player_speed = 8

    # check horizontal collision and vertical collision each other
    # to access to the rectangle of each of the tile
    # using rect.colliderect is better than sprite.collide_rect (more convenient)
    def horizontal_movement_collision(self):
        player = self.player.sprite
        player.rect.x += player.direction.x * player.player_speed

        for sprite in self.tiles.sprites():
            if sprite.rect.colliderect(player.rect):
                if player.direction.x < 0:
                    player.rect.left = sprite.rect.right
                elif player.direction.x > 0:
                    player.rect.right = sprite.rect.left

    def vertical_movement_collision(self):
        player = self.player.sprite
        player.apply_gravity()

        for sprite in self.tiles.sprites():
            if sprite.rect.colliderect(player.rect):
                if player.direction.y > 0:
                    player.rect.bottom = sprite.rect.top
                    player.direction.y = 0
                elif player.direction.y < 0:
                    player.rect.top = sprite.rect.bottom
                    player.direction.y = 0

    def run(self):
        self.tiles.update(self.world_shift)
        self.tiles.draw(self.display_surface)
        self.scroll_x()

        self.player.update()
        self.horizontal_movement_collision()
        self.vertical_movement_collision()
        self.player.draw(self.display_surface)

• 상, 하, 좌, 우 움직임과 바닥, 벽 사이의 충돌을 통해 벽과 바닥을 구현하기 위해 horizontal_movement_collision과 vertical_movement_collision을 정의

KEEP

• 없음

PROBLEM

• class의 사용에 미숙함
• 바닥과 벽을 구현하기 위해 함수를 정의할 때 어떤 class를 호출하고 method를 사용할지 그리고 어떠한 방식으로 구현할지 이해하는 것에 상당히 시간이 많이 소요됨

TRY

• class의 사용과 상속에 대해 다시 공부하고 코드 복기
• 함수를 스스로 생각해내서 만들어내기 위해 알고리즘적 사고력을 키워야함을 느낌