Создаем RPG игру на Python: пошаговое руководство для начинающих

import pygame
import sys

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

# Константы
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
FPS = 60

# Цвета
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

# Создание окна
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Моя 2D RPG")
clock = pygame.time.Clock()

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

# Обновление игровой логики

# Отрисовка
screen.fill(BLACK)

# Переворачиваем экран
pygame.display.flip()

# Ограничение FPS
clock.tick(FPS)

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

import pygame

class Player:
def __init__(self, x, y):
self.x = x
self.y = y
self.width = 32
self.height = 32
self.speed = 5
self.direction = 'down'

# Характеристики персонажа
self.level = 1
self.max_hp = 100
self.hp = 100
self.attack = 10
self.defense = 5
self.experience = 0

# Инвентарь
self.inventory = []
self.gold = 0

# Загрузка спрайтов
self.sprites = {
'down': pygame.image.load('assets/player_down.png'),
'up': pygame.image.load('assets/player_up.png'),
'left': pygame.image.load('assets/player_left.png'),
'right': pygame.image.load('assets/player_right.png')
}

self.rect = pygame.Rect(x, y, self.width, self.height)

def move(self, dx, dy):
if dx > 0:
self.direction = 'right'
elif dx < 0:
self.direction = 'left'
elif dy > 0:
self.direction = 'down'
elif dy < 0:
self.direction = 'up'

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

def draw(self, screen):
screen.blit(self.sprites[self.direction], (self.x, self.y))

def gain_experience(self, amount):
self.experience += amount
# Проверка на повышение уровня
exp_needed = self.level * 100
if self.experience >= exp_needed:
self.level_up()

def level_up(self):
self.level += 1
self.max_hp += 20
self.hp = self.max_hp
self.attack += 2
self.defense += 1
self.experience = 0
print(f"Level up! Now level {self.level}")

from player import Player

# После инициализации Pygame
player = Player(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)

# В игровом цикле
# Обработка клавиш
keys = pygame.key.get_pressed()
dx, dy = 0, 0
if keys[pygame.K_LEFT]:
dx = -player.speed
if keys[pygame.K_RIGHT]:
dx = player.speed
if keys[pygame.K_UP]:
dy = -player.speed
if keys[pygame.K_DOWN]:
dy = player.speed
player.move(dx, dy)

# В секции отрисовки
screen.fill(BLACK)
player.draw(screen)

import pygame

class NPC:
def __init__(self, x, y, name, sprite_path, is_enemy=False):
self.x = x
self.y = y
self.name = name
self.sprite = pygame.image.load(sprite_path)
self.is_enemy = is_enemy
self.width = 32
self.height = 32
self.rect = pygame.Rect(x, y, self.width, self.height)

# Характеристики для врагов
if is_enemy:
self.hp = 50
self.attack = 8
self.defense = 3
self.experience_reward = 20
self.gold_reward = 10

# Диалоги для дружественных NPC
self.dialogues = []

def draw(self, screen):
screen.blit(self.sprite, (self.x, self.y))

def add_dialogue(self, text):
self.dialogues.append(text)

def get_dialogue(self):
if not self.dialogues:
return "..."
return self.dialogues[0] # Для простоты берем первый диалог

class Item:
def __init__(self, name, description, item_type, value, effect=None):
self.name = name
self.description = description
self.item_type = item_type # 'weapon', 'armor', 'potion', etc.
self.value = value # Gold value
self.effect = effect # Function or value for item effect

def use(self, player):
if self.item_type == 'potion':
player.hp = min(player.hp + self.effect, player.max_hp)
return True # Item consumed
elif self.item_type == 'weapon':
player.attack += self.effect
return False # Item equipped, not consumed
elif self.item_type == 'armor':
player.defense += self.effect
return False # Item equipped, not consumed
return False

class Quest:
def __init__(self, name, description, reward_gold, reward_exp):
self.name = name
self.description = description
self.completed = False
self.reward_gold = reward_gold
self.reward_exp = reward_exp
self.objectives = []

def add_objective(self, description, target_count, current_count=0):
self.objectives.append({
'description': description,
'target': target_count,
'current': current_count
})

def update_objective(self, index, amount=1):
if index >= len(self.objectives):
return False

self.objectives[index]['current'] += amount

# Check if all objectives are completed
all_completed = True
for obj in self.objectives:
if obj['current'] < obj['target']:
all_completed = False
break

self.completed = all_completed
return self.completed

def claim_reward(self, player):
if self.completed:
player.gold += self.reward_gold
player.gain_experience(self.reward_exp)
return True
return False

import pygame

