Создаем гоночную игру на Python: от базового шаблона до финала

pip install pygame

import pygame
import sys

# Инициализация Pygame
pygame.init()

# Настройка окна
screen_width = 800
screen_height = 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Гоночная игра на Python")

# Основной игровой цикл
running = True
while running:
# Обработка событий
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False

# Логика игры

# Отрисовка
screen.fill((0, 0, 0)) # Заливка экрана черным цветом
pygame.display.flip() # Обновление экрана

# Ограничение FPS
pygame.time.Clock().tick(60)

# Завершение работы
pygame.quit()
sys.exit()

import pygame
import os
import sys

# Инициализация и настройки окна (как в предыдущем примере)
pygame.init()
screen_width = 800
screen_height = 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Гоночная игра на Python")

# Создаем класс для управления ресурсами
class ResourceManager:
def __init__(self):
self.images = {}
self.sounds = {}

def load_image(self, name, path, scale=1):
fullpath = os.path.join('assets', 'images', path)
try:
image = pygame.image.load(fullpath).convert_alpha()
if scale != 1:
w, h = image.get_width(), image.get_height()
image = pygame.transform.scale(image, (int(w * scale), int(h * scale)))
self.images[name] = image
return image
except pygame.error as e:
print(f"Не удалось загрузить изображение: {fullpath}")
print(f"Ошибка: {e}")
return None

def get_image(self, name):
return self.images.get(name)

# Создаем экземпляр менеджера ресурсов
resources = ResourceManager()

# Загружаем изображения
car_image = resources.load_image('player_car', 'car.png', scale=0.5)
road_image = resources.load_image('road', 'road.png')
background_image = resources.load_image('background', 'background.png')

# Настройка игровых объектов
car_x = screen_width // 2
car_y = screen_height – 100

# Основной игровой цикл
clock = pygame.time.Clock()
running = True

while running:
# Обработка событий
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False

# Отрисовка
if background_image:
screen.blit(background_image, (0, 0))
if road_image:
screen.blit(road_image, (0, 0))
if car_image:
screen.blit(car_image, (car_x, car_y))

pygame.display.flip()
clock.tick(60) # 60 FPS

pygame.quit()
sys.exit()

racing_game/
├── main.py
├── assets/
│ ├── images/
│ │ ├── cars/
│ │ │ ├── player_car.png
│ │ │ └── enemy_cars/
│ │ ├── background/
│ │ │ ├── road.png
│ │ │ └── scenery.png
│ │ └── ui/
│ │ ├── buttons.png
│ │ └── scoreboard.png
│ └── sounds/
│ ├── engine.wav
│ ├── crash.wav
│ └── music.mp3
├── src/
│ ├── car.py
│ ├── game.py
│ └── utils.py
└── README.md

class Player:
def __init__(self, x, y, image):
self.x = x
self.y = y
self.image = image
self.speed = 0
self.max_speed = 10
self.acceleration = 0.2
self.deceleration = 0.1
self.turning_speed = 5
self.angle = 0 # Угол поворота в градусах
self.rotated_image = image
self.rect = self.image.get_rect(center=(x, y))

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

# Ускорение и торможение
if keys[pygame.K_UP]:
self.speed = min(self.speed + self.acceleration, self.max_speed)
elif keys[pygame.K_DOWN]:
self.speed = max(self.speed – self.acceleration, -self.max_speed/2)
else:
# Замедление, когда не нажаты клавиши
if self.speed > 0:
self.speed = max(self.speed – self.deceleration, 0)
elif self.speed < 0:
self.speed = min(self.speed + self.deceleration, 0)

# Поворот только когда автомобиль движется
if abs(self.speed) > 0.1:
if keys[pygame.K_LEFT]:
self.angle += self.turning_speed * (self.speed / self.max_speed)
if keys[pygame.K_RIGHT]:
self.angle -= self.turning_speed * (self.speed / self.max_speed)

def update(self):
# Расчет движения на основе скорости и угла
radians = math.radians(self.angle)
dx = -math.sin(radians) * self.speed
dy = -math.cos(radians) * self.speed

self.x += dx
self.y += dy

# Обновление позиции и поворота изображения
self.rotated_image = pygame.transform.rotate(self.image, self.angle)
self.rect = self.rotated_image.get_rect(center=(self.x, self.y))

def draw(self, screen):
screen.blit(self.rotated_image, self.rect.topleft)

# В начале файла добавим:
import math

