В предыдущих частях мы рассмотрели создание консольной и GUI-версии "Сапёра" на Python, теперь пришло время совершить скачок, перенести классическую игру в трехмерное пространство с использованием графических технологий и популярный библиотек (буду стараться подробно описать комментариями в коде, если не понятно, то напишите в коммментариях, чтобы обновил статью и сделал её более подробной)
Раздел 1: Подготовка и настройка проекта, также размышления по проекту
1.1 Размышления: Почему все же 3D, а не улучшение 2D или новые идеи
Изначально я воспринимал разработку игры как учебный проект, который вряд ли кто-то увидит. Однако, получив первую обратную связь, осознал ценность создания чего-то уникального в сообществе
Анализируя существующие проекты на Хабре, я заметил интересный парадокс: при обилии 3D-игр различных жанров, классический "Сапёр" в трёхмерном исполнении практически отсутствует. При этом с технической точки зрения переход от 2D к 3D не настолько сложен, как может показаться, во многом это логичное развитие после освоения Tkinter и 2D-графики, поэтому после освоения текстового интерфейса и двумерной графики, следующим шагом становится создание полноценной 3D-игры. Вот что принципиально нового нас ждет:
Иммерсивный геймплей («Immersive‑gameplay») - вместо плоского поля вы получите объёмное пространство, где каждая клетка становится реальным 3D‑объектом
Свобода камеры - возможность осматривать поле под любым углом, приближать и отдалять
Тактильное управление - плавное перемещение курсора в трех измерениях вместо дискретных прыжков по клеткам
Визуальная глубина - реалистичное освещение, тени, объёмные мины и флаги создают эффект присутствия
Если вы уже знакомы с основами Python и хотите погрузиться в мир 3D-графики и игровой разработки или просто поиграть в объёмного сапёра - этот проект станет идеальной отправной точкой для вас.
1.2 Прорыв: от Tkinter к OpenGL
В отличие от предыдущих версий, где мы использовали Tkinter для создания интерфейса, здесь мы задействуем всю мощь и красоту всех базовых инструментов:
PyGame- для создания игрового окна и обработки вводаOpenGL- для высокопроизводительного 3D-рендеринга
1.3 Архитектура проекта
Проект разделен на логические модули, которые будут представлены во втором разделе:
main.pyточка входа и координацияmenu.pyсистема меню и настроекgame.pyигровая логика и управлениеrenderer.py3D-рендеринг и графика
1.4 На какую аудиторию этот проект
Начинающим разработчикам: отличный способ познакомиться с 3D-графикой на практике
Опытным программистам: интересный вызов и возможность оптимизации
Всем любителям игр или просто любителям изменять код: шанс создать свою собственную 3D-версию классики
1.5 Подготовка: что нам нужно для запуска и работы с проектом
Для работы потребуются библиотеки Python, и поэтому перед тем, как приступить к написанию, убедитесь, что у вас установлен Python (версия 3.10 или выше), если нет, то вы можете скачать её с официального сайта python.org. После скачивания python, нужно установить библиотеки:
pip install pygame PyOpenGL PyOpenGL_accelerateДля следующего шага нам понадобятся знания Python и библиотеки
Раздел 2: Главная часть - код программы и его описание
2.1 main.py - Главный файл приложения
import pygame
from game import Minesweeper3D
from menu import GameMenu
def main():
pygame.init()
# Создаем окно меню
menu_screen = pygame.display.set_mode((1280, 1024))
pygame.display.set_caption("3D-Minesweeper - Menu")
# Создаем меню
menu = GameMenu(menu_screen)
game_settings = menu.run()
if game_settings: # Если пользователь начал игру
# Закрываем меню и создаем игровое окно
pygame.quit()
# Перезапускаем pygame для игрового окна
pygame.init()
# Создаем и запускаем игру с выбранными настройками
game = Minesweeper3D(game_settings)
game.run()
if __name__ == "__main__":
main()Назначение файла - нужен для правильной работы между меню и игрой, можно сказать управление жизненным циклом приложения
2.2 menu.py - Система меню
Класс меню реализует базовый функционал для настройки игры, где ключевые методы включают инициализацию параметров в init, главный цикл обработки событий в run, обработку кликов мыши через handle_mouse_down, обновление значений слайдеров в update_slider_values, а также отрисовку интерфейса с помощью группы методов draw_interface, draw_slider, draw_lighting_toggle и draw_start_button.
Интерфейс меню был реализован как минимально рабочий вариант - здесь открывается широкий простор для творчества: можно добавить анимированные переходы, дополнительные настройки графики, систему профилей или даже мини-превью геймплея на фоне и т.д.
2.2.1 Конструктор класса GameMenu - инициализация всех параметров
import pygame
class GameMenu:
def __init__(self, screen):
self.screen = screen
self.width, self.height = screen.get_size()
# Шрифты - подбираем на глаз
self.big_font = pygame.font.SysFont('Times New Roman', 50)
self.normal_font = pygame.font.SysFont('Times New Roman', 35)
# Настройки по умолчанию - стандартные значения
self.grid_size = 10 # Размер поля
self.mine_count = 15 # Мины для начала
self.lighting_on = True # Освещение включено
# Вычисляем позиции относительно размера экрана
self.middle_x = self.width // 2 # Центр экрана
# Высоты элементов отступаем от верха пропорционально
self.title_y = self.height // 8 # Заголовок в верхней части
self.first_slider_y = self.height // 4 # Первый слайдер чуть ниже
self.slider_spacing = self.height // 10 # Расстояние между слайдерами
self.toggle_y = self.first_slider_y + self.slider_spacing * 2 # Переключатель после двух слайдеров
self.button_y = self.toggle_y + self.slider_spacing # Кнопка внизу
# Ширины элементов пропорционально ширине экрана
self.slider_length = self.width // 4 # Слайдер занимает четверть экрана
self.btn_width = self.width // 5 # Кнопка поменьше
self.btn_height = 50 # Высота кнопки стандартная
# Для удобства - отступ слайдера от центра
self.slider_offset_x = self.width // 9
# Состояния перетаскивания
self.grid_dragging = False
self.mines_dragging = False
# Флаг работы меню
self.running = TrueПояснение к работе: Класс принимает объект экрана ("screen") PyGame и автоматически определяет его размеры для адаптивного позиционирования
screen.get_size()- Метод PyGame, возвращающий (width, height) с размерами окнаpygame.font.SysFont('Times New Roman', 50)- Создание объекта шрифта:Первый параметр - название шрифта ( можно менять на любой другой стандартный или установить свой акцидентный шрифт)
Второй параметр - размер в пикселях
Пропорциональное позиционирование:
self.height // 8- заголовок занимает 1/8 высоты от верхаself.width // 4- слайдер занимает 1/4 ширины экрана
Состояния перетаскивания - флаги для отслеживания, какой слайдер сейчас перетаскивается
self.mines_dragging = False- слайдер минself.grid_dragging = False- слайдер размера
2.2.2 Метод run() - главный игровой цикл меню
def run(self):
"""Главный цикл открыт пока пользователь не выберет настройки"""
while self.running:
# Текущая позиция мыши для обработки hover эффектов
# P.S. hover-эффект — это изменение вида элемента, когда пользователь наводит на него курсор мыши
mouse_pos = pygame.mouse.get_pos()
# Разбираем все события которые накопились
for event in pygame.event.get():
if event.type == pygame.QUIT:
return None # Выход из игры если закрыли окно
# Нажатие кнопки мыши - возможно начало перетаскивания или клик
if event.type == pygame.MOUSEBUTTONDOWN:
self.handle_mouse_down(mouse_pos)
# Отпустили кнопку - заканчиваем перетаскивание
if event.type == pygame.MOUSEBUTTONUP:
self.grid_dragging = False
self.mines_dragging = False
# Клавиша ESC - выход в меню
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
return None
# Если тащим слайдер - обновляем его значение
if self.grid_dragging or self.mines_dragging:
self.update_slider_values(mouse_pos)
# Рисуем все элементы интерфейса
self.draw_interface()
pygame.display.flip()
# Не грузим процессор - ждем немного
pygame.time.delay(30)
# Возвращаем настройки когда пользователь нажал "Начать игру"
return self.get_settings()Пояснения ключевых команд и моментов:
pygame.mouse.get_pos()- возвращает текущие координаты (x, y) курсора мышиpygame.event.get()- получает список всех событий, произошедших с последнего вызоваevent.type- тип события (QUIT, MOUSEBUTTONDOWN, KEYDOWN и т.д.)pygame.display.flip()- обновляет весь экран
2.2.3 Метод handle_mouse_down() - обработка нажатий мыши
def handle_mouse_down(self, mouse_pos):
"""Обрабатываем клик мыши проверяем куда попали"""
x, y = mouse_pos
# Позиция начала слайдера (левый край)
slider_start_x = self.middle_x - self.slider_offset_x
# Вычисляем где должна быть ручка слайдера размера сетки
grid_handle_x = slider_start_x + (self.grid_size - 5) * (self.slider_length / 15)
# Область ручки - немного расширяем для удобства клика
handle_left = grid_handle_x - 15
handle_right = grid_handle_x + 15
handle_top = self.first_slider_y - 5
handle_bottom = self.first_slider_y + 25
# Проверяем попали ли в ручку слайдера размера сетки
if (handle_left < x < handle_right and handle_top < y < handle_bottom):
self.grid_dragging = True
# Аналогично для слайдера количества мин (он ниже)
mines_handle_x = slider_start_x + (self.mine_count - 5) * (self.slider_length / 95)
mines_handle_top = self.first_slider_y + self.slider_spacing - 5
mines_handle_bottom = mines_handle_top + 30
if (mines_handle_x - 15 < x < mines_handle_x + 15 and
mines_handle_top < y < mines_handle_bottom):
self.mines_dragging = True
# Проверяем клик по переключателю освещения
toggle_rect = pygame.Rect(self.middle_x - 70, self.toggle_y, 140, 40)
if toggle_rect.collidepoint(mouse_pos):
self.lighting_on = not self.lighting_on # Переключаем состояние
# Проверяем клик по кнопке "Начать игру"
start_rect = pygame.Rect(self.middle_x - self.btn_width // 2, self.button_y,
self.btn_width, self.btn_height)
if start_rect.collidepoint(mouse_pos):
self.running = False # Заканчиваем работу менюСлайдеры и обнаружение кликов:
Вычисление позиции ручки:
(self.grid_size - 5)- нормализация (т.к. диапазон 5-20 → 0-15)(self.slider_length / 15)- масштабирование на длину слайдера
pygame.Rect()- создает прямоугольник для проверки столкновенийcollidepoint()- проверяет, находится ли точка внутри прямоугольника
2.2.4 Метод update_slider_values() - обновление значений при перетаскивании
def update_slider_values(self, mouse_pos):
"""Обновляем значения когда тащим слайдер"""
x, y = mouse_pos
slider_start_x = self.middle_x - self.slider_offset_x
# Обновляем размер сетки если тащим первый слайдер
if self.grid_dragging:
# Вычисляем относительное положение мыши на слайдере
relative_x = x - slider_start_x
# Ограничиваем в пределах слайдера
relative_x = max(0, min(relative_x, self.slider_length))
# Пересчитываем в значение от 5 до 20
self.grid_size = 5 + int(relative_x / self.slider_length * 15)
# Аналогично для количества мин
if self.mines_dragging:
relative_x = x - slider_start_x
relative_x = max(0, min(relative_x, self.slider_length))
self.mine_count = 5 + int(relative_x / self.slider_length * 95)
# Защита от дурака - не может быть мин больше чем клеток (минус 9 для безопасной зоны)
max_possible_mines = self.grid_size * self.grid_size - 9
if self.mine_count > max_possible_mines:
self.mine_count = max_possible_mines
Алгоритм преобразования координат в значения:
relative_x = x - slider_start_x- смещение от начала слайдераmax(0, min(relative_x, self.slider_length))- ограничение в границах слайдераФормула нормализации:
(relative_x / slider_length) * range + min_value
Защита от некорректных значений:
grid_size * grid_size - 9- максимальное количество мин (минус безопасная зона 3x3, чтобы мин не было больше, чем клеток, также автоматическая коррекция при превышении лимита)
2.2.6 Метод draw_interface() - основная отрисовка интерфейса
def draw_interface(self):
"""Рисуем весь интерфейс меню"""
# Заливаем фон темно-синим цветом
self.screen.fill((40, 40, 80))
# Заголовок игры по центру сверху
title = self.big_font.render("Сапер 3D", True, (255, 255, 200))
title_rect = title.get_rect(center=(self.middle_x, self.title_y))
self.screen.blit(title, title_rect)
# Рисуем два слайдера - для размера поля и количества мин
self.draw_slider("Размер поля:", self.grid_size, self.first_slider_y,
f"{self.grid_size}×{self.grid_size}")
self.draw_slider("Количество мин:", self.mine_count,
self.first_slider_y + self.slider_spacing, str(self.mine_count))
# Переключатель освещения
self.draw_lighting_toggle()
# Кнопка начала игры
self.draw_start_button()Ключевые команды PyGame:
self.screen.fill((40, 40, 80))- заливка фона цветом RGB(40,40,80) - (тёмно-синий цвет с фиолетовым оттенком) , можно менять или например вставить фотографиюfont.render(text, antialias, color)- создание поверхности с текстом:antialias=True- сглаживание краев текста
surface.get_rect(center=(x, y))- получение прямоугольника с центром в указанной позицииself.screen.blit(source, dest)- отрисовка поверхности на экран:source- что рисуемdest- куда рисуем (координаты)
2.2.7 Метод draw_slider() - отрисовка отдельного слайдера
def draw_slider(self, label, value, y_pos, value_text):
"""Рисуем один слайдер с меткой и значением"""
# Начало слайдера (левый край)
slider_start_x = self.middle_x - self.slider_offset_x
# Метка слева от слайдера
label_surface = self.normal_font.render(label, True, (255, 255, 255))
# Размещаем метку слева от слайдера с выравниванием по базовой линии
self.screen.blit(label_surface, (slider_start_x - label_surface.get_width() - 20, y_pos))
# Значение справа от слайдера
value_surface = self.normal_font.render(value_text, True, (255, 255, 200))
self.screen.blit(value_surface, (slider_start_x + self.slider_length + 10, y_pos))
# Фоновая полоса слайдера
pygame.draw.rect(self.screen, (80, 80, 120),
(slider_start_x, y_pos + 15, self.slider_length, 8))
# Заполненная часть - показывает текущее значение
if value > 5:
# Вычисляем ширину заполненной части в зависимости от типа слайдера
if "Размер" in label:
fill_width = (value - 5) * (self.slider_length / 15)
else:
fill_width = (value - 5) * (self.slider_length / 95)
pygame.draw.rect(self.screen, (0, 120, 220),
(slider_start_x, y_pos + 15, fill_width, 8))
# Ручка слайдера - кружок по текущей позиции
if "Размер" in label:
handle_x = slider_start_x + (value - 5) * (self.slider_length / 15)
else:
handle_x = slider_start_x + (value - 5) * (self.slider_length / 95)
pygame.draw.circle(self.screen, (255, 255, 255), (int(handle_x), y_pos + 19), 12)
Примитивы PyGame:
pygame.draw.rect(surface, color, rect, width=0)рисование прямоугольника:width=0- заливка,width>0- контур толщиной width
pygame.draw.circle(surface, color, center, radius)рисование кругаfont.render()создает изображение текста с бежевым цветом (255,255,200) и сглаживаниемscreen.blit()рисует это изображение с отступом 10 пикселей справа от слайдера, показывая текущее числовое значение настроек
2.2.8 Метод draw_lighting_toggle() - переключатель освещения
def draw_lighting_toggle(self):
"""Рисуем переключатель освещения"""
# Позиция переключателя - по центру
toggle_x = self.middle_x - 70
toggle_y = self.toggle_y
# Метка слева
label = self.normal_font.render("Освещение:", True, (255, 255, 255))
self.screen.blit(label, (toggle_x - label.get_width() - 30, toggle_y))
# Сам переключатель - зеленный если включено, красный если выключено
toggle_color = (50, 200, 50) if self.lighting_on else (200, 50, 50)
pygame.draw.rect(self.screen, toggle_color,
(toggle_x, toggle_y, 140, 40), border_radius=20)
# Текст на переключателе
state_text = "ВКЛ" if self.lighting_on else "ВЫКЛ"
text_surface = self.normal_font.render(state_text, True, (255, 255, 255))
text_rect = text_surface.get_rect(center=(toggle_x + 70, toggle_y + 20))
self.screen.blit(text_surface, text_rect)Примичание:
Условное изменение цвета в зависимости от состояния (зеленный если включено, красный, если выключено)
2.2.9 Метод draw_start_button() - кнопка начала игры
def draw_start_button(self):
"""Рисуем кнопку начала игры"""
# Позиция кнопки - по центру внизу
btn_x = self.middle_x - self.btn_width // 2
btn_y = self.button_y
# Цвет кнопки - зеленый
button_color = (30, 150, 30)
# Рисуем саму кнопку со скругленными углами
pygame.draw.rect(self.screen, button_color,
(btn_x, btn_y, self.btn_width, self.btn_height), border_radius=10)
# Обводка кнопки
pygame.draw.rect(self.screen, (200, 200, 200),
(btn_x, btn_y, self.btn_width, self.btn_height), 2, border_radius=10)
# Текст на кнопке
text_surface = self.normal_font.render("Начать игру", True, (255, 255, 255))
text_rect = text_surface.get_rect(center=(btn_x + self.btn_width // 2, btn_y + self.btn_height // 2))
self.screen.blit(text_surface, text_rect)2.2.10 Метод get_settings() - возврат настроек
def get_settings(self):
"""Возвращаем выбранные пользователем настройки"""
return {
'grid_size': self.grid_size,
'mine_count': self.mine_count,
'lighting_enabled': self.lighting_on
}Простота: Метод возвращает словарь с четко именованными ключами, готовый к использованию в основном классе игры.
2.3 game.py - Основная игровая логика
Класс Minesweeper3D представляет собой ядро игровой логики, где каждый метод выполняет четко определенную роль: от инициализации игрового окружения в init и сброса состояния в init_game до стратегического размещения мин с безопасной зоной через place_mines, интерактивного вскрытия клеток с рекурсивной логикой в reveal_cell, проверки условий победы в check_win, обработки непрерывного пользовательского ввода в handle_input, управления главным игровым циклом в run и визуализации интерфейса в draw_interface
Возможно при модификации рекурсивного метода reveal_cell следует быть осторожным с глубиной рекурсии на больших полях, а также учитывать взаимосвязь между handle_input и главным циклом run эти изменения в одном моменте могут потребовать корректировки в другом
2.3.1 Метод init(self, settings) - инициализация игры
import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import random
from renderer import Renderer
class Minesweeper3D:
def __init__(self, settings):
"""
Инициализация игры с настройками и создание игрового окружения
Args:
settings: Словарь настроек игры (размер поля, количество мин и т.д.)
"""
self.settings = settings
self.grid_size = settings['grid_size']
self.mine_count = settings['mine_count']
self.last_arrow_time = 0
self.width, self.height = (1280, 1024)
# Создаем OpenGL окно с указанными параметрами
pygame.display.set_mode((self.width, self.height), DOUBLEBUF | OPENGL)
pygame.display.set_caption("3D Minesweeper - Use WASD, Arrows, Q/E, Space, F, R")
# Инициализация рендерера для 3D-графики
self.renderer = Renderer(self.width, self.height, self.grid_sizeself.settings['lighting_enabled'])
# Первоначальная настройка игрового состояния
self.init_game()
Пояснение ключевых моментов:
DOUBLEBUF | OPENGL- флаги для создания окна с двойной буферизацией и OpenGL контекстом (Окно с двойной буферизацией создаётся для устранения мерцания и для плавности изображения)Renderer()- создание объекта рендерера, который будет заниматься всей 3D-графикой
2.3.2 Метод init_game(self) - сброс игрового состояния
def init_game(self):
"""
Инициализация или сброс игрового состояния к начальным значениям
Создает чистую сетку, сбрасывает позицию курсора, таймеры и флаги состояния игры
"""
# Создаем сетку клеток с начальными значениями
self.grid = [[{'mine': False, 'revealed': False, 'flagged': False, 'adjacent': 0}
for _ in range(self.grid_size)] for _ in range(self.grid_size)]
# Позиция курсора (начинаем в центре поля)
self.cursor_pos = [self.grid_size // 2, self.grid_size // 2]
# Состояние игры
self.game_over = False # Флаг завершения игры
self.win = False # Флаг победы
self.first_click = True # Флаг первого хода (для безопасного старта)
self.start_time = pygame.time.get_ticks() # Время начала игры
self.elapsed_time = 0 # Прошедшее время игры
# Словарь для отслеживания состояния клавиш управления
self.keys_pressed = {
pygame.K_w: False, pygame.K_s: False, pygame.K_a: False, pygame.K_d: False,
pygame.K_q: False, pygame.K_e: False, pygame.K_UP: False, pygame.K_DOWN: False,
pygame.K_LEFT: False, pygame.K_RIGHT: False, pygame.K_ESCAPE: False
}Структура данных клетки:
mineесть ли мина в клеткеrevealedоткрыта ли клеткаflaggedпомечена ли флагомadjacentколичество мин в соседних клетках
2.3.3 Метод place_mines(self, safe_x, safe_y) - размещение мин
def place_mines(self, safe_x, safe_y):
"""
Размещение мин на поле с гарантией безопасной зоны вокруг первого клика
Args:
safe_x, safe_y: Координаты безопасной клетки (первый клик)
"""
mines_placed = 0
safe_cells = set()
# Создаем безопасную зону вокруг первого клика
for dx in [-1, 0, 1]:
for dy in [-1, 0, 1]:
nx, ny = safe_x + dx, safe_y + dy
if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size:
safe_cells.add((nx, ny))
# Размещаем мины
while mines_placed < self.mine_count:
x, y = random.randint(0, self.grid_size - 1), random.randint(0, self.grid_size - 1)
if (x, y) not in safe_cells and not self.grid[y][x]['mine']:
self.grid[y][x]['mine'] = True
mines_placed += 1
# Обновляем счетчики соседних мин
for dx in [-1, 0, 1]:
for dy in [-1, 0, 1]:
if dx == 0 and dy == 0:
continue
nx, ny = x + dx, y + dy
if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size:
self.grid[ny][nx]['adjacent'] += 1Алгоритм безопасной зоны:
Создается зона 3x3 клетки вокруг первого клика, мины никогда не будут размещатся в этой зоне (понимаю, что немного не как в оригинале)
2.3.4 Метод reveal_cell(self, x, y) - вскрытие клетки
def reveal_cell(self, x, y):
"""Вскрытие клетки и рекурсивное вскрытие"""
if not (0 <= x < self.grid_size and 0 <= y < self.grid_size):
return
cell = self.grid[y][x]
if cell['revealed'] or cell['flagged']:
return
# Первый клик гарантируем безопасность
if self.first_click:
self.first_click = False
self.place_mines(x, y)
cell['revealed'] = True
# Проверка на мину
if cell['mine']:
self.game_over = True
# Показываем все мины при проигрыше
for row in self.grid:
for cell_data in row:
if cell_data['mine']:
cell_data['revealed'] = True
return
# Рекурсивное вскрытие пустых клеток
if cell['adjacent'] == 0:
for dx in [-1, 0, 1]:
for dy in [-1, 0, 1]:
if dx != 0 or dy != 0:
self.reveal_cell(x + dx, y + dy)Рекурсивный алгоритм:
Если клетка пустая (0 мин вокруг), автоматически открываются все соседи, процесс продолжается, пока не встретятся клетки с числами
2.3.5 Метод check_win(self) - проверка победы
def check_win(self):
"""Проверка условия победы"""
for y in range(self.grid_size):
for x in range(self.grid_size):
cell = self.grid[y][x]
if not cell['mine'] and not cell['revealed']:
return False
self.win = True
return TrueЛогика победы: Игрок побеждает, когда все безопасные клетки открыты (можно добавить альтернативное условие победы например: все флаги расставлены правильно)
2.3.6 Метод handle_input(self) - обработка ввода
def handle_input(self):
"""Обработка ввода с клавиатуры"""
current_time = pygame.time.get_ticks()
# Управление камерой
speed = 2.0
if self.keys_pressed[pygame.K_w]:
self.renderer.camera_rotation_x = (self.renderer.camera_rotation_x - speed) % 360
if self.keys_pressed[pygame.K_s]:
self.renderer.camera_rotation_x = (self.renderer.camera_rotation_x + speed) % 360
if self.keys_pressed[pygame.K_a]:
self.renderer.camera_rotation_y = (self.renderer.camera_rotation_y - speed) % 360
if self.keys_pressed[pygame.K_d]:
self.renderer.camera_rotation_y = (self.renderer.camera_rotation_y + speed) % 360
# Приближение/отдаление
if self.keys_pressed[pygame.K_q]:
self.renderer.camera_distance = min(-5, self.renderer.camera_distance + speed * 0.5)
if self.keys_pressed[pygame.K_e]:
self.renderer.camera_distance = max(-40, self.renderer.camera_distance - speed * 0.5)
# Управление курсором
if self.keys_pressed[pygame.K_UP] and current_time - self.last_arrow_time > 150:
self.cursor_pos[1] = min(self.grid_size - 1, self.cursor_pos[1] + 1)
self.last_arrow_time = current_time
if self.keys_pressed[pygame.K_DOWN] and current_time - self.last_arrow_time > 150:
self.cursor_pos[1] = max(0, self.cursor_pos[1] - 1)
self.last_arrow_time = current_time
if self.keys_pressed[pygame.K_LEFT] and current_time - self.last_arrow_time > 150:
self.cursor_pos[0] = max(0, self.cursor_pos[0] - 1)
self.last_arrow_time = current_time
if self.keys_pressed[pygame.K_RIGHT] and current_time - self.last_arrow_time > 150:
self.cursor_pos[0] = min(self.grid_size - 1, self.cursor_pos[0] + 1)
self.last_arrow_time = current_timeСистема задержки для курсора:
current_time - self.last_arrow_time > 150- задержка 150 мс между перемещениями (предотвращает быстрое движение курсора)
2.3.7 Метод run(self) - главный игровой цикл
def run(self):
"""Главный игровой цикл"""
clock = pygame.time.Clock()
running = True
while running:
# Обновление времени
current_time = pygame.time.get_ticks()
if not self.game_over and not self.win:
self.elapsed_time = (current_time - self.start_time) // 1000
# Обработка событий
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key in self.keys_pressed:
self.keys_pressed[event.key] = True
# Выход в меню по ESC
if event.key == pygame.K_ESCAPE:
running = False
# Перезапуск игры
if (self.game_over or self.win) and event.key == pygame.K_r:
self.init_game()
continue
# Игровые действия
if not self.game_over and not self.win:
if event.key == pygame.K_SPACE:
x, y = self.cursor_pos
self.reveal_cell(x, y)
if not self.game_over and not self.first_click:
self.check_win()
elif event.key == pygame.K_f:
x, y = self.cursor_pos
if not self.grid[y][x]['revealed']:
self.grid[y][x]['flagged'] = not self.grid[y][x]['flagged']
elif event.type == pygame.KEYUP:
if event.key in self.keys_pressed:
self.keys_pressed[event.key] = False
# Обработка непрерывного ввода
self.handle_input()
# Очистка экрана
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# Обновление камеры
self.renderer.update_camera()
# Отрисовка игрового поля
self.renderer.draw_grid(self.grid, self.cursor_pos, self.grid_size)
# Отображение интерфейса
self.draw_interface()
# Обновление дисплея
pygame.display.flip()
clock.tick(60)Команды OpenGL:
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)- очистка буферов цвета и глубиныpygame.display.flip()- обмен буферов (двойная буферизация)
2.3.8 Метод draw_interface(self) - интерфейс поверх игры
def draw_interface(self):
"""Отрисовка интерфейса поверх игры"""
# Статус игры
if self.game_over:
self.renderer.draw_text("GAME OVER! Press R to restart", self.width // 1.5, self.height // 2, background=True)
elif self.win:
self.renderer.draw_text("YOU WIN! Press R to restart", self.width // 1.5, self.height // 2, background=True)
# Время и мины
time_text = f"Time: {self.elapsed_time}s"
mines_text = f"Mines: {self.mine_count}"
grid_text = f"Grid: {self.grid_size}x{self.grid_size}"
# Вычисляем относительные отступы от краев экрана
margin_x = self.width * 0.05 # 5% от ширины экрана
margin_y = self.height * 0.2 # 5% от высоты экрана
text_spacing = 40 + self.width * 0.05 # Фиксированный интервал между строками
# Левая колонка
self.renderer.draw_text(time_text, margin_x, margin_y, background=True)
self.renderer.draw_text(mines_text, margin_x, margin_y + text_spacing, background=True)
# Правая колонка - отступаем от правого края
right_margin_x = self.width - 200 # Фиксированная ширина текста или можно сделать относительной
self.renderer.draw_text(grid_text, right_margin_x, margin_y, background=True)
# Подсказки управления (нижний левый угол)
controls_text = "WASD: Camera Q/E: Zoom Arrows: Move Space: Reveal F: Flag"
self.renderer.draw_text(controls_text, margin_x, self.height - margin_y, background=True)
# Клавиши управления (нижний правый угол)
control_keys = "R: Restart ESC: Menu"
right_controls_x = self.width - 200
self.renderer.draw_text(control_keys, right_controls_x, self.height - margin_y, background=True)
2.4 renderer.py - система рендеринга
Рендерер игры представляет собой мощный инструмент для визуализации 3D-пространства, где каждый метод отвечает за ключевые аспекты отображения: инициализация OpenGL в init, настройка атмосферного освещения через setup_lighting, динамическое управление камерой в update_camera, отрисовка базовых элементов вроде кубов draw_cube и сложных объектов вроде мин с шипами в draw_mine, построение сетки поля draw_grid, а также гибкая система текстовой визуализации - от простого 2D-текста draw_text до объёмных 3D-чисел draw_number и специальных маркеров вроде флагов draw_flag.
Могу сказать, что удалось разделить по максимуму методы между собой, что даёт большую свободу для модификаций и добавления новых визуальных эффектов будущими разработчикам (то есть вам)
2.4.1 Метод init(self, width, height, grid_size, lighting_enabled) - инициализация
from OpenGL.GL import *
from OpenGL.GLU import *
import pygame
class Renderer:
def __init__(self, width, height, grid_size, lighting_enabled=True):
"""
Инициализация рендерера для визуализации игрового поля
Args:
width: Ширина окна отображения
height: Высота окна отображения
grid_size: Размер игрового поля (количество клеток)
lighting_enabled: Флаг включения освещения (по умолчанию True)
"""
self.width = width
self.height = height
self.grid_size = grid_size
self.cell_size = 2 # Размер одной клетки
self.depth = 0.7 # Глубина клеток
# Создание квадриков (мины и шипы)
self.mine_quadric = gluNewQuadric()
self.spike_quadric = gluNewQuadric()
# Параметры камеры
self.camera_distance = -30 # Дистанция камеры от центра сцены
self.camera_rotation_x = 30 # Угол поворота по оси X (наклон)
self.camera_rotation_y = -45 # Угол поворота по оси Y (вращение)
# Настройка OpenGL
gluPerspective(60, (width / height), 0.1, 75.0) # Перспективная проекция
glTranslatef(0.0, 0.0, self.camera_distance) # Позиционирование камеры
glRotatef(self.camera_rotation_x, 1, 0, 0) # Поворот по оси X
glRotatef(self.camera_rotation_y, 0, 1, 0) # Поворот по оси Y
glEnable(GL_DEPTH_TEST) # Включение теста глубины
glEnable(GL_COLOR_MATERIAL) # Включение цветовых материалов
# Настройка освещения если включено
if lighting_enabled:
self.setup_lighting()
# Инициализация шрифта для текстовых надписей
pygame.font.init()
self.font = pygame.font.SysFont('Times New Roman', 24)2.4.2 Метод setup_lighting(self) - настройка освещения
def setup_lighting(self):
"""
Создает основное и дополнительное освещение
"""
glEnable(GL_LIGHTING) # Включение системы освещения
glEnable(GL_LIGHT0) # Активация первого источника света
glEnable(GL_LIGHT1) # Активация второго источника света
# Расчет половины размера игрового поля для позиционирования света
field_half_size = (self.grid_size * self.cell_size) / 2
# Настройка первого источника света (верхний-правый)
glLightfv(GL_LIGHT0, GL_POSITION, (field_half_size, -field_half_size, 10, 1))
glLightfv(GL_LIGHT0, GL_DIFFUSE, (0.8, 0.8, 0.8, 1)) # Рассеянный свет
glLightfv(GL_LIGHT0, GL_AMBIENT, (0.2, 0.2, 0.2, 1)) # Фоновое освещение
# Настройка второго источника света (спереди-сверху)
glLightfv(GL_LIGHT1, GL_POSITION, (0, 0, 100, 1))
glLightfv(GL_LIGHT1, GL_DIFFUSE, (0.8, 0.8, 0.8, 1)) # Рассеянный свет
glLightfv(GL_LIGHT1, GL_AMBIENT, (0.2, 0.2, 0.2, 1)) # Фоновое освещениеПараметры источников света:
GL_POSITION- позиция света в формате (x, y, z, w)GL_DIFFUSE- цвет основное освещениеGL_AMBIENT- цвет фонового освещения
2.4.3 Метод update_camera(self) - обновление камеры
def update_camera(self):
"""
Обновление позиции и ориентации камеры в 3D-пространстве
"""
glLoadIdentity() # Сброс матрицы преобразований
gluPerspective(60, (self.width / self.height), 0.1, 75.0) # Установка перспективы
glTranslatef(0.0, 0.0, self.camera_distance) # Перемещение камеры
glRotatef(self.camera_rotation_x, 1, 0, 0) # Поворот по оси X (вертикальный наклон)
glRotatef(self.camera_rotation_y, 0, 1, 0) # Поворот по оси Y (горизонтальное вращение)2.4.4 Метод draw_cube(self, x, y, z, color) - отрисовка 3D-куба
def draw_cube(self, x, y, z, color):
"""
Метод создает и отрисовывает трехмерный куб:
Args:
x, y, z - координаты переднего верхнего угла куба в 3D-пространстве
color - цвет заливки граней куба
"""
vertices = [
[x, y, z], [x + self.cell_size, y, z], [x + self.cell_size, y + self.cell_size, z],
[x, y + self.cell_size, z], # Передняя грань (ближняя к наблюдателю)
[x, y, z - self.depth], [x + self.cell_size, y, z - self.depth],
[x + self.cell_size, y + self.cell_size, z - self.depth], [x, y + self.cell_size, z - self.depth]
# Задняя грань (дальняя от наблюдателя)
]
faces = [[0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 5, 4], [2, 3, 7, 6], [0, 3, 7, 4], [1, 2, 6, 5]]
glBegin(GL_QUADS)
glColor3fv(color)
for face in faces:
for vertex in face:
glVertex3fv(vertices[vertex])
glEnd()
glColor3f(1, 1, 1)
glBegin(GL_LINES)
edges = [(0, 1), (1, 2), (2, 3), (3, 0), (4, 5), (5, 6), (6, 7), (7, 4), (0, 4), (1, 5), (2, 6), (3, 7)]
for edge in edges:
for vertex in edge:
glVertex3fv(vertices[vertex])
glEnd()GL_QUADS- рисует четырехугольники (грани куба)GL_LINES- рисует линии (ребра куба)
2.4.5.Метод draw_grid(self, grid, cursor_pos, grid_size) - отрисовка поля
def draw_grid(self, grid, cursor_pos, grid_size):
"""
Отрисовка игрового поля с клетками, минами, флагами и курсором
Args:
grid: Двумерный массив клеток игрового поля
cursor_pos: Текущая позиция курсора (x, y)
grid_size: Размер игрового поля
"""
# Смещение для центрирования поля относительно начала координат
offset_x = -grid_size * self.cell_size / 2
offset_y = -grid_size * self.cell_size / 2
# Отрисовка всех клеток поля
for y in range(grid_size):
for x in range(grid_size):
cell_x = offset_x + x * self.cell_size
cell_y = offset_y + y * self.cell_size
cell = grid[y][x]
# Выбор цвета клетки в зависимости от состояния
if cell['revealed']:
color = (1, 0, 0) if cell['mine'] else (0.8, 0.8, 0.8) # Красный для мин, серый для пустых
else:
color = (0.4, 0.4, 0.8) # Синий для неоткрытых клеток
# Отрисовка базового куба клетки
self.draw_cube(cell_x, cell_y, 0, color)
# Отрисовка содержимого открытых клеток
if cell['revealed']:
if cell['mine']:
self.draw_mine(cell_x, cell_y) # Мина
elif cell['adjacent'] > 0:
self.draw_number(cell_x, cell_y, cell['adjacent']) # Число соседних мин
elif cell['flagged']:
self.draw_flag(cell_x, cell_y) # Флаг
# Отрисовка курсора (желтая рамка поверх клетки)
cursor_x = offset_x + cursor_pos[0] * self.cell_size
cursor_y = offset_y + cursor_pos[1] * self.cell_size
glColor3f(1, 1, 0) # Желтый цвет
glBegin(GL_LINE_LOOP)
glVertex3f(cursor_x, cursor_y, 0.1) # Лево-низ
glVertex3f(cursor_x + self.cell_size, cursor_y, 0.1) # Право-низ
glVertex3f(cursor_x + self.cell_size, cursor_y + self.cell_size, 0.1) # Право-верх
glVertex3f(cursor_x, cursor_y + self.cell_size, 0.1) # Лево-верх
glEnd()Цветовая схема клеток:
Неоткрытые: синий
(0.4, 0.4, 0.8)Открытые с миной: красный
(1, 0, 0)Открытые пустые: серый
(0.8, 0.8, 0.8)
2.4.6 Метод draw_text(self, text, x, y, background) - 2D-текст
def draw_text(self, text, x, y, background=False):
"""
Отрисовка 2D-текста
Args:
text: Текст для отображения
x, y: Координаты левого верхнего угла
background: Добавлять ли полупрозрачный фон
"""
# Сохраняем текущие матрицы и настройки
glMatrixMode(GL_PROJECTION)
glPushMatrix()
glLoadIdentity()
glOrtho(0, self.width, self.height, 0, -1, 1)
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glLoadIdentity()
# Отключаем глубину и освещение для 2D
glDisable(GL_DEPTH_TEST)
glDisable(GL_LIGHTING)
# Включаем blending для прозрачности
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
# Рендерим текст
text_surface = self.font.render(text, True, (0, 255, 0, 255))
text_width = text_surface.get_width()
text_height = text_surface.get_height()
try:
text_data = pygame.image.tostring(text_surface, "RGBA", True)
glRasterPos2f(x, y)
# Устанавливаем цвет текста (белый)
glColor4f(0 , 0, 0, 5)
glDrawPixels(text_width, text_height, GL_RGBA, GL_UNSIGNED_BYTE, text_data)
except Exception as e:
print(f"Error drawing text: {e}")
# Восстанавливаем настройки
glDisable(GL_BLEND)
glEnable(GL_LIGHTING)
glEnable(GL_DEPTH_TEST)
glPopMatrix()
glMatrixMode(GL_PROJECTION)
glPopMatrix()
glMatrixMode(GL_MODELVIEW)Переключение между 2D и 3D режимами:
Сохраняем текущие проекции и моделирования
Переключаемся в проекцию для 2D
Отключаем 3D-функции (глубину, освещение)
Включаем blending для прозрачности
Рисуем текст
Восстанавливаем предыдущие настройки
2.4.7 Метод draw_number(self, x, y, number) - отрисовка чисел на клетках
def draw_number(self, x, y, number):
"""
Рисование 3D-числа, показывающего количество мин вокруг
Args:
x, y: Координаты клетки
number: Число для отображения (1-8)
"""
if number == 0:
return # Не рисуем 0
# Цвета для разных чисел (как в классическом сапере)
colors = [
(0, 0, 255), # 1 - синий
(0, 255, 0), # 2 - зеленый
(255, 0, 0), # 3 - красный
(0, 0, 0.5), # 4 - темно-синий
(0.5, 0, 0), # 5 - темно-красный
(0, 0.5, 0.5), # 6 - бирюзовый
(0, 0, 0), # 7 - черный
(0.5, 0.5, 0.5) # 8 - серый
]
# Выбираем цвет в зависимости от числа
color = colors[number - 1] if number <= 8 else (1, 0, 1) # Фиолетовый для чисел >8
# Сохраняем текущую матрицу преобразований
glPushMatrix()
# Перемещаемся в центр клетки и немного выше поверхности
glTranslatef(x + self.cell_size / 2, y + self.cell_size / 2, 0.1)
# Масштабируем текст до нужного размера
glScalef(0.003, 0.003, 0.003) # Отрицательный масштаб по X исправляет зеркальность
# Центрируем текст (компенсируем отрицательное масштабирование)
text_width = len(str(number)) * 80 # Примерная ширина текста
glTranslatef(-text_width / 2, -150, 0) # Центрируем и опускаем немного вниз
glColor3fv(color)
# Рисуем число с помощью встроенных символов OpenGL
# (заменяем GLUT_STROKE_ROMAN на базовые примитивы)
self.draw_text_primitive(str(number))
# Восстанавливаем предыдущую матрицу
glPopMatrix()Цветовая схема чисел:
Соответствует классическому "Сапёру" , каждое число имеет уникальный цвет для быстрой идентификации
Трансформации для позиционирования:
glTranslatef()- перемещение в центр клеткиglScalef(0.003, 0.003, 0.003)- масштабирование текстаglTranslatef(-text_width/2, -150, 0)- центрирование и смещение вниз
2.4.8 Метод draw_text_primitive(self, text) - рисование цифр
def draw_text_primitive(self, text):
"""
Рисование текста с помощью базовых примитивов OpenGL
Простая реализация для цифр 0-9
Args:
text: Текст для отображения
"""
for char in text:
if char == '1':
glBegin(GL_LINES)
glVertex2f(40, -150)
glVertex2f(40, 150)
glEnd()
glTranslatef(100, 0, 0)
elif char == '2':
glBegin(GL_LINE_STRIP)
glVertex2f(10, 150) # Левая нижняя
glVertex2f(90, 150) # Правая нижняя
glVertex2f(90, 0) # Правая середина
glVertex2f(10, 0) # Левая середина
glVertex2f(10, -150) # Левая верхняя
glVertex2f(90, -150) # Правая верхняя
glEnd()
glTranslatef(120, 0, 0)
elif char == '3':
glBegin(GL_LINE_STRIP)
glVertex2f(10, -150)
glVertex2f(90, -150)
glVertex2f(90, 0)
glVertex2f(10, 0)
glVertex2f(90, 0)
glVertex2f(90, 150)
glVertex2f(10, 150)
glEnd()
glTranslatef(120, 0, 0)
elif char == '4':
glBegin(GL_LINES)
glVertex2f(10, 150)
glVertex2f(10, 0) # Левая вертикаль
glVertex2f(10, 0)
glVertex2f(90, 0) # Горизонталь
glVertex2f(90, 150)
glVertex2f(90, -150) # Правая вертикаль
glEnd()
glTranslatef(120, 0, 0)
elif char == '5':
glBegin(GL_LINE_STRIP)
glVertex2f(90, 150)
glVertex2f(10, 150)
glVertex2f(10, 0)
glVertex2f(90, 0)
glVertex2f(90, -150)
glVertex2f(10, -150)
glEnd()
glTranslatef(120, 0, 0)
elif char == '6':
glBegin(GL_LINE_STRIP)
glVertex2f(90, -150)
glVertex2f(10, -150)
glVertex2f(10, 150)
glVertex2f(90, 150)
glVertex2f(90, 0)
glVertex2f(10, 0)
glEnd()
glTranslatef(120, 0, 0)
elif char == '7':
glBegin(GL_LINE_STRIP)
glVertex2f(10, 150)
glVertex2f(90, 150)
glVertex2f(90, -150)
glEnd()
glTranslatef(120, 0, 0)
elif char == '8':
glBegin(GL_LINE_LOOP)
glVertex2f(10, -150)
glVertex2f(90, -150)
glVertex2f(90, 150)
glVertex2f(10, 150)
glEnd()
glBegin(GL_LINES)
glVertex2f(10, 0)
glVertex2f(90, 0)
glEnd()
glTranslatef(120, 0, 0)
else:
# Для неизвестных символов просто сдвигаемся
glTranslatef(100, 0, 0)
Примитивы OpenGL для рисования цифр:
GL_LINES- отдельные линии (для цифры 1)GL_LINE_STRIP- последовательные соединенные линии (для большинства цифр)GL_LINE_LOOP- замкнутый контур (для цифры 8)
Координатная система для цифр:
Центр координат в середине цифры
Y от -150 (низ) до 150 (верх) и X от 10 (лево) до 90 (право)
2.9.9 Метод draw_flag(self, x, y) - отрисовка флага
def draw_flag(self, x, y):
"""
Рисование 3D-флага для помеченных клеток
Args:
x, y: Координаты клетки с флагом
"""
glPushMatrix()
glTranslatef(x + self.cell_size / 2, y + self.cell_size / 2, 0.1)
# Рисуем флагшток (коричневый прямоугольник)
glColor3f(0.5, 0.3, 0.1)
glBegin(GL_QUADS)
glVertex3f(-0.1, -0.4, 0)
glVertex3f(0.1, -0.4, 0)
glVertex3f(0.1, 0.4, 0)
glVertex3f(-0.1, 0.4, 0)
glEnd()
# Рисуем флаг (красный треугольник)
glColor3f(1, 0, 0)
glBegin(GL_TRIANGLES)
glVertex3f(0.1, 0.4, 0) # Верх флагштока
glVertex3f(0.1, 0.1, 0) # Низ флага
glVertex3f(0.5, 0.25, 0) # Кончик флага
glEnd()
glPopMatrix()Структура флага:
Флагшток - коричневый прямоугольник от -0.4 до 0.4 по Y
Флаг - красный треугольник, прикрепленный к верхней части флагштока
2.4.10 Метод draw_mine(self, x, y) - отрисовка мины
def draw_mine(self, x, y):
"""
Рисование 3D-мины в виде сферы с шипами
Args:
x, y: Координаты клетки с миной
"""
glPushMatrix()
glTranslatef(x + self.cell_size / 2, y + self.cell_size / 2, 0.1)
# Рисуем черную сферу (тело мины)
glColor3f(0, 0, 0)
gluSphere(self.mine_quadric, 0.3, 20, 20)
# Рисуем серые шипы вокруг мины
glColor3f(0.5, 0.5, 0.5)
for i in range(8):
glPushMatrix()
glRotatef(45 * i, 0, 0, 1)
glTranslatef(0.5, 0, 0)
gluSphere(self.spike_quadric, 0.1, 10, 10)
glPopMatrix()
glPopMatrix()Структура мины:
Тело: черная сфера радиусом 0.3
Шипы: 8 серых сфер радиусом 0.1, равномерно распределенных вокруг
Раздел 3: Финал - итоги и добрые слова
3.1 Итог: Что мы получили
Работающую 3D-версию классического "Сапёра" с свободой обзора камеры, интеллектуальным меню и реалистичной 3D-графикой. Игрок может:
Настраивать размер поля и количество мин перед игрой
Свободно вращать камеру вокруг игрового поля
Приближать и отдалять обзор
Видеть объемные мины с шипами и 3D-флаги
пример - вывод меню 
пример - вывод игрового поля
3.2 Что можно улучшить
☆ Добавить текстуры для клеток и объектов вместо однотонных цветов
☆ Реализовать систему частиц для взрыва при поражении
☆ Добавить звуковые эффекты и фоновую музыку
☆ Создать режим "ночная игра" с динамическим освещением
→ Полный код доступен для модификации и улучшения - на GitHub
→ Все три части проекта (консольная, 2D-GUI, 3D-версия) представляют полный цикл разработки, и также показывают, что одну игру можно реализовать разными способами
Я очень рад, что получилось создать несколько версий игры, которые визуально отличаются уже при запуске кода, демонстрируя эволюцию от простого к сложному. Очень хотелось бы, чтобы кто-то взял этот проект за основу и доработал его до красивой, законченной версии, а не просто оставил в каркасном состоянии - всегда можно добавить эффектный фон, анимацию взрыва или другие визуальные улучшения, превратив это либо в качественное дополнение, либо в совершенно новый продукт. Код находится в открытом доступе, и я уже видел, как сообщество улучшало консольную версию, поэтому очень надеюсь, что и эту 3D-реализацию кто-то подхватит и доведет до идеала, раскрыв весь её потенциал.
P.S. Если обнаружите проблемы или баги - сообщите для исправления