class TileMap:
def __init__(self, tile_size):
self.tile_size = tile_size
self.tiles = {} # Словарь тайлов: (x, y) -> tile_type
self.collision_tiles = set() # Тайлы, с которыми нельзя столкнуться
self.interactive_tiles = {} # Тайлы, с которыми можно взаимодействовать

# Загрузка изображений тайлов
self.tile_images = {
'grass': pygame.image.load('assets/tiles/grass.png'),
'water': pygame.image.load('assets/tiles/water.png'),
'tree': pygame.image.load('assets/tiles/tree.png'),
'stone': pygame.image.load('assets/tiles/stone.png'),
'chest': pygame.image.load('assets/tiles/chest.png'),
'door': pygame.image.load('assets/tiles/door.png')
}

# Определяем, какие типы тайлов непроходимы
self.collision_types = {'water', 'tree', 'stone'}

def load_map(self, filename):
"""Загрузка карты из файла"""
with open(filename, 'r') as f:
lines = f.readlines()

for y, line in enumerate(lines):
tiles = line.strip().split(',')
for x, tile in enumerate(tiles):
if tile == '-': # Пустая клетка
continue

tile_x = x * self.tile_size
tile_y = y * self.tile_size

self.tiles[(tile_x, tile_y)] = tile

if tile in self.collision_types:
self.collision_tiles.add((tile_x, tile_y))

if tile in {'chest', 'door'}:
self.interactive_tiles[(tile_x, tile_y)] = {
'type': tile,
'used': False,
'content': [] # Для сундуков – содержимое
}

def draw(self, screen, camera_x=0, camera_y=0):
"""Отрисовка видимой части карты"""
screen_width, screen_height = screen.get_size()