# После загрузки ресурсов:
player = Player(screen_width // 2, screen_height – 100, car_image)

# В основном игровом цикле:
while running:
# Обработка событий
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False

# Обновление игровой логики
player.handle_keys()
player.update()

# Отрисовка
if background_image:
screen.blit(background_image, (0, 0))
if road_image:
screen.blit(road_image, (0, 0))

player.draw(screen)

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

class Track:
def __init__(self, image, boundary_color=(255, 0, 0)):
self.image = image
self.boundary_color = boundary_color
# Создаем маску для обнаружения столкновений с границами
self.mask = pygame.mask.from_surface(self.image)

def draw(self, screen):
screen.blit(self.image, (0, 0))

def check_collision(self, player):
# Получаем позицию игрока относительно трассы
player_x = int(player.x)
player_y = int(player.y)

# Проверяем, находится ли точка на границе трассы
try:
color = self.image.get_at((player_x, player_y))
if color[0:3] == self.boundary_color:
return True
except IndexError:
# Если игрок вышел за пределы изображения
return True

return False

def handle_collision(self, player):
# Упрощенная обработка столкновения – просто остановка и небольшой откат
if self.check_collision(player):
# Уменьшаем скорость и немного отбрасываем назад
player.speed = -player.speed * 0.5

# Откатываем позицию на один шаг назад
radians = math.radians(player.angle)
player.x += math.sin(radians) * player.speed * 2
player.y += math.cos(radians) * player.speed * 2
return True
return False

# После загрузки ресурсов:
track_image = resources.load_image('track', 'track.png')
track = Track(track_image, boundary_color=(255, 0, 0))

# В основном игровом цикле, перед отрисовкой игрока:
track.draw(screen)

# После обновления игрока, но до отрисовки:
track.handle_collision(player)

def check_collision(self, player):
# Создаем маску для спрайта игрока
player_mask = pygame.mask.from_surface(player.rotated_image)

# Смещение для проверки коллизии
offset_x = int(player.rect.x)
offset_y = int(player.rect.y)

# Проверка перекрытия масок
overlap = self.mask.overlap(player_mask, (offset_x, offset_y))

return overlap is not None

class AIOpponent:
def __init__(self, x, y, image, track, waypoints):
self.x = x
self.y = y
self.image = image
self.track = track
self.waypoints = waypoints # Список точек, по которым будет двигаться ИИ
self.current_waypoint = 0
self.speed = 3
self.angle = 0
self.rotated_image = image
self.rect = self.image.get_rect(center=(x, y))

def update(self):
# Получаем текущую целевую точку
target_x, target_y = self.waypoints[self.current_waypoint]

# Рассчитываем направление к целевой точке
dx = target_x – self.x
dy = target_y – self.y

# Рассчитываем угол к целевой точке
target_angle = math.degrees(math.atan2(-dx, -dy))

# Плавно поворачиваем к целевой точке
angle_diff = (target_angle – self.angle + 180) % 360 – 180
if abs(angle_diff) > 2:
self.angle += min(2, max(-2, angle_diff * 0.1))

# Двигаемся вперед
radians = math.radians(self.angle)
self.x -= math.sin(radians) * self.speed
self.y -= math.cos(radians) * self.speed

# Обновляем изображение и прямоугольник
self.rotated_image = pygame.transform.rotate(self.image, self.angle)
self.rect = self.rotated_image.get_rect(center=(self.x, self.y))

# Проверяем, достигли ли мы текущей точки
if math.hypot(dx, dy) < 30:
self.current_waypoint = (self.current_waypoint + 1) % len(self.waypoints)

def draw(self, screen):
screen.blit(self.rotated_image, self.rect.topleft)

class GameHUD:
def __init__(self, screen_width, screen_height):
self.screen_width = screen_width
self.screen_height = screen_height
self.font = pygame.font.SysFont('Arial', 24)
self.start_time = pygame.time.get_ticks()
self.score = 0
self.lap = 0

def update(self, player_speed, lap_completed=False):
if lap_completed:
self.lap += 1
self.score += 1000 # Бонус за круг

# Дополнительные очки за скорость
self.score += abs(int(player_speed * 0.1))

def draw(self, screen):
# Рассчитываем прошедшее время
elapsed_time = (pygame.time.get_ticks() – self.start_time) // 1000
minutes = elapsed_time // 60
seconds = elapsed_time % 60

# Отрисовываем информацию
time_text = self.font.render(f'Время: {minutes:02d}:{seconds:02d}', True, (255, 255, 255))
score_text = self.font.render(f'Очки: {self.score}', True, (255, 255, 255))
lap_text = self.font.render(f'Круг: {self.lap}', True, (255, 255, 255))

screen.blit(time_text, (10, 10))
screen.blit(score_text, (10, 40))
screen.blit(lap_text, (10, 70))

class Checkpoint:
def __init__(self, x, y, width, height, checkpoint_id):
self.rect = pygame.Rect(x, y, width, height)
self.id = checkpoint_id
self.passed = False

def check_passed(self, player_rect):
if not self.passed and self.rect.colliderect(player_rect):
self.passed = True
return True
return False

def reset(self):
self.passed = False

def draw(self, screen, debug=False):
if debug:
pygame.draw.rect(screen, (0, 255, 0) if self.passed else (255, 0, 0), self.rect, 2)

# Создаем контрольные точки
checkpoints = [
Checkpoint(400, 200, 50, 100, 0),
Checkpoint(600, 400, 100, 50, 1),
Checkpoint(200, 500, 100, 50, 2),
]

# Создаем путевые точки для ИИ соперников
ai_waypoints = [
(400, 200), (500, 300), (600, 400), 
(500, 500), (300, 500), (200, 400), 
(200, 200), (300, 150)
]

# Создаем ИИ соперника
opponent_image = resources.load_image('opponent_car', 'opponent_car.png', scale=0.5)
opponent = AIOpponent(300, 200, opponent_image, track, ai_waypoints)

# Создаем игровой HUD
hud = GameHUD(screen_width, screen_height)

# Переменные для отслеживания кругов
current_checkpoint = 0
total_checkpoints = len(checkpoints)
lap_completed = False

# В основном игровом цикле
while running:
# ... (обработка событий)

# Обновление
player.handle_keys()
player.update()
opponent.update()

# Проверка контрольных точек
if checkpoints[current_checkpoint].check_passed(player.rect):
current_checkpoint = (current_checkpoint + 1) % total_checkpoints
if current_checkpoint == 0:
lap_completed = True

# Обновление HUD
hud.update(player.speed, lap_completed)
lap_completed = False # Сбрасываем флаг круга

# Проверка столкновений
track.handle_collision(player)

# Отрисовка
track.draw(screen)

# Отрисовка контрольных точек в режиме отладки
for cp in checkpoints:
cp.draw(screen, debug=True)

player.draw(screen)
opponent.draw(screen)
hud.draw(screen)

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