파이썬 프로그램

파이썬으로 만드는 게임, 마인스위퍼: 간단하고 재미있게 지뢰 찾기에 도전하세요.

슈가가족 2023. 7. 13. 05:57

여기서 게임의 목표는 모든 지뢰가 없는 칸을 열거나 모든 지뢰에 깃발을 세우는 것입니다. 게임이 시작되면, 플레이어는 각 타일을 좌클릭하여 열거나 우클릭하여 지뢰를 표시합니다.

 

게임 시작하기

 

게임은 pygame 라이브러리를 사용하여 만들어졌습니다. pygame은 파이썬에서 2D 게임을 만들기 위한 라이브러리입니다. 게임은 총 800x600 픽셀의 스크린에 50x50 픽셀 크기의 셀로 이루어진 격자판에서 진행됩니다. 또한, 격자판에는 총 15개의 지뢰가 무작위로 배치됩니다.

 

게임 플레이

 

게임 플레이는 다음과 같이 이루어집니다:

플레이어는 마우스 좌클릭을 사용하여 타일을 엽니다. 지뢰가 있는 타일을 열면 게임이 끝나고 '실패'라는 메시지가 표시됩니다.

플레이어는 마우스 우클릭을 사용하여 지뢰를 표시합니다. 모든 지뢰를 정확하게 표시하면 게임이 끝나고 '성공'이라는 메시지가 표시됩니다.

지뢰가 없는 타일을 열면, 해당 타일 주변의 8개 타일에 있는 지뢰의 수가 표시됩니다. 주변에 지뢰가 없는 경우, 주변의 모든 타일이 자동으로 열립니다.

게임이 끝나면, 화면 중앙에 '성공' 또는 '실패' 메시지가 표시됩니다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
import pygame 
import random
 
pygame.init() 
 
BLACK = (000)
RED = (25500)
GRAY = (128128128)
WHITE = (255255255)
YELLOW = (2552550)
large_font = pygame.font.SysFont(None72)
small_font = pygame.font.SysFont(None36)
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
 
CELL_SIZE = 50
COLUMN_COUNT = SCREEN_WIDTH // CELL_SIZE
ROW_COUNT = SCREEN_HEIGHT // CELL_SIZE
 
grid = [[{'mine'False'open'False'mine_count_around'0'flag'Falsefor _ in range(COLUMN_COUNT)] for _ in range(ROW_COUNT)]
MINE_COUNT = 15
for _ in range(MINE_COUNT):
    while True:
        column_index = random.randint(0, COLUMN_COUNT - 1)
        row_index = random.randint(0, ROW_COUNT - 1)
        tile = grid[row_index][column_index]
        if not tile['mine']:
            tile['mine'= True 
            break
 
clock = pygame.time.Clock() 
 
def in_bound(column_index, row_index):
    if (0 <= column_index < COLUMN_COUNT and 0 <= row_index < ROW_COUNT):
        return True
    else:
        return False
 
def open_tile(column_index, row_index): 
    if not in_bound(column_index, row_index):
        return
 
    tile = grid[row_index][column_index]
    if not tile['open']:
        tile['open'= True
    else:    
        return
 
    if tile['mine']:
        return
 
    mine_count_around = get_mine_count_around(column_index, row_index)
    if mine_count_around > 0:
        tile['mine_count_around'= mine_count_around
    else:
        for dc, dr in [(01), (0-1), (10), (-10), (11), (1-1), (-11), (-1-1)]:
            column_index_around, row_index_around = (column_index + dc, row_index + dr)
            open_tile(column_index_around, row_index_around)
 
def get_mine_count_around(column_index, row_index):
    count = 0
 
    for dc, dr in [(01), (0-1), (10), (-10), (11), (1-1), (-11), (-1-1)]:
        column_index_around, row_index_around = (column_index + dc, row_index + dr)
        if in_bound(column_index_around, row_index_around) and grid[row_index_around][column_index_around]['mine']:
            count += 1
    return count
 
def runGame():
    SUCCESS = 1
    FAILURE = 2
    game_over = 0
 
    while True
        clock.tick(30
        screen.fill(BLACK) 
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                break
            elif event.type == pygame.MOUSEBUTTONDOWN:
                column_index = event.pos[0// CELL_SIZE
                row_index = event.pos[1// CELL_SIZE
                if event.button == 1:
                    if in_bound(column_index, row_index):
                        tile = grid[row_index][column_index]
                        if tile['mine']:
                            tile['open'= True
                            game_over = FAILURE
                        else:
                            open_tile(column_index, row_index)
                elif event.button == 3:
                    if in_bound(column_index, row_index):
                        tile = grid[row_index][column_index]
                        if not tile['flag']:
                            tile['flag'= True
                        else:
                            tile['flag'= False
 
                        success = True
                        for row_index in range(ROW_COUNT):
                            for column_index in range(COLUMN_COUNT):
                                tile = grid[row_index][column_index]
                                if tile['mine'and not tile['flag']:
                                    success = False
                                    break
                        if success:
                            game_over = SUCCESS
 
        for column_index in range(COLUMN_COUNT):
            for row_index in range(ROW_COUNT):
                tile = grid[row_index][column_index]
                if tile['mine_count_around']:
                    mine_count_around_image = small_font.render('{}'.format(tile['mine_count_around']), True, YELLOW)
                    screen.blit(mine_count_around_image, mine_count_around_image.get_rect(centerx=column_index * CELL_SIZE + CELL_SIZE // 2, centery=row_index * CELL_SIZE + CELL_SIZE // 2))
                if tile['mine']: 
                    mine_image = small_font.render('x'True, RED)
                    screen.blit(mine_image, mine_image.get_rect(centerx=column_index * CELL_SIZE + CELL_SIZE // 2, centery=row_index * CELL_SIZE + CELL_SIZE // 2)) #지뢰 설치
                if not tile['open']:
                    pygame.draw.rect(screen, GRAY, pygame.Rect(column_index * CELL_SIZE, row_index * CELL_SIZE, CELL_SIZE, CELL_SIZE)) #커버
                if tile['flag']: 
                    v_image = small_font.render('v'True, WHITE)
                    screen.blit(v_image, (column_index * CELL_SIZE + 10, row_index * CELL_SIZE + 10)) 
                pygame.draw.rect(screen, WHITE, pygame.Rect(column_index * CELL_SIZE, row_index * CELL_SIZE, CELL_SIZE, CELL_SIZE), 1)
 
        if game_over > 0:
            if game_over == SUCCESS:
                success_image = large_font.render('Success'True, RED)
                screen.blit(success_image, success_image.get_rect(centerx=SCREEN_WIDTH // 2, centery=SCREEN_HEIGHT // 2))
            elif game_over == FAILURE:
                failure_image = large_font.render('Failure'True, RED)
                screen.blit(failure_image, failure_image.get_rect(centerx=SCREEN_WIDTH // 2, centery=SCREEN_HEIGHT // 2))
 
        pygame.display.update() 
 
runGame()
pygame.quit() 
cs

 

이 게임은 간단하지만, 지뢰의 위치를 추측하고, 지뢰가 없는 영역을 찾아내는 논리적인 생각이 필요합니다. 마인스위퍼는 전략적인 생각과 행동을 요구하는 재미있는 게임입니다.