파이썬 테트리스 게임 만들기

안녕하세요 슈가 입니다.

 

---

이 프로그램은 간단한 테트리스 게임 입니다. 국민 게임이죠. 모르는 사람이 없을 정도로 단순하면서 재미 있습니다.

 

 

다음은 프로그램의 작동 방식에 대한 설명입니다.

 

 

게임 방법 입니다.

 

• 아래 방향키: 블록을 더 빠르게 내립니다.
• 왼쪽/오른쪽 방향키: 블록을 왼쪽/오른쪽으로 이동시킵니다.
• 위 방향키: 블록을 시계 방향으로 회전시킵니다.
• ESC 키: 게임을 종료합니다.
• P 키: 게임을 일시 중지합니다.
• RETURN 키: 블록을 즉시 내립니다.

프로그램 : https://www.python.org/ 홈 방문
Downloads에 본인 pc os에 맞는 버전 다운로드
슈가는 python 3.10 32bt 사용

에디터 : Visual Studio Code 사용

 

 

코드 이해를 돕기 위해 아래 간단히 설명 드립니다.

 

주요 구현 내용은 다음과 같습니다.

• tetris_shapes: 7가지 다른 블록 모양을 나타내는 리스트입니다.
• new_board(): 게임판을 초기화하고, 바닥부분에 1이 채워진 리스트를 추가합니다.
• check_collision(): 현재 블록이 게임판에서 충돌하는지 확인합니다.
• remove_row(): 게임판에서 한 줄을 삭제하고 새로운 빈 줄을 추가합니다.
• join_matrixes(): 두 개의 매트릭스를 합쳐서 반환합니다.
• new_stone(): 새로운 블록을 생성합니다.
• disp_msg(): 메시지를 화면에 표시합니다.
• center_msg(): 화면 중앙에 메시지를 표시합니다.
• draw_matrix(): 매트릭스를 화면에 그립니다.
• add_cl_lines(): 삭제한 줄의 개수에 따라 점수와 레벨을 업데이트합니다.
• move(): 현재 블록을 왼쪽이나 오른쪽으로 이동시킵니다.
• quit(): 게임을 종료합니다.
• drop(): 현재 블록을 아래 방향으로 이동시킵니다.
• insta_drop(): 현재 블록을 즉시 아래로 이동시킵니다.
• rotate_stone(): 현재 블록을 시계 방향으로 회전시킵니다.
• toggle_pause(): 게임 일시 중지 여부를 전환합니다.
• start_game(): 새 게임을 시작합니다.
• run(): 게임 루프를 실행합니다. 이 부분에서 게임판, 블록, 메시지 등을 화면에 그리고, 키보드 입력을 처리합니다.

 

프로그램 실행전 꼭 꼭 pygame 설치하시고 하세요.,

pip install pygame 실행

 

설치가 완료되면 아래 코드를 실행하세요.

#!/usr/bin/env python3
#-*- coding: utf-8 -*-
 
# Very simple tetris implementation
#
# Control keys:
# Down - Drop stone faster
# Left/Right - Move stone
# Up - Rotate Stone clockwise
# Escape - Quit game
# P - Pause game
# Return - Instant drop
#
# Have fun!
 
# NOTE: If you're looking for the old python2 version, see
# <https://gist.github.com/silvasur/565419/45a3ded61b993d1dd195a8a8688e7dc196b08de8>
 
# Copyright (c) 2010 "Laria Carolin Chabowski"<me@laria.me>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
 
 
from random import randrange as rand
import pygame, sys
 
# The configuration
cell_size = 18
cols = 10
rows = 22
maxfps = 30
 
colors = [
(0, 0, 0 ),
(255, 85, 85),
(100, 200, 115),
(120, 108, 245),
(255, 140, 50 ),
(50, 120, 52 ),
(146, 202, 73 ),
(150, 161, 218 ),
(35, 35, 35) # Helper color for background grid
]
 
# Define the shapes of the single parts
tetris_shapes = [
[[1, 1, 1],
[0, 1, 0]],
 
[[0, 2, 2],
[2, 2, 0]],
 
[[3, 3, 0],
[0, 3, 3]],
 
[[4, 0, 0],
[4, 4, 4]],
 
[[0, 0, 5],
[5, 5, 5]],
 
[[6, 6, 6, 6]],
 
[[7, 7],
[7, 7]]
]
 
def rotate_clockwise(shape):
return [
[ shape[y][x] for y in range(len(shape)) ]
for x in range(len(shape[0]) - 1, -1, -1)
]
 
def check_collision(board, shape, offset):
off_x, off_y = offset
for cy, row in enumerate(shape):
for cx, cell in enumerate(row):
try:
if cell and board[ cy + off_y ][ cx + off_x ]:
return True
except IndexError:
return True
return False
 
def remove_row(board, row):
del board[row]
return [[0 for i in range(cols)]] + board
 
def join_matrixes(mat1, mat2, mat2_off):
off_x, off_y = mat2_off
for cy, row in enumerate(mat2):
for cx, val in enumerate(row):
mat1[cy+off_y-1 ][cx+off_x] += val
return mat1
 
def new_board():
board = [
[ 0 for x in range(cols) ]
for y in range(rows)
]
board += [[ 1 for x in range(cols)]]
return board
 
class TetrisApp(object):
def __init__(self):
pygame.init()
pygame.key.set_repeat(250,25)
self.width = cell_size*(cols+6)
self.height = cell_size*rows
self.rlim = cell_size*cols
self.bground_grid = [[ 8 if x%2==y%2 else 0 for x in range(cols)] for y in range(rows)]
 