# Определяем видимую область
start_x = max(0, camera_x // self.tile_size)
start_y = max(0, camera_y // self.tile_size)
end_x = min(start_x + (screen_width // self.tile_size) + 1, len(self.tiles))
end_y = min(start_y + (screen_height // self.tile_size) + 1, len(self.tiles))

# Отрисовка видимых тайлов
for y in range(start_y, end_y):
for x in range(start_x, end_x):
tile_x = x * self.tile_size – camera_x
tile_y = y * self.tile_size – camera_y
pos = (x * self.tile_size, y * self.tile_size)

if pos in self.tiles:
tile_type = self.tiles[pos]
screen.blit(self.tile_images[tile_type], (tile_x, tile_y))

def check_collision(self, rect):
"""Проверка коллизии с непроходимыми тайлами"""
# Получаем тайлы, с которыми может столкнуться объект
tile_positions = []
for y in range(rect.y // self.tile_size, (rect.y + rect.height) // self.tile_size + 1):
for x in range(rect.x // self.tile_size, (rect.x + rect.width) // self.tile_size + 1):
tile_positions.append((x * self.tile_size, y * self.tile_size))

# Проверяем, есть ли среди них непроходимые
for pos in tile_positions:
if pos in self.collision_tiles:
return True
return False

def check_interaction(self, rect):
"""Проверка взаимодействия с интерактивными объектами"""
for pos, data in self.interactive_tiles.items():
tile_rect = pygame.Rect(pos[0], pos[1], self.tile_size, self.tile_size)
if rect.colliderect(tile_rect):
return pos, data
return None, None

w,w,w,w,w,w,w,w,w,w,w,w,w,w,w
w,g,g,g,g,g,g,g,g,g,g,g,g,g,w
w,g,g,g,t,g,g,g,g,g,t,g,g,g,w
w,g,g,g,g,g,g,g,g,g,g,g,g,g,w
w,g,t,g,g,g,g,g,g,g,g,g,g,g,w
w,g,g,g,g,g,g,g,g,g,g,g,c,g,w
w,g,g,g,g,g,g,g,g,g,g,g,g,g,w
w,g,g,g,s,s,g,g,g,s,g,g,g,g,w
w,g,g,g,g,g,g,g,g,g,g,g,g,g,w
w,w,w,w,w,w,d,d,w,w,w,w,w,w,w

from world import TileMap

# После инициализации pygame и создания игрока
tile_map = TileMap(32) # Размер тайла 32x32 пикселя
tile_map.load_map('maps/level1.txt')

camera_x, camera_y = 0, 0

# В игровом цикле
# После обработки клавиш и перед движением игрока
new_rect = player.rect.copy()
new_rect.x += dx
new_rect.y += dy

if not tile_map.check_collision(new_rect):
player.move(dx, dy)

# Обновляем камеру для следования за игроком
camera_x = max(0, player.x – SCREEN_WIDTH // 2)
camera_y = max(0, player.y – SCREEN_HEIGHT // 2)

# Проверка взаимодействия с объектами при нажатии клавиши E
keys = pygame.key.get_pressed()
if keys[pygame.K_e]:
pos, data = tile_map.check_interaction(player.rect)
if data:
if data['type'] == 'chest' and not data['used']:
print("Вы нашли сокровище!")
player.gold += 50
data['used'] = True
elif data['type'] == 'door':
print("Переход на новую локацию!")
# Здесь можно добавить код для загрузки другой карты

# В секции отрисовки
screen.fill(BLACK)
tile_map.draw(screen, camera_x, camera_y)
player.draw(screen)

class InteractiveObject:
def __init__(self, x, y, width, height, obj_type):
self.x = x
self.y = y
self.width = width
self.height = height
self.type = obj_type # 'chest', 'npc', 'portal', etc.
self.activated = False
self.rect = pygame.Rect(x, y, width, height)

def interact(self, player):
"""Базовый метод взаимодействия, переопределяется в дочерних классах"""
pass

class Chest(InteractiveObject):
def __init__(self, x, y, items=None, gold=0):
super().__init__(x, y, 32, 32, 'chest')
self.items = items or []
self.gold = gold
self.opened = False

def interact(self, player):
if not self.opened:
player.gold += self.gold
for item in self.items:
player.inventory.append(item)
self.opened = True
return f"Вы нашли {self.gold} золота и {len(self.items)} предметов!"
return "Сундук уже открыт."

class Portal(InteractiveObject):
def __init__(self, x, y, destination_map, destination_x, destination_y):
super().__init__(x, y, 32, 32, 'portal')
self.destination_map = destination_map
self.destination_x = destination_x
self.destination_y = destination_y

def interact(self, player, game_world):
game_world.load_map(self.destination_map)
player.x = self.destination_x
player.y = self.destination_y
return f"Вы перешли в новую локацию."

import random
import pygame

class CombatSystem:
def __init__(self, player, enemy):
self.player = player
self.enemy = enemy
self.is_player_turn = True
self.combat_log = []
self.combat_active = True

def player_attack(self):
if not self.is_player_turn or not self.combat_active:
return False

damage = max(1, self.player.attack – self.enemy.defense // 2)
# Шанс критического удара (20%)
if random.random() < 0.2:
damage *= 2
self.add_log("Критический удар!")

self.enemy.hp -= damage
self.add_log(f"Вы нанесли {damage} урона врагу.")

if self.enemy.hp <= 0:
self.enemy.hp = 0
self.combat_victory()
else:
self.is_player_turn = False

return True

def enemy_attack(self):
if self.is_player_turn or not self.combat_active:
return False

damage = max(1, self.enemy.attack – self.player.defense // 2)

self.player.hp -= damage
self.add_log(f"Враг нанес вам {damage} урона.")

if self.player.hp <= 0:
self.player.hp = 0
self.combat_defeat()
else:
self.is_player_turn = True

return True

def combat_victory(self):
self.combat_active = False
self.add_log(f"Вы победили {self.enemy.name}!")
self.player.gain_experience(self.enemy.experience_reward)
self.player.gold += self.enemy.gold_reward
self.add_log(f"Получено {self.enemy.experience_reward} опыта и {self.enemy.gold_reward} золота.")

def combat_defeat(self):
self.combat_active = False
self.add_log("Вы проиграли...")
# Здесь можно добавить последствия поражения

def use_item(self, item_index):
if not self.is_player_turn or not self.combat_active:
return False

if item_index < 0 or item_index >= len(self.player.inventory):
return False

item = self.player.inventory[item_index]

# Использование предмета возвращает True, если предмет был потреблен
if item.use(self.player):
self.add_log(f"Вы использовали {item.name}.")
self.player.inventory.pop(item_index)
self.is_player_turn = False
return True
else:
self.add_log("Этот предмет нельзя использовать в бою.")
return False

def add_log(self, message):
self.combat_log.append(message)
print(message) # Для отладки

def draw_combat_ui(self, screen):
# Отрисовка интерфейса боя
# Это базовая реализация, можно улучшить и стилизовать

# Фон для боевого интерфейса
combat_bg = pygame.Surface((screen.get_width(), 200))
combat_bg.fill((50, 50, 50))
screen.blit(combat_bg, (0, screen.get_height() – 200))

# Информация о персонажах
font = pygame.font.Font(None, 24)

player_info = f"Игрок: HP {self.player.hp}/{self.player.max_hp}"
player_text = font.render(player_info, True, (255, 255, 255))
screen.blit(player_text, (20, screen.get_height() – 180))

enemy_info = f"Враг: {self.enemy.name} HP {self.enemy.hp}"
enemy_text = font.render(enemy_info, True, (255, 255, 255))
screen.blit(enemy_text, (20, screen.get_height() – 150))

# Боевой лог (последние 5 сообщений)
log_y = screen.get_height() – 120
for message in self.combat_log[-5:]:
log_text = font.render(message, True, (255, 255, 255))
screen.blit(log_text, (20, log_y))
log_y += 20

# Кнопки действий
if self.is_player_turn and self.combat_active:
actions = ["Атаковать", "Предметы", "Защищаться", "Бежать"]
action_x = 20
for action in actions:
action_btn = pygame.Surface((100, 30))
action_btn.fill((100, 100, 200))
action_text = font.render(action, True, (255, 255, 255))
action_btn.blit(action_text, (10, 5))
screen.blit(action_btn, (action_x, screen.get_height() – 40))
action_x += 120

# Добавьте в импорты
from combat import CombatSystem
from npc import NPC

# Глобальные переменные для боевой системы
current_combat = None
in_combat = False

def start_combat(player, enemy):
global current_combat, in_combat
current_combat = CombatSystem(player, enemy)
in_combat = True

# В игровом цикле
if in_combat:
# Обработка ввода в режиме боя
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
# Проверяем клики по кнопкам действий
mouse_x, mouse_y = pygame.mouse.get_pos()
if screen.get_height() – 40 <= mouse_y <= screen.get_height() – 10:
if 20 <= mouse_x <= 120: # Атака
current_combat.player_attack()
elif 140 <= mouse_x <= 240: # Предметы
# Здесь можно добавить выбор предмета из инвентаря
pass
elif 260 <= mouse_x <= 360: # Защита
# Увеличиваем защиту на один ход
player.defense += 5
current_combat.add_log("Вы приняли защитную стойку!")
current_combat.is_player_turn = False
elif 380 <= mouse_x <= 480: # Побег
# Шанс побега 50%
if random.random() < 0.5:
current_combat.add_log("Вы успешно сбежали!")
in_combat = False
else:
current_combat.add_log("Не удалось сбежать!")
current_combat.is_player_turn = False

# Ход противника
if not current_combat.is_player_turn and current_combat.combat_active:
current_combat.enemy_attack()

# Проверка окончания боя
if not current_combat.combat_active:
# Задержка перед возвращением к игре
pygame.time.delay(2000)
in_combat = False

# Отрисовка боевого интерфейса
screen.fill(BLACK)
current_combat.draw_combat_ui(screen)
else:
# Обычный игровой процесс

import pickle
import os

def save_game(player, world_state, filename='save.dat'):
"""Сохранить игру в файл"""
save_data = {
'player': {
'x': player.x,
'y': player.y,
'hp': player.hp,
'max_hp': player.max_hp,
'attack': player.attack,
'defense': player.defense,
'level': player.level,
'experience': player.experience,
'gold': player.gold,
'inventory': player.inventory
},
'world': world_state
}

with open(f'saves/{filename}', 'wb') as f:
pickle.dump(save_data, f)
print(f"Игра сохранена в {filename}")

def load_game(player, world_manager, filename='save.dat'):
"""Загрузить игру из файла"""
if not os.path.exists(f'saves/{filename}'):
print(f"Файл сохранения {filename} не найден")
return False

try:
with open(f'saves/{filename}', 'rb') as f:
save_data = pickle.load(f)

# Восстанавливаем данные игрока
player_data = save_data['player']
player.x = player_data['x']
player.y = player_data['y']
player.hp = player_data['hp']
player.max_hp = player_data['max_hp']
player.attack = player_data['attack']
player.defense = player_data['defense']
player.level = player_data['level']
player.experience = player_data['experience']
player.gold = player_data['gold']
player.inventory = player_data['inventory']

# Восстанавливаем состояние мира
world_state = save_data['world']
world_manager.restore_state(world_state)

print(f"Игра загружена из {filename}")
return True
except Exception as e:
print(f"Ошибка при загрузке игры: {e}")
return False

# Импортируем систему сохранений
from save_system import save_game, load_game

# В обработке событий добавим
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_F5: # Сохранение по F5
world_state = {
'current_map': 'maps/level1.txt', # Адаптируйте под вашу систему карт
'interactive_objects': tile_map.interactive_tiles,
'npcs': npcs_state() # Функция для сохранения состояния NPC
}
save_game(player, world_state)
elif event.key == pygame.K_F9: # Загрузка по F9
if load_game(player, world_manager):
# Обновляем положение камеры после загрузки
camera_x = max(0, player.x – SCREEN_WIDTH // 2)
camera_y = max(0, player.y – SCREEN_HEIGHT // 2)