self.default_font = pygame.font.Font(
pygame.font.get_default_font(), 12)
 
self.screen = pygame.display.set_mode((self.width, self.height))
pygame.event.set_blocked(pygame.MOUSEMOTION) # We do not need
# mouse movement
# events, so we
# block them.
self.next_stone = tetris_shapes[rand(len(tetris_shapes))]
self.init_game()
 
def new_stone(self):
self.stone = self.next_stone[:]
self.next_stone = tetris_shapes[rand(len(tetris_shapes))]
self.stone_x = int(cols / 2 - len(self.stone[0])/2)
self.stone_y = 0
 
if check_collision(self.board,
self.stone,
(self.stone_x, self.stone_y)):
self.gameover = True
 
def init_game(self):
self.board = new_board()
self.new_stone()
self.level = 1
self.score = 0
self.lines = 0
pygame.time.set_timer(pygame.USEREVENT+1, 1000)
 
def disp_msg(self, msg, topleft):
x,y = topleft
for line in msg.splitlines():
self.screen.blit(
self.default_font.render(
line,
False,
(255,255,255),
(0,0,0)),
(x,y))
y+=14
 
def center_msg(self, msg):
for i, line in enumerate(msg.splitlines()):
msg_image = self.default_font.render(line, False,
(255,255,255), (0,0,0))
 
msgim_center_x, msgim_center_y = msg_image.get_size()
msgim_center_x //= 2
msgim_center_y //= 2
 
self.screen.blit(msg_image, (
self.width // 2-msgim_center_x,
self.height // 2-msgim_center_y+i*22))
 
def draw_matrix(self, matrix, offset):
off_x, off_y = offset
for y, row in enumerate(matrix):
for x, val in enumerate(row):
if val:
pygame.draw.rect(
self.screen,
colors[val],
pygame.Rect(
(off_x+x) *
cell_size,
(off_y+y) *
cell_size,
cell_size,
cell_size),0)
 
def add_cl_lines(self, n):
linescores = [0, 40, 100, 300, 1200]
self.lines += n
self.score += linescores[n] * self.level
if self.lines >= self.level*6:
self.level += 1
newdelay = 1000-50*(self.level-1)
newdelay = 100 if newdelay < 100 else newdelay
pygame.time.set_timer(pygame.USEREVENT+1, newdelay)
 
def move(self, delta_x):
if not self.gameover and not self.paused:
new_x = self.stone_x + delta_x
if new_x < 0:
new_x = 0
if new_x > cols - len(self.stone[0]):
new_x = cols - len(self.stone[0])
if not check_collision(self.board,
self.stone,
(new_x, self.stone_y)):
self.stone_x = new_x
def quit(self):
self.center_msg("Exiting...")
pygame.display.update()
sys.exit()
 
def drop(self, manual):
if not self.gameover and not self.paused:
self.score += 1 if manual else 0
self.stone_y += 1
if check_collision(self.board,
self.stone,
(self.stone_x, self.stone_y)):
self.board = join_matrixes(
self.board,
self.stone,
(self.stone_x, self.stone_y))
self.new_stone()
cleared_rows = 0
while True:
for i, row in enumerate(self.board[:-1]):
if 0 not in row:
self.board = remove_row(
self.board, i)
cleared_rows += 1
break
else:
break
self.add_cl_lines(cleared_rows)
return True
return False
 
def insta_drop(self):
if not self.gameover and not self.paused:
while(not self.drop(True)):
pass
 
def rotate_stone(self):
if not self.gameover and not self.paused:
new_stone = rotate_clockwise(self.stone)
if not check_collision(self.board,
new_stone,
(self.stone_x, self.stone_y)):
self.stone = new_stone
 
def toggle_pause(self):
self.paused = not self.paused
 
def start_game(self):
if self.gameover:
self.init_game()
self.gameover = False
 
def run(self):
key_actions = {
'ESCAPE': self.quit,
'LEFT': lambda:self.move(-1),
'RIGHT': lambda:self.move(+1),
'DOWN': lambda:self.drop(True),
'UP': self.rotate_stone,
'p': self.toggle_pause,
'SPACE': self.start_game,
'RETURN': self.insta_drop
}
 
self.gameover = False
self.paused = False
 
dont_burn_my_cpu = pygame.time.Clock()
while 1:
self.screen.fill((0,0,0))
if self.gameover:
self.center_msg("""Game Over!\nYour score: %d
Press space to continue""" % self.score)
else:
if self.paused:
self.center_msg("Paused")
else:
pygame.draw.line(self.screen,
(255,255,255),
(self.rlim+1, 0),
(self.rlim+1, self.height-1))
self.disp_msg("Next:", (
self.rlim+cell_size,
2))
self.disp_msg("Score: %d\n\nLevel: %d\
\nLines: %d" % (self.score, self.level, self.lines),
(self.rlim+cell_size, cell_size*5))
self.draw_matrix(self.bground_grid, (0,0))
self.draw_matrix(self.board, (0,0))
self.draw_matrix(self.stone,
(self.stone_x, self.stone_y))
self.draw_matrix(self.next_stone,
(cols+1,2))
pygame.display.update()
 
for event in pygame.event.get():
if event.type == pygame.USEREVENT+1:
self.drop(False)
elif event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
for key in key_actions:
if event.key == eval("pygame.K_"
+key):
key_actions[key]()
 
dont_burn_my_cpu.tick(maxfps)
 
if __name__ == '__main__':
App = TetrisApp()
App.run()

재미 있는 게임 즐기세요.