Искусство разработки игр

Разработка игры "Пятнашки" на SFML C++

2025-06-05T14:48:49.656Z

Привет! Сегодня хочу поделиться опытом создания классической головоломки — игры "Пятнашки", на C++ с использованием фреймворка SFML (Simple and Fast Multimedia Library).

Если вы начинающий разработчик или просто любите писать игры своими руками, то эта статья может вам понравиться.
Я расскажу не только о том, как отобразить окно и кнопки, но и о том, как организовать логику игры, обработать взаимодействие пользователя, а также немного поговорим о структуре проекта и возможностях SFML.

Игра "Пятнашки" — отличный способ попрактиковаться в программировании: здесь есть и логика, и работа с интерфейсом, и даже простая анимация. А SFML — это отличный выбор для тех, кто хочет создавать 2D-игры без излишней сложности и с минимальным порогом входа.

Давайте начнём!

Подготовка среды разработки

Перед тем как писать код, нужно подготовить рабочую среду:

Установите компилятор C++.

Например:

GCC (Linux)

MinGW (Windows)

Visual Studio (Windows)

Скачайте и установите SFML:

Официальный сайт: https://www.sfml-dev.org/download.php

Выберите версию под ваш компилятор и систему.

Настройте свой проект:

Добавьте пути к заголовочным файлам SFML.

Слинкуйте нужные библиотеки (sfml-graphics, sfml-window, sfml-system).

Проверьте, что всё работает — откройте простое окно SFML.

Общая структура проекта

Вот как выглядел мой проект:

Базовый класс Screen — основа всех экранов

В процессе создания игры важно было организовать удобную архитектуру, особенно потому, что у нас есть несколько экранов: главное меню, игровой экран и экран с правилами. Чтобы не повторять один и тот же код в каждом из них, я создал абстрактный базовый класс Screen.

Зачем он нужен?

Класс Screen служит общей основой для всех экранов приложения:

он предоставляет доступ к окну (sf::RenderWindow);

хранит ссылки на глобальное состояние игры (GameState) и переходы между экранами (Transition);

реализует общие элементы интерфейса (например, фон);

упрощает расширяемость проекта — добавление нового экрана становится простым делом.

Основные компоненты класса

Screen.h

#pragma once
#include <SFML/Graphics.hpp>
#include "GameState.h"
#include "Transition.h"
#include "ResourceManager.h"
#include <memory>

class Screen : public sf::Drawable {
protected:
    sf::RenderWindow& window;
    GameState& state;
    Transition& transition;

    // Общие элементы интерфейса
    sf::Sprite backgroundSprite;
    bool useTexture;

    Screen(sf::RenderWindow& window, G
    ameState& state, Transition& transition);

    // Виртуальные методы для настройки ресурсов и элементов интерфейса
    virtual void initialize() = 0;

    // Вспомогательные методы
    void setupBackground(const std::string& textureId);

public:
    virtual ~Screen() = default;

    // Общие методы, которые будут переопределяться
    virtual void handleEvent(const sf::Event& event) = 0;
    virtual void update(float deltaTime) = 0;
    virtual void 
    draw(sf::RenderTarget& target, sf::RenderStates states) const = 0;
};

Screen.cpp

#include "Screen.h"
#include <iostream>

Screen::Screen(sf::RenderWindow& window, GameState& state,
 Transition& transition)
    : window(window), state(state), transition(transition), 
    useTexture(false) {
}

void Screen::setupBackground(const std::string& textureId) {
    ResourceManager& rm = ResourceManager::getInstance();
    sf::Texture& bgTexture = rm.getTexture(textureId);
    if (bgTexture.getSize().x == 0) {
        std::cerr << "Ошибка: Не удалось загрузить текстуру фона '" 
        << textureId << "' из ResourceManager.\n";
        useTexture = false;
    }
    else {
        useTexture = true;
        backgroundSprite.setTexture(bgTexture);
        backgroundSprite.setScale(
            static_cast<float>(window.getSize().x) / bgTexture.getSize().x,
            static_cast<float>(window.getSize().y) / bgTexture.getSize().y
        );
    }
}

Что здесь происходит?

Конструктор принимает ссылки на важнейшие объекты: окно, состояние игры и переходы.

initialize() — чисто виртуальный метод, который должен быть реализован в каждом дочернем классе. Здесь можно загрузить специфичные для экрана ресурсы или создать кнопки.

setupBackground() — универсальный метод для настройки фона. Он использует ResourceManager, чтобы получить текстуру по ID и корректно её от масштабировать под размер окна.

Все экраны обязаны реализовать три ключевых метода:

handleEvent() — обработка событий (нажатия мыши, клавиш и т.д.)

update() — логика обновления состояния экрана (анимации, проверка условий и пр.)

draw() — отрисовка всех элементов экрана.

Реализация класса ResourceManager с поддержкой ресурсов Windows

Одним из важнейших компонентов в любой игре или мультимедийном приложении является централизованное управление ресурсами. В этой главе мы рассмотрим реализацию класса ResourceManager на C++ с использованием SFML и Windows API.

Класс ResourceManager отвечает за загрузку и хранение следующих типов ресурсов:

· sf::Font — шрифты;

· sf::SoundBuffer — звуковые эффекты;

· sf::Texture — текстуры;

· sf::Music — музыкальные потоки (streaming).

Все ресурсы хранятся в памяти, загружаются из ресурсов Windows .exe файла (раздел .rc) и доступны по строковому идентификатору.

resource.h

#pragma once

#define IDR_TEXTURE1   102  // Изображение PNG
#define IDR_TEXTURE2   103  // Изображение PNG
#define IDR_TEXTURE3   104  // Изображение PNG
#define IDR_TEXTURE4   105  // Изображение PNG
#define IDR_TEXTURE5   106  // Изображение PNG

#define IDR_FONT1      201  // Шрифт
#define IDR_FONT2      202  // Шрифт

#define IDR_SOUND1     301  // Звук

#define IDR_ICON1      401  // Иконка

fifteen_puzzle.rc

#include "resource.h"

IDR_TEXTURE1   RCDATA  "assets/puzzle.png"
IDR_TEXTURE2   RCDATA  "assets/background.png"
IDR_TEXTURE3   RCDATA  "assets/background1.png"
IDR_TEXTURE4   RCDATA  "assets/background2.png"
IDR_TEXTURE5   RCDATA  "assets/numbers.png"

IDR_SOUND1     RCDATA "assets/music.wav"

IDR_FONT1      RCDATA "assets/arial.ttf"
IDR_FONT2      RCDATA "assets/glv.ttf"

IDR_ICON1      ICON "assets/puzzle.ico"

ResourceManager.h

#pragma once

#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include <windows.h>
#include <map>
#include <string>
#include <memory>

class ResourceManager {
private:
	// Хранилища для ресурсов
    // Хранилище для шрифтов
    std::map<std::string, sf::Font> fonts;
    // Хранилище для звуковых буферов
    std::map<std::string, sf::SoundBuffer> buffers;
    // Хранилище для текстур
    std::map<std::string, sf::Texture> textures;
    // Хранилище для музыкальных потоков
    std::map<std::string, std::unique_ptr<sf::Music>> musicStreams; 

    // Приватный конструктор для реализации синглтона
    ResourceManager();

    // Приватный деструктор
    ~ResourceManager() {}

    // Вспомогательный метод для загрузки ресурса
    template<typename T>
    bool loadResource(HRSRC resource, HGLOBAL handle, T& target);

public:
    // Метод получения единственного экземпляра класса
    static ResourceManager& getInstance();

    // Запрет копирования
    ResourceManager(const ResourceManager&) = delete;
    ResourceManager& operator=(const ResourceManager&) = delete;

    // Методы загрузки конкретных ресурсов
    bool loadFont(const std::string& id, int resourceId);
    bool loadSound(const std::string& id, int resourceId);
    bool loadTexture(const std::string& id, int resourceId);
    bool loadMusic(const std::string& id, int resourceId); 

    // Геттеры для получения ресурсов по идентификатору
    sf::Font& getFont(const std::string& id);
    sf::SoundBuffer& getSoundBuffer(const std::string& id);
    sf::Texture& getTexture(const std::string& id);
    sf::Image getImage(const std::string& id);
    sf::Music& getMusic(const std::string& id); 
};

ResourceManager.cpp

#include "ResourceManager.h"
#include <iostream>

// Конструктор по умолчанию
ResourceManager::ResourceManager() {}

// Шаблонная функция для загрузки ресурса из памяти в целевой объект (например, шрифт, текстура и т.д.)
template<typename T>
bool ResourceManager::loadResource(HRSRC resource, HGLOBAL handle, T& target) {
    if (!resource) {
        std::cerr << "Не удалось найти ресурс" << std::endl;
        return false;
    }

    // Загружаем ресурс в память
    handle = LoadResource(NULL, resource);
    if (!handle) {
        std::cerr << "Не удалось загрузить ресурс" << std::endl;
        return false;
    }

    // Получаем указатель на данные ресурса
    const void* data = LockResource(handle);

    // Получаем размер ресурса
    DWORD size = SizeofResource(NULL, resource);

    // Пытаемся загрузить ресурс в целевой объект (например, sf::Font или sf::Texture)
    return target.loadFromMemory(data, size);
}

// Возвращает единственный экземпляр ResourceManager (паттерн Singleton)
ResourceManager& ResourceManager::getInstance() {
    static ResourceManager instance;
    return instance;
}

// Загружает шрифт из ресурса Windows с заданным ID и сохраняет его под указанным идентификатором
bool ResourceManager::loadFont(const std::string& id, int resourceId) {
    // Находим ресурс шрифта в исполняемом файле
    HRSRC fontResource = FindResource(NULL, MAKEINTRESOURCE(resourceId), RT_RCDATA);
    HGLOBAL fontHandle = NULL;

    sf::Font font;
    if (!loadResource(fontResource, fontHandle, font)) {
        std::cerr << "Не удалось загрузить шрифт " << id << std::endl;
        return false;
    }

    // Сохраняем загруженный шрифт в хранилище
    fonts[id] = std::move(font);
    return true;
}

// Загружает звуковой буфер из ресурса Windows с заданным ID и сохраняет его под указанным идентификатором
bool ResourceManager::loadSound(const std::string& id, int resourceId) {
    HRSRC soundResource = FindResource(NULL, MAKEINTRESOURCE(resourceId), RT_RCDATA);
    HGLOBAL soundHandle = NULL;

    sf::SoundBuffer buffer;
    if (!loadResource(soundResource, soundHandle, buffer)) {
        std::cerr << "Не удалось загрузить звук " << id << std::endl;
        return false;
    }

    // Сохраняем загруженный звуковой буфер в хранилище
    buffers[id] = std::move(buffer);
    return true;
}

// Загружает текстуру из ресурса Windows с заданным ID и сохраняет её под указанным идентификатором
bool ResourceManager::loadTexture(const std::string& id, int resourceId) {
    HRSRC textureResource = FindResource(NULL, MAKEINTRESOURCE(resourceId), RT_RCDATA);
    HGLOBAL textureHandle = NULL;

    sf::Texture texture;
    if (!loadResource(textureResource, textureHandle, texture)) {
        std::cerr << "Не удалось загрузить текстуру " << id << std::endl;
        return false;
    }

    // Сохраняем загруженную текстуру в хранилище
    textures[id] = std::move(texture);
    return true;
}

// Загружает музыку из ресурса Windows с заданным ID и сохраняет её под указанным идентификатором
bool ResourceManager::loadMusic(const std::string& id, int resourceId) {
    HRSRC musicResource = FindResource(NULL, MAKEINTRESOURCE(resourceId), RT_RCDATA);
    HGLOBAL musicHandle = NULL;

    if (!musicResource) {
        std::cerr << "Не удалось найти музыкальный ресурс " << id << std::endl;
        return false;
    }

    musicHandle = LoadResource(NULL, musicResource);
    if (!musicHandle) {
        std::cerr << "Не удалось загрузить музыкальный ресурс " << id << std::endl;
        return false;
    }

    // Получаем указатель на данные музыки и её размер
    const void* data = LockResource(musicHandle);
    DWORD size = SizeofResource(NULL, musicResource);

    // Создаём объект музыки и загружаем его из памяти
    auto music = std::make_unique<sf::Music>();
    if (!music->openFromMemory(data, size)) {
        std::cerr << "Не удалось открыть музыкальный поток " << id << " из памяти" << std::endl;
        return false;
    }

    // Сохраняем музыкальный поток в хранилище
    musicStreams[id] = std::move(music);
    return true;
}

// Возвращает ссылку на шрифт по указанному ID
sf::Font& ResourceManager::getFont(const std::string& id) {
    auto it = fonts.find(id);
    if (it == fonts.end()) {
        std::cerr << "Шрифт " << id << " не найден" << std::endl;
        static sf::Font emptyFont;  // Статический пустой шрифт на случай ошибки
        return emptyFont;
    }
    return it->second;
}

// Возвращает ссылку на звуковой буфер по указанному ID
sf::SoundBuffer& ResourceManager::getSoundBuffer(const std::string& id) {
    auto it = buffers.find(id);
    if (it == buffers.end()) {
        std::cerr << "Звуковой буфер " << id << " не найден" << std::endl;
        static sf::SoundBuffer emptyBuffer;
        return emptyBuffer;
    }
    return it->second;
}

// Возвращает ссылку на текстуру по указанному ID
sf::Texture& ResourceManager::getTexture(const std::string& id) {
    auto it = textures.find(id);
    if (it == textures.end()) {
        std::cerr << "Текстура " << id << " не найдена" << std::endl;
        static sf::Texture emptyTexture;
        return emptyTexture;
    }
    return it->second;
}

// Возвращает копию изображения из текстуры по указанному ID
sf::Image ResourceManager::getImage(const std::string& id) {
    auto it = textures.find(id);
    if (it != textures.end()) {
        return it->second.copyToImage();  // Копируем текстуру в изображение
    }
    std::cerr << "Текстура для изображения " << id << " не найдена" << std::endl;
    return sf::Image();
}

// Возвращает ссылку на музыкальный поток по указанному ID
sf::Music& ResourceManager::getMusic(const std::string& id) {
    auto it = musicStreams.find(id);
    if (it == musicStreams.end()) {
        std::cerr << "Музыкальный поток " << id << " не найден" << std::endl;
        static sf::Music emptyMusic;
        return emptyMusic;
    }
    return *(it->second);  // Разыменовываем уникальный указатель, чтобы вернуть ссылку
}

Кастомный класс Button для интерфейса

Интерфейс — важная часть любой игры. В этой главе мы реализуем гибкий класс Button, полностью совместимый с SFML 2.x и современными возможностями C++20. Он предоставляет визуальные эффекты нажатия, возможность настройки цветов, шрифтов и размеров, а также безопасную обработку кликов.

Возможности данного класса

Поддержка нажатия с визуальной анимацией.

Гибкая настройка цветов: фона, обводки, текста.

Обработка клика через sf::Vector2f (позиция мыши).

Использование concepts из C++20 для безопасных шаблонов.

Центрирование текста по кнопке.

Поддержка перемещения и сравнения (<=>).

Button.h

#pragma once

#include <SFML/Graphics.hpp>
#include <string>
#include <concepts>

// Класс кнопки для SFML. Наследуется от sf::Drawable 
// и sf::Transformable для отрисовки и трансформаций.
class Button : public sf::Drawable, public sf::Transformable {

public:
    // Конструктор кнопки с полным набором параметров
    Button(std::wstring text, sf::Vector2f position, sf::Font& font,
        sf::Color buttonColor, sf::Color pressedColor,
        sf::Color textColor, sf::Color pressedTextColor,
        float width, float height, unsigned int fontSize,
        sf::Color outlineColor, float outlineThickness);

    // Конструкторы и операторы копирования/перемещения
    Button(const Button&) = default;
    Button& operator=(const Button&) = default;
    Button(Button&&) noexcept;
    Button& operator=(Button&&) noexcept;

    // Отрисовка кнопки на экране
    void draw(sf::RenderTarget& target, sf::RenderStates states) const override;

    // Проверка, был ли клик по кнопке
    [[nodiscard]] bool isClicked(sf::Vector2f mousePos) const noexcept;

    // Получение глобальных границ кнопки
    [[nodiscard]] sf::FloatRect getGlobalBounds() const noexcept;

    // Установка текста кнопки
    void setText(std::wstring text) noexcept;

    // Анимация при нажатии
    void pressAnimation() noexcept;

    // Анимация при отпускании
    void releaseAnimation() noexcept;

    // Установка цвета кнопки (с использованием concepts C++20)
    template<typename T> requires std::same_as<T, sf::Color>
    void setButtonColor(T color) noexcept;

    // Остальные настройки кнопки
    void setPressedColor(sf::Color color) noexcept;
    void setTextColor(sf::Color color) noexcept;
    void setPressedTextColor(sf::Color color) noexcept;
    void setSize(float width, float height) noexcept;
    void setFontSize(unsigned int size) noexcept;
    void setBackgroundTransparency(unsigned int alpha) noexcept;
    void setOutlineColor(sf::Color color) noexcept;
    void setOutlineThickness(float thickness) noexcept;

    // Трёхстороннее сравнение (spaceship operator)
    auto operator<=>(const Button& other) const = default;

private:
    // Прямоугольная форма кнопки и текст
    sf::RectangleShape shape;
    sf::Text label;

    // Цвета: обычный, при нажатии, для текста и при нажатии текста
    sf::Color buttonColor;
    sf::Color pressedColor;
    sf::Color textColor;
    sf::Color pressedTextColor;

    // Оригинальные параметры: толщина границы и размер шрифта
    float originalOutlineThickness;
    unsigned int originalFontSize;

    // Обновление позиции текста по центру кнопки
    void updateTextPosition() noexcept;
};

Button.cpp

#include "Button.h"
#include <ranges>

// Конструктор с параметрами
Button::Button(std::wstring text, sf::Vector2f position, sf::Font& font,
    sf::Color buttonColor, sf::Color pressedColor, sf::Color textColor,
    sf::Color pressedTextColor, float width, float height, unsigned int fontSize,
    sf::Color outlineColor, float outlineThickness)
    : buttonColor{ buttonColor },
    pressedColor{ pressedColor },
    textColor{ textColor },
    pressedTextColor{ pressedTextColor },
    originalOutlineThickness{ outlineThickness },
    originalFontSize{ fontSize }
{
    shape.setSize(sf::Vector2f{ width, height });
    shape.setFillColor(buttonColor);
    shape.setOutlineColor(outlineColor);
    shape.setOutlineThickness(outlineThickness);
    shape.setPosition(position);

    label.setFont(font);
    label.setString(std::move(text));
    label.setCharacterSize(fontSize);
    label.setFillColor(textColor);

    updateTextPosition();
}

// Центрирует текст по центру кнопки
void Button::updateTextPosition() noexcept {
    const auto textBounds = label.getLocalBounds();
    label.setOrigin({
        textBounds.left + textBounds.width / 2.0f,
        textBounds.top + textBounds.height / 2.0f
        });

    const auto shapePos = shape.getPosition();
    const auto shapeSize = shape.getSize();
    label.setPosition({
        shapePos.x + shapeSize.x / 2.0f,
        shapePos.y + shapeSize.y / 2.0f
        });
}

// Проверка попадания курсора мыши в границы кнопки
[[nodiscard]] bool Button::isClicked(sf::Vector2f mousePos) const noexcept {
    return shape.getGlobalBounds().contains(mousePos);
}

// Устанавливает новый текст
void Button::setText(std::wstring text) noexcept {
    label.setString(std::move(text));
    updateTextPosition();
}

// Визуальная анимация при нажатии на кнопку
void Button::pressAnimation() noexcept {
    shape.setFillColor(pressedColor);
    label.setFillColor(pressedTextColor);
    shape.setOutlineThickness(1.0f); // уменьшаем толщину обводки
    label.setCharacterSize(originalFontSize - 2); // уменьшаем размер текста
    updateTextPosition();
}

// Визуальная анимация при отпускании кнопки
void Button::releaseAnimation() noexcept {
    shape.setFillColor(buttonColor);
    label.setFillColor(textColor);
    shape.setOutlineThickness(originalOutlineThickness);
    label.setCharacterSize(originalFontSize);
    updateTextPosition();
}

// Установка цвета кнопки (через шаблон с concept)
template<typename T>
    requires std::same_as<T, sf::Color>
void Button::setButtonColor(T color) noexcept {
    this->buttonColor = color;
    shape.setFillColor(color);
}

// Установка цвета при нажатии
void Button::setPressedColor(sf::Color color) noexcept {
    this->pressedColor = color;
}

// Установка цвета текста
void Button::setTextColor(sf::Color color) noexcept {
    this->textColor = color;
    label.setFillColor(color);
}

// Установка цвета текста при нажатии
void Button::setPressedTextColor(sf::Color color) noexcept {
    this->pressedTextColor = color;
}

// Изменение размера кнопки
void Button::setSize(float width, float height) noexcept {
    shape.setSize({ width, height });
    updateTextPosition();
}

// Изменение размера шрифта
void Button::setFontSize(unsigned int size) noexcept {
    originalFontSize = size;
    label.setCharacterSize(size);
    updateTextPosition();
}

// Установка прозрачности фона кнопки
void Button::setBackgroundTransparency(unsigned int alpha) noexcept {
    buttonColor.a = static_cast<std::uint8_t>(std::clamp(alpha, 0u, 255u));
    shape.setFillColor(buttonColor);
}

// Установка цвета обводки
void Button::setOutlineColor(sf::Color color) noexcept {
    shape.setOutlineColor(color);
}

// Установка толщины обводки
void Button::setOutlineThickness(float thickness) noexcept {
    originalOutlineThickness = thickness;
    shape.setOutlineThickness(thickness);
}

// Отрисовка кнопки и текста
void Button::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    states.transform.combine(getTransform());
    target.draw(shape, states);
    target.draw(label, states);
}

// Получение границ кнопки (для коллизий/кликов)
[[nodiscard]] sf::FloatRect Button::getGlobalBounds() const noexcept {
    return shape.getGlobalBounds();
}

// Конструктор перемещения
Button::Button(Button&& other) noexcept = default;

// Оператор перемещения
Button& Button::operator=(Button&& other) noexcept = default;

Анимированный разноцветный текст, класс ColorfulText

В этом разделе блога я хочу показать вам, как создать красивый, динамически меняющийся текст с цветной анимацией на библиотеке SFML. Такой текст отлично подходит для заставок, титулов, экранов загрузки или игровых меню. Мы создадим собственный класс ColorfulText, где каждая буква будет представлять собой отдельный объект sf::Text, меняющий цвет через определённый интервал времени.

Возможности данного класса

- отображает строку текста;

- окрашивает каждую букву в случайный цвет;

- периодически обновляет цвета;

- поддерживает позиционирование с центрированием.

ColorfulText.h

#pragma once

#include <SFML/Graphics.hpp>
#include <vector>
#include <string>
#include <random>
#include <memory>

// Класс ColorfulText — отображает анимированный разноцветный текст
class ColorfulText {
public:
    // Конструктор
    ColorfulText(const std::string& fontId, std::wstring_view text, unsigned int charSize,
        const sf::Vector2f& position, const sf::RenderWindow& window,
        bool centerHorizontally = false, bool centerVertically = false);

    // Обновление цвета текста (вызывается в цикле игры)
    void update(float deltaTime);

    // Отрисовка текста на экране
    void draw(sf::RenderTarget& target, sf::RenderStates states = {}) const;

    // Установка новой позиции текста с возможностью центрирования
    void setPosition(const sf::Vector2f& position,
        bool centerHorizontally = false,
        bool centerVertically = false);

private:
    // Обновление цветов букв на случайные
    void updateColors();

    std::shared_ptr<sf::Font> font;       // Шрифт
    std::vector<sf::Text> letters;        // Вектор отдельных букв (sf::Text)
    float colorTimer;                     // Таймер для смены цвета
    static constexpr float COLOR_CHANGE_INTERVAL = 0.5f; // Интервал смены цвета
};

Вместо одного объекта sf::Text, как обычно, мы создаём вектор letters, в котором каждая буква строки является отдельным объектом sf::Text. Это даёт нам гибкость при анимации — можно изменять цвет каждой буквы по отдельности.

ColorfulText.cpp

#include "ColorfulText.h"
#include "ResourceManager.h"
#include <algorithm>
#include <random>

// Конструктор
ColorfulText::ColorfulText(const std::string& fontId, std::wstring_view text, unsigned int charSize,
    const sf::Vector2f& position, const sf::RenderWindow& window,
    bool centerHorizontally, bool centerVertically)
    : colorTimer(0.0f) {

    // Получаем ссылку на синглтон ResourceManager
    ResourceManager& rm = ResourceManager::getInstance();

    // Загружаем шрифт
    font = std::make_shared<sf::Font>(rm.getFont(fontId));

    // Проверяем, загрузился ли шрифт
    if (font->getInfo().family.empty()) {
        throw std::runtime_error("Не удалось загрузить шрифт с ID: " + std::string(fontId) + " из ResourceManager");
    }

    // Вычисляем общую ширину текста для центрирования
    float totalWidth = text.size() * charSize * 0.8f;
    float xPos = position.x;
    float yPos = position.y;

    if (centerHorizontally) {
        xPos = (window.getSize().x - totalWidth) / 2.0f;
    }
    if (centerVertically) {
        yPos = (window.getSize().y - charSize) / 2.0f;
    }

    // Создаем отдельные буквы и задаем им позицию и цвет
    letters.reserve(text.size());
    for (size_t i = 0; i < text.size(); ++i) {
        sf::Text letter;
        letter.setFont(*font);
        letter.setString(text[i]); // Каждая буква отдельно
        letter.setCharacterSize(charSize);
        letter.setFillColor(sf::Color::Magenta); // Начальный цвет
        letter.setPosition(xPos + i * charSize * 0.8f, yPos);
        letters.push_back(letter);
    }
}

// Обновление — вызывается каждый кадр, меняет цвет по таймеру
void ColorfulText::update(float deltaTime) {
    colorTimer += deltaTime;
    if (colorTimer >= COLOR_CHANGE_INTERVAL) {
        colorTimer = 0.0f;
        updateColors();
    }
}

// Функция случайной смены цвета каждой буквы
void ColorfulText::updateColors() {
    static std::random_device rd;
    static std::mt19937 gen(rd());
    static std::uniform_int_distribution<int> dis(0, 255);

    for (auto& letter : letters) {
        letter.setFillColor(sf::Color(
            static_cast<sf::Uint8>(dis(gen)),  // R
            static_cast<sf::Uint8>(dis(gen)),  // G
            static_cast<sf::Uint8>(dis(gen))   // B
        ));
    }
}

// Отрисовка всех букв текста
void ColorfulText::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    for (const auto& letter : letters) {
        target.draw(letter, states);
    }
}

// Установка новой позиции текста с опциональным центрированием
void ColorfulText::setPosition(const sf::Vector2f& position, bool centerHorizontally, bool centerVertically) {
    float totalWidth = letters.size() * letters[0].getCharacterSize() * 0.8f;
    float xPos = position.x;
    float yPos = position.y;

    if (centerHorizontally) {
        xPos = position.x - totalWidth / 2.0f;
    }
    if (centerVertically) {
        yPos = position.y - letters[0].getCharacterSize() / 2.0f;
    }

    // Обновляем позицию каждой буквы
    for (size_t i = 0; i < letters.size(); ++i) {
        letters[i].setPosition(xPos + i * letters[0].getCharacterSize() * 0.8f, yPos);
    }
}

Плавный переход между экранами в игре, класс Transition

Переходы между игровыми экранами — важная часть UX. Они делают игру визуально цельной и приятной. В этом разделе мы реализуем двухфазный эффект затемнения и осветления — популярный способ перехода между состояниями игры с помощью чёрного оверлея.

Возможности данного класса:

затухание экрана до чёрного (fade-out),
смену состояния игры (например, меню → игра),
проявление нового состояния (fade-in).

Transition.h

#pragma once

#include <SFML/Graphics.hpp>
#include "GameState.h"

class Transition : public sf::Drawable, public sf::Transformable {
public:
    Transition(sf::RenderWindow& window); // Конструктор с окном для динамического размера
    void startTransition(GameState newState);
    bool update(GameState& currentState, float deltaTime); // Добавляем deltaTime

private:
    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;

    sf::RectangleShape overlay;
    sf::RenderWindow& window; // Ссылка на окно для получения размера
    GameState targetState;
    float alpha; // Используем float для плавности
    bool transitioning;
    bool fadingIn; // Флаг для фазы fade-in
    float transitionDuration; // Длительность одной фазы
};

Transition.cpp

#include "Transition.h"

// Конструктор: инициализирует переход с заданным окном отрисовки
Transition::Transition(sf::RenderWindow& window)
    : window(window), alpha(255.f), transitioning(false), fadingIn(false), transitionDuration(0.5f) {

    // Устанавливаем размер затемняющего прямоугольника равным размеру окна
    overlay.setSize(sf::Vector2f(static_cast<float>(window.getSize().x),
        static_cast<float>(window.getSize().y)));

    // Цвет прямоугольника — чёрный с максимальной непрозрачностью (начальное состояние — экран полностью закрыт)
    overlay.setFillColor(sf::Color(0, 0, 0, static_cast<sf::Uint8>(alpha)));
}

// Запускает переход к новому состоянию игры (например, из меню в игру)
void Transition::startTransition(GameState newState) {
    transitioning = true;   // Начинаем переход
    fadingIn = false;       // Сначала будет фейд-аут (затемнение)
    targetState = newState; // Сохраняем целевое состояние игры
    alpha = 255.f;          // Сбрасываем прозрачность

    // Обновляем цвет оверлея, чтобы он был полностью непрозрачным
    overlay.setFillColor(sf::Color(0, 0, 0, static_cast<sf::Uint8>(alpha)));
}

// Обновляет состояние перехода (анимация затухания / появления)
// Возвращает true, если переход всё ещё активен
bool Transition::update(GameState& currentState, float deltaTime) {
    if (transitioning) {
        if (!fadingIn) {
            // Фаза затухания (экран темнеет)
            alpha -= (255.f / transitionDuration) * deltaTime;
            if (alpha <= 0.f) {
                alpha = 0.f;
                fadingIn = true;           // Переходим к фазе проявления
                currentState = targetState; // Меняем текущее состояние игры
            }
        }
        else {
            // Фаза проявления (экран светлеет)
            alpha += (255.f / transitionDuration) * deltaTime;
            if (alpha >= 255.f) {
                alpha = 255.f;
                transitioning = false;     // Переход завершён
            }
        }

        // Обновляем прозрачность оверлея
        // Используется 255.f - alpha, чтобы получить эффект "появления" после затемнения
        overlay.setFillColor(sf::Color(0, 0, 0, static_cast<sf::Uint8>(255.f - alpha)));

        return true; // Переход всё ещё активен
    }
    return false; // Переход завершён
}

// Отрисовывает оверлей (черный прямоугольник) поверх текущего содержимого окна
void Transition::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    if (transitioning) {
        target.draw(overlay, states); // Рисуем затемняющий слой, если переход активен
    }
}

Реализация игры “Пятнашки” в классе FifteenPuzzle, который наследуется от sf::Drawable для отрисовки.

FifteenPuzzle.h

#pragma once

#include <SFML/Graphics.hpp>
#include <vector>
#include <memory>
#include <string>

// Класс, реализующий игру "Пятнашки", наследуется от sf::Drawable для отрисовки
class FifteenPuzzle : public sf::Drawable {
public:
    // Константы по умолчанию для размера плитки и сетки
    static constexpr int DEFAULT_TILE_SIZE = 100;
    static constexpr int DEFAULT_GRID_SIZE = 4;

    // Конструктор с параметрами размера плитки и сетки
    explicit FifteenPuzzle(int tileSize = DEFAULT_TILE_SIZE,
        int gridSize = DEFAULT_GRID_SIZE);
    // Деструктор по умолчанию
    ~FifteenPuzzle() = default;

    // Запрет копирования для предотвращения дублирования ресурсов
    FifteenPuzzle(const FifteenPuzzle&) = delete;
    FifteenPuzzle& operator=(const FifteenPuzzle&) = delete;

    // Разрешено перемещение для поддержки семантики перемещения
    FifteenPuzzle(FifteenPuzzle&&) = default;
    FifteenPuzzle& operator=(FifteenPuzzle&&) = default;

    // Установка позиции пазла на экране
    void setPosition(float x, float y);
    // Получение текущей позиции пазла
    sf::Vector2f getPosition() const;
    // Получение границ пазла (для обработки событий)
    sf::FloatRect getBounds() const;

    // Обработка событий (например, кликов мыши)
    void handleEvent(const sf::Event& event, const sf::RenderWindow& window);
    // Обновление состояния игры (заглушка для возможных анимаций)
    void update();
    // Проверка, решён ли пазл
    bool isSolved() const;
    // Перезапуск игры (перемешивание плиток)
    void restart();

private:
    const int m_tileSize; // Размер одной плитки (в пикселях)
    const int m_gridSize; // Размер сетки (например, 4x4)
    std::vector<std::vector<int>> m_board; // Двумерный массив, представляющий игровое поле
    std::shared_ptr<sf::Font> m_font; // Шрифт для отображения номеров плиток
    int m_emptyX, m_emptyY; // Координаты пустой плитки
    sf::Vector2f m_position; // Позиция пазла на экране
    bool m_isSolved; // Флаг, указывающий, решён ли пазл

    // Перемешивание плиток для создания новой игры
    void shuffleBoard();
    // Проверка, можно ли переместить плитку на указанные координаты
    bool canMove(int x, int y) const;
    // Перемещение плитки на пустое место
    void moveTile(int x, int y);
    // Проверка, является ли текущая конфигурация решаемой
    bool isSolvable(const std::vector<int>& numbers) const;
    // Метод отрисовки пазла (переопределение sf::Drawable)
    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};

Основные моменты:

Константы: DEFAULT_TILE_SIZE (100 пикселей) и DEFAULT_GRID_SIZE (4x4) задают размер плиток и сетки по умолчанию.
Запрет копирования: Конструктор копирования и оператор присваивания отключены, чтобы избежать дублирования ресурсов.
Поддержка перемещения: Конструктор перемещения и оператор присваивания включены для эффективного управления ресурсами.
Основные методы: Методы вроде handleEvent, update, isSolved и restart управляют игровым процессом, а draw отвечает за отрисовку.

FifteenPuzzle.cpp

#include "FifteenPuzzle.h"
#include <numeric>
#include <random>
#include <stdexcept>
#include "ResourceManager.h"

// Конструктор: инициализация игры с заданными параметрами
FifteenPuzzle::FifteenPuzzle(int tileSize, int gridSize)
    : m_tileSize(tileSize)
    , m_gridSize(gridSize)
    , m_board(gridSize, std::vector<int>(gridSize, 0))
    , m_font(std::make_shared<sf::Font>())
    , m_emptyX(0)
    , m_emptyY(0)
    , m_position(0.f, 0.f)
    , m_isSolved(false)
{
    // Получение экземпляра менеджера ресурсов (паттерн Singleton)
    ResourceManager& rm = ResourceManager::getInstance();
    // Загрузка шрифта из менеджера ресурсов
    *m_font = rm.getFont("font");

    // Проверка успешной загрузки шрифта
    if (m_font->getInfo().family.empty()) {
        throw std::runtime_error("Не удалось загрузить шрифт 'font' из ResourceManager");
    }

    // Инициализация игрового поля
    shuffleBoard();
}

// Установка позиции пазла на экране
void FifteenPuzzle::setPosition(float x, float y) {
    m_position.x = x;
    m_position.y = y;
}

// Получение текущей позиции пазла
sf::Vector2f FifteenPuzzle::getPosition() const {
    return m_position;
}

// Получение прямоугольника, ограничивающего пазл
sf::FloatRect FifteenPuzzle::getBounds() const {
    return sf::FloatRect(m_position.x, m_position.y,
        m_tileSize * m_gridSize,
        m_tileSize * m_gridSize);
}

// Проверка, является ли текущая конфигурация пазла решаемой
bool FifteenPuzzle::isSolvable(const std::vector<int>& numbers) const {
    // Подсчёт инверсий в последовательности чисел
    int inversions = 0;
    for (size_t i = 0; i < numbers.size(); ++i) {
        for (size_t j = i + 1; j < numbers.size(); ++j) {
            if (numbers[i] && numbers[j] && numbers[i] > numbers[j]) {
                ++inversions;
            }
        }
    }

    // Для нечётного размера сетки: чётное число инверсий => решаемо
    if (m_gridSize % 2 == 1) {
        return inversions % 2 == 0;
    }
    // Для чётного размера сетки: учитываем позицию пустой плитки
    else {
        int emptyRowFromBottom = m_gridSize - m_emptyY;
        if (emptyRowFromBottom % 2 == 0) {
            return inversions % 2 == 1;
        }
        else {
            return inversions % 2 == 0;
        }
    }
}

// Перемешивание игрового поля для новой игры
void FifteenPuzzle::shuffleBoard() {
    // Создание последовательности чисел от 1 до gridSize*gridSize-1, с 0 в конце
    std::vector<int> numbers(m_gridSize * m_gridSize);
    std::iota(numbers.begin(), numbers.end(), 1);
    numbers.back() = 0;

    // Инициализация генератора случайных чисел
    std::random_device rd;
    std::mt19937 g(rd());

    // Перемешивание до получения решаемой конфигурации
    do {
        std::shuffle(numbers.begin(), numbers.end(), g);

        // Заполнение игрового поля
        for (int i = 0; i < m_gridSize; ++i) {
            for (int j = 0; j < m_gridSize; ++j) {
                m_board[i][j] = numbers[i * m_gridSize + j];
                if (m_board[i][j] == 0) {
                    m_emptyX = j;
                    m_emptyY = i;
                }
            }
        }
    } while (!isSolvable(numbers));

    // Сброс флага решения
    m_isSolved = false;
}

// Проверка, можно ли переместить плитку на указанные координаты
bool FifteenPuzzle::canMove(int x, int y) const {
    // Плитка должна быть соседней с пустой и находиться в пределах поля
    return (std::abs(x - m_emptyX) + std::abs(y - m_emptyY) == 1) &&
        (x >= 0 && x < m_gridSize && y >= 0 && y < m_gridSize);
}

// Перемещение плитки на пустое место
void FifteenPuzzle::moveTile(int x, int y) {
    if (canMove(x, y)) {
        // Обмен плитки с пустым местом
        std::swap(m_board[m_emptyY][m_emptyX], m_board[y][x]);
        m_emptyX = x;
        m_emptyY = y;
        // Проверка, решён ли пазл после хода
        m_isSolved = isSolved();
    }
}

// Проверка, решён ли пазл
bool FifteenPuzzle::isSolved() const {
    int expected = 1;
    for (int i = 0; i < m_gridSize; ++i) {
        for (int j = 0; j < m_gridSize; ++j) {
            if (i == m_gridSize - 1 && j == m_gridSize - 1) {
                return m_board[i][j] == 0;
            }
            if (m_board[i][j] != expected++) {
                return false;
            }
        }
    }
    return true;
}

// Обработка событий (например, кликов мыши)
void FifteenPuzzle::handleEvent(const sf::Event& event, const sf::RenderWindow& window) {
    if (event.type == sf::Event::MouseButtonPressed &&
        event.mouseButton.button == sf::Mouse::Left) {
        // Преобразование координат мыши в мировые координаты
        sf::Vector2f mousePos = window.mapPixelToCoords(
            sf::Vector2i(event.mouseButton.x, event.mouseButton.y));

        // Проверка, находится ли клик внутри пазла
        if (getBounds().contains(mousePos)) {
            // Вычисление координат плитки
            int x = static_cast<int>((mousePos.x - m_position.x) / m_tileSize);
            int y = static_cast<int>((mousePos.y - m_position.y) / m_tileSize);
            moveTile(x, y);
        }
    }
}

// Обновление состояния игры (пока не используется)
void FifteenPuzzle::update() {
    // Здесь можно добавить анимации или другие обновления
}

// Отрисовка пазла
void FifteenPuzzle::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    // Смещение координат для учёта позиции пазла
    states.transform.translate(m_position);

    // Отрисовка каждой плитки
    for (int i = 0; i < m_gridSize; ++i) {
        for (int j = 0; j < m_gridSize; ++j) {
            if (m_board[i][j] != 0) {
                // Отри Clay плитки
                sf::RectangleShape rect(sf::Vector2f(m_tileSize - 2, m_tileSize - 2));
                rect.setPosition(j * m_tileSize + 1, i * m_tileSize + 1);
                rect.setFillColor(sf::Color(64, 224, 208)); // Бирюзовый цвет
                target.draw(rect, states);

                // Отрисовка номера плитки
                if (m_font) {
                    sf::Text text;
                    text.setFont(*m_font);
                    text.setString(std::to_string(m_board[i][j]));
                    text.setCharacterSize(m_tileSize / 2);
                    text.setFillColor(sf::Color::Black);

                    // Центрирование текста
                    auto textRect = text.getLocalBounds();
                    text.setOrigin(textRect.width / 2.0f, textRect.height / 2.0f);
                    text.setPosition(j * m_tileSize + m_tileSize / 2.0f,
                        i * m_tileSize + m_tileSize / 2.5f);
                    target.draw(text, states);
                }
            }
        }
    }
}

// Перезапуск игры (перемешивание плиток)
void FifteenPuzzle::restart() {
    shuffleBoard();
}

Инициализация

В конструкторе создаётся игровое поле (m_board) как двумерный вектор размером gridSize x gridSize. Шрифт для номеров плиток загружается через ResourceManager (паттерн Singleton). Затем вызывается shuffleBoard() для создания начальной конфигурации.

Перемешивание

Метод shuffleBoard() генерирует случайную последовательность чисел от 1 до gridSize*gridSize-1 с 0 в конце (пустая плитка). Используется std::shuffle с генератором случайных чисел std::mt19937. Важно, что метод isSolvable проверяет, является ли конфигурация решаемой, подсчитывая инверсии и учитывая позицию пустой плитки.

Обработка кликов

Метод handleEvent обрабатывает клики мыши. Координаты клика преобразуются в индексы плитки, и если плитка соседствует с пустой, вызывается moveTile для её перемещения.

Отрисовка

Метод draw отрисовывает каждую плитку как прямоугольник (sf::RectangleShape) бирюзового цвета с номером, отцентрированным с помощью sf::Text. Пустая плитка (0) не отрисовывается.

Проверка решения

Метод isSolved проверяет, расположены ли плитки в порядке от 1 до 15 с пустой плиткой в правом нижнем углу.

Создаём главное меню для игры "Пятнашки", класс MainMenu

Класс MainMenu отвечает за отображение и обработку главного меню игры. Оно включает заголовок "Пятнашки" и пять кнопок: "Играть", "Правила", "Музыка: Вкл/Выкл", "Рестарт" и "Выход". Меню использует SFML для отрисовки, поддерживает анимации кнопок и фоновую музыку. Код организован так, чтобы быть понятным и легко расширяемым.

Класс MainMenu наследуется от базового класса Screen, что позволяет интегрировать его в систему управления состояниями игры.

MainMenu.h

#pragma once  

#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include "Button.h"
#include "GameState.h"
#include "Transition.h"
#include "ColorfulText.h"
#include <memory>
#include "GameScreen.h"
#include "Screen.h"

class MainMenu : public Screen {
private:
    // Элементы интерфейса главного меню — все они уникальные указатели для удобного управления памятью
    std::unique_ptr<ColorfulText> titleText;   // Заголовок меню с цветной анимацией
    std::unique_ptr<Button> playButton;        // Кнопка "Играть"
    std::unique_ptr<Button> rulesButton;       // Кнопка "Правила"
    std::unique_ptr<Button> musicButton;       // Кнопка включения/выключения музыки
    std::unique_ptr<Button> restartButton;     // Кнопка "Перезапустить" (может использоваться в других состояниях)
    std::unique_ptr<Button> exitButton;        // Кнопка "Выход"

    sf::Music* music;            // Указатель на объект музыки (не владеем им, просто ссылка)
    GameScreen& gameScreen;      // Ссылка на игровой экран для перехода к игре
    bool isMusicOn;              // Флаг: включена ли музыка

    // Метод для инициализации элементов интерфейса меню
    void initialize() override;

public:
    // Конструктор: принимает окно отрисовки, текущее состояние игры, переход и игровой экран
    MainMenu(sf::RenderWindow& window,
        GameState& state,
        Transition& transition,
        GameScreen& gameScreen);

    // Обработка событий (нажатия мыши, клавиш и т.д.)
    void handleEvent(const sf::Event& event) override;

    // Обновление логики меню (анимация, проверка нажатий и т.д.)
    void update(float deltaTime) override;

    // Отрисовка всех элементов меню
    void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};

Основные моменты:

Поля: Указатели std::unique_ptr на заголовок (ColorfulText) и кнопки (Button) обеспечивают автоматическое управление памятью. Переменная isMusicOn отслеживает состояние музыки.
Зависимости: Класс использует sf::Music для фоновой музыки, GameScreen для перезапуска игры и Transition для переключения между экранами.
Методы: initialize настраивает элементы меню, handleEvent обрабатывает клики, update обновляет анимации, а draw отрисовывает меню.

MainMenu.cpp

#include "MainMenu.h"
#include <stdexcept>

// Константы для расположения и размеров элементов интерфейса
constexpr float BUTTON_WIDTH = 500.0f;       // Ширина кнопок
constexpr float BUTTON_HEIGHT = 50.0f;       // Высота кнопок
constexpr float SPACING = 30.0f;             // Расстояние между кнопками
constexpr float TITLE_Y_POS = 50.0f;         // Вертикальная позиция заголовка

// Конструктор: инициализирует главное меню и вызывает метод initialize()
MainMenu::MainMenu(sf::RenderWindow& window, GameState& state, Transition& transition, GameScreen& gameScreen)
    : Screen(window, state, transition), gameScreen(gameScreen), isMusicOn(true) {
    initialize();  // Инициализация всех элементов интерфейса
}

// Метод инициализации главного меню
void MainMenu::initialize() {
    ResourceManager& rm = ResourceManager::getInstance();

    // Получаем шрифты из менеджера ресурсов
    sf::Font& font = rm.getFont("font");
    sf::Font& font2 = rm.getFont("font1");

    // Проверяем, успешно ли загружены шрифты
    if (font.getInfo().family.empty() || font2.getInfo().family.empty()) {
        throw std::runtime_error("Не удалось получить шрифты из ResourceManager");
    }

    // Устанавливаем фоновое изображение
    setupBackground("background");

    // Создаем анимированный цветной заголовок "Пятнашки"
    titleText = std::make_unique<ColorfulText>(
        "font1",
        L"Пятнашки",
        100,
        sf::Vector2f(0, TITLE_Y_POS),
        window,
        true,
        false);

    // Рассчитываем начальную Y-координату для размещения кнопок по центру экрана
    float startY = window.getSize().y / 2.0f - (5 * BUTTON_HEIGHT + 4 * SPACING) / 2.0f + 50.0f;
    float centerX = (window.getSize().x - BUTTON_WIDTH) / 2.0f;

    // Создаем все кнопки меню с заданными параметрами стиля и расположения

    playButton = std::make_unique<Button>(
        L"Играть",
        sf::Vector2f(centerX, startY),
        font,
        sf::Color(255, 192, 203, 150),
        sf::Color(255, 192, 203, 200),
        sf::Color::Blue,
        sf::Color(128, 128, 128),
        BUTTON_WIDTH,
        BUTTON_HEIGHT,
        30,
        sf::Color::Magenta,
        5.0f);

    rulesButton = std::make_unique<Button>(
        L"Правила",
        sf::Vector2f(centerX, startY + BUTTON_HEIGHT + SPACING),
        font,
        sf::Color(255, 192, 203, 150),
        sf::Color(255, 192, 203, 200),
        sf::Color::Blue,
        sf::Color(128, 128, 128),
        BUTTON_WIDTH,
        BUTTON_HEIGHT,
        30,
        sf::Color::Magenta,
        5.0f);

    musicButton = std::make_unique<Button>(
        L"Музыка: Вкл",
        sf::Vector2f(centerX, startY + 2 * (BUTTON_HEIGHT + SPACING)),
        font,
        sf::Color(255, 192, 203, 150),
        sf::Color(255, 192, 203, 200),
        sf::Color::Blue,
        sf::Color(128, 128, 128),
        BUTTON_WIDTH,
        BUTTON_HEIGHT,
        30,
        sf::Color::Magenta,
        5.0f);

    restartButton = std::make_unique<Button>(
        L"Рестарт",
        sf::Vector2f(centerX, startY + 3 * (BUTTON_HEIGHT + SPACING)),
        font,
        sf::Color(255, 192, 203, 150),
        sf::Color(255, 192, 203, 200),
        sf::Color::Blue,
        sf::Color(128, 128, 128),
        BUTTON_WIDTH,
        BUTTON_HEIGHT,
        30,
        sf::Color::Magenta,
        5.0f);

    exitButton = std::make_unique<Button>(
        L"Выход",
        sf::Vector2f(centerX, startY + 4 * (BUTTON_HEIGHT + SPACING)),
        font,
        sf::Color(255, 192, 203, 150),
        sf::Color(255, 192, 203, 200),
        sf::Color::Blue,
        sf::Color(128, 128, 128),
        BUTTON_WIDTH,
        BUTTON_HEIGHT,
        30,
        sf::Color::Magenta,
        5.0f);

    // Получаем ссылку на музыку из менеджера ресурсов
    music = &rm.getMusic("music");

    // Проверяем, что музыка загружена и готова к воспроизведению
    if (music->getStatus() == sf::Music::Stopped && music->getDuration() == sf::Time::Zero) {
        throw std::runtime_error("Музыкальный поток не инициализирован в ResourceManager");
    }

    // Настраиваем зацикленное воспроизведение и запускаем музыку
    music->setLoop(true);
    music->play();
}

// Обновляет логику меню — в данном случае только анимацию заголовка
void MainMenu::update(float deltaTime) {
    titleText->update(deltaTime);  // Анимация цвета заголовка
}

// Обрабатывает события от пользователя (например, нажатие мыши)
void MainMenu::handleEvent(const sf::Event& event) {
    // Получаем текущую позицию курсора
    sf::Vector2f mousePos(static_cast<float>(sf::Mouse::getPosition(window).x),
        static_cast<float>(sf::Mouse::getPosition(window).y));

    // Если произошло нажатие мыши
    if (event.type == sf::Event::MouseButtonPressed) {
        if (playButton->isClicked(mousePos)) playButton->pressAnimation();
        if (rulesButton->isClicked(mousePos)) rulesButton->pressAnimation();
        if (musicButton->isClicked(mousePos)) musicButton->pressAnimation();
        if (restartButton->isClicked(mousePos)) restartButton->pressAnimation();
        if (exitButton->isClicked(mousePos)) exitButton->pressAnimation();
    }

    // Если кнопка мыши отпущена
    if (event.type == sf::Event::MouseButtonReleased) {
        if (playButton->isClicked(mousePos)) {
            playButton->releaseAnimation();
            transition.startTransition(GameState::GAME);  // Переход к игре
        }
        if (rulesButton->isClicked(mousePos)) {
            rulesButton->releaseAnimation();
            transition.startTransition(GameState::RULES);  // Переход к правилам
        }
        if (musicButton->isClicked(mousePos)) {
            musicButton->releaseAnimation();
            isMusicOn = !isMusicOn;  // Переключаем состояние музыки
            musicButton->setText(isMusicOn ? L"Музыка: Вкл" : L"Музыка: Выкл");  // Обновляем текст кнопки
            if (isMusicOn && music->getStatus() != sf::Music::Playing) {
                music->play();  // Включаем музыку
            }
            else if (!isMusicOn) {
                music->stop();  // Выключаем музыку
            }
        }
        if (restartButton->isClicked(mousePos)) {
            restartButton->releaseAnimation();
            gameScreen.restartGame();  // Перезапускаем игру
            transition.startTransition(GameState::GAME);  // Переходим в игру
        }
        if (exitButton->isClicked(mousePos)) {
            exitButton->releaseAnimation();
            window.close();  // Закрываем окно приложения
        }
    }
}

// Отрисовывает всё содержимое главного меню
void MainMenu::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    // Если фоновая текстура установлена — рисуем её
    if (useTexture) {
        target.draw(backgroundSprite, states);
    }
    else {
        // Иначе рисуем однотонный фон (в данном случае голубой)
        sf::RectangleShape background(sf::Vector2f(
            static_cast<float>(window.getSize().x),
            static_cast<float>(window.getSize().y)));
        background.setFillColor(sf::Color::Cyan);
        target.draw(background, states);
    }

    // Отрисовываем заголовок
    titleText->draw(target, states);

    // Отрисовываем все кнопки
    target.draw(*playButton, states);
    target.draw(*rulesButton, states);
    target.draw(*musicButton, states);
    target.draw(*restartButton, states);
    target.draw(*exitButton, states);
}

Создание игрового окна, класс GameScreen

Игровое окно включает в себя:

отрисовку поля игры,
анимации и интерфейс,
таймер прохождения,
обработку событий,
и даже отображение сообщения о победе.

Класс GameScreen — это наследник базового класса Screen, который управляет визуальными и логическими элементами экрана. Он включает следующие компоненты:

FifteenPuzzle — основная игровая логика и поле;
Button — кнопка возврата в меню;
ColorfulText — анимированный заголовок "Пятнашки";
sf::Text, sf::RectangleShape — для уведомлений и таймера;
sf::Clock — измерение времени прохождения;
флаг isGameStarted — определяет, запущена ли игра.

GameScreen.h

#pragma once


#include "Screen.h"           
#include "FifteenPuzzle.h"    
#include "Button.h"           
#include "ColorfulText.h"     


class GameScreen : public Screen {
private:
    // Указатель на объект головоломки "Пятнашки"
    std::unique_ptr<FifteenPuzzle> puzzle;

    // Кнопка выхода в меню
    std::unique_ptr<Button> exitButton;

    // Цветной анимированный заголовок "Пятнашки"
    std::unique_ptr<ColorfulText> titleText;

    // Текстовое поле для отображения сообщений (например, победы)
    sf::Text text;

    // Прямоугольник-фон под текстовые уведомления
    sf::RectangleShape textBackground;

    // Текст таймера, показывающий время игры
    sf::Text timerText;

    // Фон под таймер
    sf::RectangleShape timerBackground;

    // Часы для измерения времени игры
    sf::Clock gameClock;

    // Флаг, указывающий, начал ли пользователь игру
    bool isGameStarted;

    // Метод инициализации элементов интерфейса
    void initialize() override;

public:
    /*
     Конструктор.
     Инициализирует игровой экран, связывает его с окном, состоянием и системой переходов.
     */
    GameScreen(sf::RenderWindow& window, GameState& state, Transition& transition);

    /*
     Обработка событий (нажатия клавиш, клики мыши и др.).
     */
    void handleEvent(const sf::Event& event) override;

    /*
      Отрисовка всех элементов экрана: головоломки, кнопок, текста и фона.
     */
    void draw(sf::RenderTarget& target, sf::RenderStates states) const override;

    /*
     Обновление состояния экрана (анимация заголовка, обновление таймера и т.д.).
     */
    void update(float deltaTime) override;

    /*
     Перезапуск игры: сброс позиций плиток, таймера, очистка сообщений.
     */
    void restartGame();
};

GameScreen.cpp

#include "GameScreen.h"
#include <iostream>
#include <string>

// Константа для позиции Y заголовка 
constexpr float TITLE_Y_POS = 15.0f;

/*
 Конструктор класса GameScreen.
 Инициализирует игровой экран, связывает его с окном и системой состояний.
 */
GameScreen::GameScreen(sf::RenderWindow& window, GameState& state, Transition& transition)
    : Screen(window, state, transition),
    puzzle(std::make_unique<FifteenPuzzle>(100, 4)), // Создаем головоломку 4x4 с размером плитки 100
    isGameStarted(false) { // Игра ещё не начата
    initialize(); // Вызываем метод инициализации графических элементов
}

/*
 Метод инициализации всех графических элементов интерфейса:
 - Кнопка выхода в меню
 - Текстовые поля: сообщение о победе, таймер
 - Заголовок игры
 */
void GameScreen::initialize() {
    ResourceManager& rm = ResourceManager::getInstance();
    sf::Font& font = rm.getFont("font");

    if (font.getInfo().family.empty()) {
        throw std::runtime_error("Не удалось загрузить шрифт 'font' из ResourceManager");
    }

    setupBackground("background1"); // Устанавливаем фоновое изображение

    // Создаем кнопку "меню" с заданными стилями и размерами
    exitButton = std::make_unique<Button>(
        std::wstring(L"м е н ю"),
        sf::Vector2f(445, 600),
        font,
        sf::Color(64, 224, 208, 255),
        sf::Color(64, 224, 208, 255),
        sf::Color::Black,
        sf::Color(128, 128, 128),
        395.0f,
        50.0f,
        30u,
        sf::Color::Black,
        4.0f
    );

    // Устанавливаем шрифт для текстового уведомления (например, победы)
    text.setFont(font);

    // Центрируем головоломку по горизонтали, вертикальная позиция — фиксированная
    puzzle->setPosition(
        (window.getSize().x - puzzle->getBounds().width) / 2.0f,
        150.0f
    );

    // Цветной анимированный заголовок "Пятнашки"
    titleText = std::make_unique<ColorfulText>("font1", L"Пятнашки", 100,
        sf::Vector2f(0, TITLE_Y_POS), window, true, false);

    // Фон под текстовые сообщения (полупрозрачный белый прямоугольник)
    textBackground.setFillColor(sf::Color(255, 255, 255, 200));

    // Настройка текста таймера
    timerText.setFont(font);
    timerText.setCharacterSize(45);
    timerText.setFillColor(sf::Color::Red);
    timerText.setPosition(
        puzzle->getBounds().left + puzzle->getBounds().width + 50.0f,
        puzzle->getBounds().top + 200.0f
    );

    // Подложка под таймер (с полупрозрачным фоном)
    timerBackground.setFillColor(sf::Color(255, 255, 255, 128));
    sf::FloatRect timerRect = timerText.getLocalBounds();
    timerBackground.setSize(sf::Vector2f(timerRect.width + 20.0f, timerRect.height + 40.0f));
    timerBackground.setPosition(
        timerText.getPosition().x - 10.0f,
        timerText.getPosition().y
    );
}

/*
 Обработка событий от пользователя:
 - Нажатие Esc
 - Клик мыши на кнопке выхода
 - Перемещение плиток
 - Начало игры
 - Перезапуск
 */
void GameScreen::handleEvent(const sf::Event& event) {
    // Выход в меню при нажатии Esc
    if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
        transition.startTransition(GameState::MENU);
    }

    // Обработка нажатия на кнопку "меню"
    if (event.type == sf::Event::MouseButtonPressed) {
        sf::Vector2f mousePos = window.mapPixelToCoords(sf::Mouse::getPosition(window));
        if (exitButton->isClicked(mousePos)) {
            exitButton->pressAnimation(); // Анимация нажатия
        }
    }

    // Обработка отпускания кнопки мыши
    if (event.type == sf::Event::MouseButtonReleased) {
        sf::Vector2f mousePos = window.mapPixelToCoords(sf::Mouse::getPosition(window));
        if (exitButton->isClicked(mousePos)) {
            exitButton->releaseAnimation(); // Анимация отпускания
            transition.startTransition(GameState::MENU); // Переход в меню
        }
    }

    // Старт игры при первом взаимодействии (нажатие клавиши или клик)
    if (!isGameStarted && (event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::KeyPressed)) {
        isGameStarted = true;
        gameClock.restart(); // Запускаем таймер
    }

    // Передаем событие головоломке (например, клик на плитку)
    puzzle->handleEvent(event, window);

    // Проверяем, решена ли головоломка
    if (puzzle->isSolved() && isGameStarted) {
        isGameStarted = false;

        // Получаем время прохождения
        sf::Time elapsed = gameClock.getElapsedTime();
        int minutes = static_cast<int>(elapsed.asSeconds()) / 60;
        int seconds = static_cast<int>(elapsed.asSeconds()) % 60;
        int milliseconds = static_cast<int>(elapsed.asMilliseconds()) % 1000;

        // Форматируем строку времени
        std::wstring timeString = std::wstring(L"Время решения: ") +
            (minutes < 10 ? L"0" : L"") + std::to_wstring(minutes) + L":" +
            (seconds < 10 ? L"0" : L"") + std::to_wstring(seconds) + L":" +
            (milliseconds < 100 ? L"0" : (milliseconds < 10 ? L"00" : L"")) + std::to_wstring(milliseconds);

        // Отображаем сообщение о победе
        text.setString(L"                   Победа!!!\n" +
            timeString + L"\n" +
            L"Нажмите Esc или кнопку меню!");
        text.setCharacterSize(50);
        text.setFillColor(sf::Color::Red);

        // Центрируем текст по окну
        sf::FloatRect textRect = text.getLocalBounds();
        text.setOrigin(textRect.left + textRect.width / 2.0f, textRect.top + textRect.height / 2.0f);
        text.setPosition(window.getSize().x / 2.0f, window.getSize().y / 2.0f);

        // Настраиваем фон под текст
        textBackground.setSize(sf::Vector2f(textRect.width + 40.0f, textRect.height + 40.0f));
        textBackground.setOrigin(textBackground.getSize().x / 2.0f, textBackground.getSize().y / 2.0f);
        textBackground.setPosition(window.getSize().x / 2.0f, window.getSize().y / 2.0f);

        // Скрываем таймер после победы
        timerText.setString(L"");
        timerBackground.setSize(sf::Vector2f(0, 0));
    }

    // Перезапуск игры при нажатии R
    if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::R) {
        restartGame();
    }
}

/*
 Отрисовка всех элементов экрана:
 - Фон
 - Головоломка
 - Сообщения (победа)
 - Таймер
 - Кнопки
 - Заголовок
 */
void GameScreen::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    target.clear(sf::Color::White); // Очищаем экран

    // Рисуем фон, если он есть
    if (useTexture) {
        target.draw(backgroundSprite, states);
    }

    target.draw(*puzzle, states);             // Рисуем головоломку
    target.draw(textBackground, states);      // Фон под текстом
    target.draw(text, states);                // Текст сообщений
    target.draw(timerBackground, states);     // Фон под таймером
    target.draw(timerText, states);           // Текст таймера
    target.draw(*exitButton, states);         // Кнопка выхода
    titleText->draw(target, states);          // Анимированный заголовок
}

/*
 Перезапуск игры:
 - Сброс плиток в случайное положение
 - Сброс таймера
 - Очистка текстовых сообщений
 - Восстановление таймера
 */
void GameScreen::restartGame() {
    puzzle->restart(); // Перемешиваем головоломку
    isGameStarted = false; // Сбрасываем флаг начала игры
    gameClock.restart(); // Сбрасываем таймер

    text.setString(L""); // Очищаем текст победы
    text.setCharacterSize(30); // Сбрасываем размер текста

    textBackground.setSize(sf::Vector2f(0, 0)); // Скрываем фон под текстом

    // Восстанавливаем начальное значение таймера
    timerText.setString(L"Время: 00:00:000");
    sf::FloatRect timerRect = timerText.getLocalBounds();
    timerBackground.setSize(sf::Vector2f(timerRect.width + 20.0f, timerRect.height + 40.0f));
    timerBackground.setPosition(
        timerText.getPosition().x - 10.0f,
        timerText.getPosition().y
    );
}

/*
 Обновление состояния экрана:
 - Анимация заголовка
 - Обновление таймера, если игра активна
 */
void GameScreen::update(float deltaTime) {
    titleText->update(deltaTime); // Обновляем анимацию цветного заголовка

    if (isGameStarted) {
        sf::Time elapsed = gameClock.getElapsedTime();
        int minutes = static_cast<int>(elapsed.asSeconds()) / 60;
        int seconds = static_cast<int>(elapsed.asSeconds()) % 60;
        int milliseconds = static_cast<int>(elapsed.asMilliseconds()) % 1000;

        // Форматируем строку времени
        std::wstring timerString = std::wstring(L"Время: ") +
            (minutes < 10 ? L"0" : L"") + std::to_wstring(minutes) + L":" +
            (seconds < 10 ? L"0" : L"") + std::to_wstring(seconds) + L":" +
            (milliseconds < 100 ? L"0" : (milliseconds < 10 ? L"00" : L"")) + std::to_wstring(milliseconds);
        timerText.setString(timerString);

        // Обновляем размер фона под таймер
        sf::FloatRect timerRect = timerText.getLocalBounds();
        timerBackground.setSize(sf::Vector2f(timerRect.width + 20.0f, timerRect.height + 20.0f));
        timerBackground.setPosition(
            timerText.getPosition().x - 10.0f,
            timerText.getPosition().y
        );
    }
}

Перечисление GameState

GameState.h

#pragma once

enum class GameState { MENU, GAME, RULES };

Это перечисление описывает три возможных состояния игры:

MENU – главное меню.
GAME – активный экран игры.
RULES – экран с правилами.

Оно используется для управления переходами между экранами и состояниями.

Окно "Правила игры", класс RulesScreen

Класс RulesScreen — это экран с правилами игры. Он помогает игроку быстро понять суть и цель головоломки перед началом игры.

Включает:

анимированный заголовок;
текст с пошаговыми правилами;
пример изображения правильно собранного поля;
кнопку возврата в главное меню.

RulesScreen.h

#pragma once

#include "Screen.h"

#include "Button.h"

#include "ColorfulText.h"

/*
 Класс RulesScreen представляет экран с правилами игры.
 Отображает описание правил игры "Пятнашки", содержит анимированный заголовок,
 изображение игрового поля и кнопку возврата в главное меню.
 */
class RulesScreen : public Screen {
private:
    // Анимированный цветной заголовок "Правила"
    std::unique_ptr<ColorfulText> titleText;

    // Текстовое поле для отображения правил игры
    sf::Text text;

    // Прямоугольник-фон под текст, чтобы он был лучше виден на фоне
    sf::RectangleShape textBackground;

    // Спрайт с изображением правильно собранного поля (пример)
    sf::Sprite numbersSprite;

    // Кнопка "Назад" для возврата в главное меню
    std::unique_ptr<Button> backButton;

    /**
     Инициализирует графические элементы экрана.
     Метод вызывается один раз при создании экрана.
     Настраивает: текст, фон, спрайт, кнопку и заголовок.
     */
    void initialize() override;

public:
    /**
     Конструктор экрана правил.
     window Ссылка на SFML окно
     state Ссылка на текущее состояние приложения
     transition Объект для управления переходами между экранами
     */
    RulesScreen(sf::RenderWindow& window, GameState& state, Transition& transition);

    /*
     Обрабатывает события пользователя (нажатия клавиш, клики мыши).
     event Обработанное событие SFML
     */
    void handleEvent(const sf::Event& event) override;

    /*
     Обновляет логику экрана (анимации, состояние кнопок и т.д.).
     deltaTime Время, прошедшее с последнего кадра (в секундах)
     */
    void update(float deltaTime) override;

    /*
     Отрисовывает все элементы экрана.
     target Цель отрисовки (обычно SFML окно)
     states Рендер-состояния (не используются по умолчанию)
     */
    void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};

RulesScreen.cpp

#include "RulesScreen.h"
#include <stdexcept>
#include <iostream>

// Константа для позиции Y заголовка (чтобы избежать magic numbers)
constexpr float TITLE_Y_POS = 15.0f;

/*
 Конструктор класса RulesScreen.
 Инициализирует экран правил, связывает его с окном и системой состояний.
 */
RulesScreen::RulesScreen(sf::RenderWindow& window, GameState& state, Transition& transition)
    : Screen(window, state, transition) {
    initialize(); // Вызываем метод инициализации графических элементов
}

/*
 Метод инициализации всех графических элементов интерфейса:
 - Заголовок
 - Текст с правилами игры
 - Фон под текст
 - Изображение игрового поля
 - Кнопка возврата в меню
 */
void RulesScreen::initialize() {
    ResourceManager& rm = ResourceManager::getInstance();
    sf::Font& font = rm.getFont("font");

    if (font.getInfo().family.empty()) {
        throw std::runtime_error("Не удалось загрузить шрифт 'font' из ResourceManager");
    }

    setupBackground("background1"); // Устанавливаем фоновое изображение

    // Анимированный цветной заголовок "Пятнашки"
    titleText = std::make_unique<ColorfulText>("font1", L"Пятнашки", 100,
        sf::Vector2f(0, TITLE_Y_POS), window, true, false);

    // Настройка текстового поля с правилами игры
    text.setFont(font);
    text.setString(
        L"   1. Игровое поле состоит из 15 пронумерованных\n"
        L"   плиток и одного пустого места.\n"
        L"   2. Цель игры перемещать плитки, расположить\n"
        L"   их в правильном порядке: (см. изображение справа)\n"
        L"   3. Перемещать можно только плитки,\n"
        L"   соседние с пустым местом.\n"
        L"   4. Используйте для перемещения плиток левую кнопку\n"
        L"   мыши.\n\n"
        L"   Удачи!"
    );
    text.setCharacterSize(30); // Размер шрифта
    text.setFillColor(sf::Color::Black); // Цвет текста — чёрный

    // Позиционируем текст по центру слева
    sf::FloatRect textRect = text.getLocalBounds();
    text.setOrigin(0, text.getLocalBounds().height / 2.0f);
    text.setPosition(30.0f, window.getSize().y / 2.0f);

    // Создаём фоновый прямоугольник под текстом для улучшения читаемости
    textBackground.setSize(sf::Vector2f(textRect.width + 40, textRect.height + 60));
    textBackground.setFillColor(sf::Color(255, 255, 255, 200)); // Полупрозрачный белый
    textBackground.setOrigin(0, textBackground.getSize().y / 2.0f);
    textBackground.setPosition(20.0f, window.getSize().y / 2.0f + 10.0f);

    // Загружаем изображение правильно собранного игрового поля
    sf::Texture& numTexture = rm.getTexture("numbers");
    if (numTexture.getSize().x == 0) {
        std::cerr << "Ошибка: Не удалось загрузить изображение 'numbers' из ResourceManager.\n";
    }
    numbersSprite.setTexture(numTexture);
    sf::FloatRect numbersRect = numbersSprite.getLocalBounds();
    numbersSprite.setOrigin(numbersRect.width / 2.0f, numbersRect.height / 2.0f);
    numbersSprite.setScale(0.9f, 0.9f); // Уменьшаем немного изображение
    numbersSprite.setPosition(window.getSize().x * 0.75f + 100, window.getSize().y / 2.0f);

    // Создаём кнопку "Назад" внизу экрана
    backButton = std::make_unique<Button>(
        std::wstring(L"м е н ю"),
        sf::Vector2f(445, 600),
        font,
        sf::Color(64, 224, 208, 255),
        sf::Color(64, 224, 208, 255),
        sf::Color::Black,
        sf::Color(128, 128, 128),
        395.0f,
        50.0f,
        30u,
        sf::Color::Black,
        4.0f
    );
}

/*
 Обработка событий от пользователя:
 - Нажатие Esc — возврат в меню
 - Нажатие/отпускание кнопки "Назад"
 */
void RulesScreen::handleEvent(const sf::Event& event) {
    // Выход в меню при нажатии Esc
    if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
        transition.startTransition(GameState::MENU);
    }

    // Обработка нажатия на кнопку "Назад"
    if (event.type == sf::Event::MouseButtonPressed) {
        sf::Vector2f mousePos = window.mapPixelToCoords(sf::Mouse::getPosition(window));
        if (backButton->isClicked(mousePos)) {
            backButton->pressAnimation(); // Анимация нажатия
        }
    }

    // Обработка отпускания кнопки мыши
    if (event.type == sf::Event::MouseButtonReleased) {
        sf::Vector2f mousePos = window.mapPixelToCoords(sf::Mouse::getPosition(window));
        if (backButton->isClicked(mousePos)) {
            backButton->releaseAnimation(); // Анимация отпускания
            transition.startTransition(GameState::MENU); // Переход в меню
        }
    }
}

/*
 Отрисовка всех элементов экрана:
 - Фон
 - Текст с правилами
 - Фон под текстом
 - Изображение игрового поля
 - Кнопка "Назад"
 - Анимированный заголовок
 */
void RulesScreen::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    target.clear(sf::Color::White); // Очищаем экран

    // Рисуем фон, если он есть
    if (useTexture) {
        target.draw(backgroundSprite, states);
    }

    target.draw(textBackground, states);     // Рисуем фон под текстом
    target.draw(numbersSprite, states);      // Рисуем изображение игрового поля
    target.draw(text, states);               // Рисуем текст с правилами
    target.draw(*backButton, states);        // Рисуем кнопку "Назад"
    titleText->draw(target, states);         // Рисуем анимированный заголовок
}

/*
 Обновление состояния экрана:
 - Обновление анимации заголовка
 */
void RulesScreen::update(float deltaTime) {
    titleText->update(deltaTime); // Обновляем анимацию цветного заголовка
}

main — Сердце игры "Пятнашки"

Файл main.cpp — это отправная точка всей игры. Он выполняет ключевые задачи: загружает ресурсы, создаёт окно, переключает экраны, обрабатывает события и управляет рендерингом.

main.cpp

#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include <iostream>
#include "MainMenu.h"
#include "GameScreen.h"
#include "RulesScreen.h"
#include "ResourceManager.h"
#include "Screen.h"
#include "resource.h" // Подключаем ресурсы из .rc файла (например, иконки, текстуры)

// Константы для размера окна
constexpr unsigned int WINDOW_WIDTH = 1280;
constexpr unsigned int WINDOW_HEIGHT = 720;

// Ограничение дельта-времени, чтобы предотвратить большие скачки времени между кадрами
constexpr float MAX_DELTA_TIME = 1.0f / 30.0f;

/*
 Инициализация всех игровых ресурсов.
 Метод загружает текстуры, шрифты, музыку и другие ресурсы из файла ресурсов (.rc).
 Если какой-то ресурс не загружен — выбрасывается исключение.
 */
void initializeResources() {
    ResourceManager& rm = ResourceManager::getInstance();

    if (!rm.loadTexture("puzzle", IDR_TEXTURE1)) {
        throw std::runtime_error("Не удалось загрузить текстуру 'puzzle'");
    }
    if (!rm.loadTexture("background", IDR_TEXTURE2)) {
        throw std::runtime_error("Не удалось загрузить текстуру 'background'");
    }
    if (!rm.loadTexture("background1", IDR_TEXTURE3)) {
        throw std::runtime_error("Не удалось загрузить текстуру 'background1'");
    }
    if (!rm.loadTexture("background2", IDR_TEXTURE4)) {
        throw std::runtime_error("Не удалось загрузить текстуру 'background2'");
    }
    if (!rm.loadTexture("numbers", IDR_TEXTURE5)) {
        throw std::runtime_error("Не удалось загрузить текстуру 'numbers'");
    }
    if (!rm.loadMusic("music", IDR_SOUND1)) {
        throw std::runtime_error("Не удалось загрузить звук 'music'");
    }
    if (!rm.loadFont("font", IDR_FONT1)) {
        throw std::runtime_error("Не удалось загрузить шрифт 'font'");
    }
    if (!rm.loadFont("font1", IDR_FONT2)) {
        throw std::runtime_error("Не удалось загрузить шрифт 'font1'");
    }
}

/*
 Точка входа в приложение.
 Создаёт окно игры, инициализирует ресурсы, создаёт экраны (меню, игра, правила),
 запускает основной цикл отрисовки и обработки событий.
 */
int main() {
    system("chcp 1251"); // Устанавливаем кодовую страницу Windows-1251 для корректного вывода в консоль

    try {
        // Загружаем все игровые ресурсы
        initializeResources();

        // Создаем главное окно приложения
        sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), L"Пятнашки");
        window.setFramerateLimit(60); // Ограничиваем частоту кадров до 60 FPS

        // Загружаем и устанавливаем иконку окна
        ResourceManager& rm = ResourceManager::getInstance();
        sf::Image icon = rm.getImage("puzzle");

        if (icon.getSize().x == 0 || icon.getSize().y == 0) {
            throw std::runtime_error("Ошибка: не удалось загрузить иконку 'puzzle' из ресурсов!");
        }

        window.setIcon(icon.getSize().x, icon.getSize().y, icon.getPixelsPtr());

        // Создаем игровые экраны
        GameState state = GameState::MENU; // Начальное состояние — главное меню
        Transition transition(window); // Объект для анимации перехода между экранами

        GameScreen gameScreen(window, state, transition);   // Игровой экран
        MainMenu mainMenu(window, state, transition, gameScreen); // Главное меню
        RulesScreen rulesScreen(window, state, transition); // Экран с правилами

        // Указатель на текущий активный экран
        Screen* currentScreen = &mainMenu;

        // Часы для измерения времени между кадрами
        sf::Clock clock;

        while (window.isOpen()) {
            // Вычисляем время с последнего кадра (ограничиваем его)
            float deltaTime = clock.restart().asSeconds();
            if (deltaTime > MAX_DELTA_TIME) deltaTime = MAX_DELTA_TIME;

            // Обработка событий SFML
            sf::Event event;
            while (window.pollEvent(event)) {
                if (event.type == sf::Event::Closed) {
                    window.close(); // Закрытие окна по нажатию крестика
                }
                currentScreen->handleEvent(event); // Передаем событие текущему экрану
            }

            // Обновляем состояние перехода между экранами
            bool isTransitioning = transition.update(state, deltaTime);

            // Обновляем текущий экран
            currentScreen->update(deltaTime);

            // Отрисовка
            window.clear(); // Очищаем окно
            window.draw(*currentScreen); // Рисуем текущий экран
            if (isTransitioning) {
                window.draw(transition); // Рисуем анимацию перехода поверх экрана
            }
            window.display(); // Отображаем всё на экране

            // Переключение экранов в зависимости от состояния
            switch (state) {
            case GameState::MENU:
                currentScreen = &mainMenu;
                break;
            case GameState::GAME:
                currentScreen = &gameScreen;
                break;
            case GameState::RULES:
                currentScreen = &rulesScreen;
                break;
            default:
                break;
            }
        }
    }
    catch (const std::exception& e) {
        // Ловим и выводим ошибки
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}

main.cpp — это диспетчер игры. Он не содержит логику самих экранов, а только управляет их жизненным циклом и переключениями. Благодаря такой структуре код легко поддерживать и расширять — можно добавлять новые экраны или менять ресурсы, не затрагивая остальное.

Клонировать репозиторий

Скачать файлы

Наш телеграмм

Наш ютюб

Менеджер ресурсов и динамический текст на SFML

2025-04-19T12:37:02.146Z

Когда Вы только начинаете изучать игровую разработку на C++ с использованием SFML, перед многими из Вас встаёт вопрос: как правильно организовать хранение и загрузку игровых ресурсов? Сначала всё кажется просто - загружаешь текстуру здесь, шрифт там, звук где-то ещё. Но когда Ваш проект начинает расти, Вы сталкиваетесь с реальными проблемами.

Одна и та же текстурная карта может загружаться в память трижды - для главного меню, для уровня и для редактора. В этом случае память расходуется неэффективно, а код превращается в спагетти из вызовов loadFromFile, разбросанных по всей кодовой базе. Тогда Вы начинаете понимать, что нужен системный подход.

Какие варианты есть, это: хранение ресурсов в отдельных классах, глобальные переменные (да, я знаю, что это плохо), система с ручным управлением жизненного цикла.

Каждый из этих подходов имеет свои недостатки. Либо ресурсы живут слишком долго, либо их освобождение происходит не в тот момент, либо доступ к ним неудобный.

Самый оптимальный вариант, это создание класса сингелтона, для управления ресурсами.

Но почему бы не упаковать все ресурсы прямо в исполняемый файл?

Мы создадим менеджер ресурсов, который использует встроенные возможности Windows.

Стоит сразу оговориться — это решение работает исключительно под Windows. Оно использует системные API-функции для доступа к ресурсам, встроенным в EXE-файл.

Главное преимущество этой системы — все ресурсы действительно хранятся внутри EXE-файла. Вы не представляете, как приятно, когда твоя игра представляет собой всего один файл, который можно скопировать куда угодно, и он просто работает. Никаких "где-то потерялась текстура", "не найден шрифт" и прочих проблем с путями.

Конечно, у этого подхода есть свои ограничения:

1. Размер EXE-файла увеличивается (но современные компьютеры с этим легко справляются)

2. Невозможно изменить ресурсы без перекомпиляции

3. Работает только под Windows

Но для многих сценариев разработки игр эти ограничения не критичны. В моём случае плюсы перевешивают:

1. Простота распространения (один файл!)

2. Защита ресурсов от случайного изменения

3. Гарантия, что все нужные файлы на месте

Если вам нужна кроссплатформенность, этот подход не подойдёт. Но если вы, как и я, разрабатываете игры исключительно под Windows и цените простоту распространения, то встроенные ресурсы Windows — отличное решение. В следующих разделах я подробно расскажу, как реализовать эту систему с нуля.

Структура проекта в Visual Studio 2022

📁 Проект/

├── 📄 main.cpp # Главный файл с основным циклом

├── 📄 ResourceManager.h # Заголовочный файл менеджера ресурсов

├── 📄 ResourceManager.cpp # Реализация менеджера ресурсов

├── 📄 ColorfulText.h # Заголовочный файл анимированного текста

├── 📄 ColorfulText.cpp # Реализация анимированного текста

├── 📄 resource.h # Идентификаторы ресурсов

└── 📄 resources.rc # Скрипт компиляции ресурсов

Файлы ресурсов

Ожидаемый результат от программы

Начинаем творить чудеса

Сначала создаём в ручную файлы ресурсов используя редактор кода С++ нашей IDE. Надеюсь Вы уже справились с установкой библиотеки SFML, если нет почитайте статьи выше.

resource.h

#pragma once

#define IDR_FONT1      201  // Шрифт
#define IDR_FONT2      202  // Шрифт

#define IDR_TEXTURE1   301  // Текстура

resource.rc

#include "resource.h"

// ресурсы по умолчанию
IDR_TEXTURE1   RCDATA  "assets/puzzle.png"
IDR_FONT1      RCDATA  "assets/arial.ttf"
IDR_FONT2      RCDATA  "assets/glv.ttf"
IDR_ICON1      ICON    "assets/puzzle.ico"

В нашей программе все ресурсы находятся в отдельной папке assets, которая в свою очередь находится в корневом каталоге проекта.

Теперь создадим класс управления ресурсами.

ResourceManager.h

#pragma once

#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include <string>
#include <unordered_map>
#include <memory>
#include <optional>
#include <source_location>
#include <windows.h>

// Класс для управления ресурсами (шрифты, текстуры, звуки, музыка)
class ResourceManager {
public:
    // Получение единственного экземпляра (паттерн Singleton)
    static ResourceManager& getInstance() noexcept;

    // Загрузка шрифта по идентификатору ресурса
    [[nodiscard]] bool loadFont(std::string_view id, int resourceId,
        const std::source_location& loc = std::source_l
        ocation::current()) noexcept;

    // Загрузка звукового буфера по идентификатору ресурса
    [[nodiscard]] bool loadSound(std::string_view id, int resourceId,
        const std::source_location& loc = std::sour
        ce_location::current()) noexcept;

    // Загрузка текстуры по идентификатору ресурса
    [[nodiscard]] bool loadTexture(std::string_view id, int resourceId,
        const std::source_location& loc = std::s
        ource_location::current()) noexcept;

    // Загрузка музыки по идентификатору ресурса
    [[nodiscard]] bool loadMusic(std::string_view id, int resourceId,
        const std::source_location& loc = s
        td::source_location::current()) noexcept;

    // Получение шрифта по идентификатору (возвращаем указатель)
    [[nodiscard]] std::optional<sf::Font*> getFont(std::string_view id,
        const std::source_location& loc
         = std::source_location::current()) noexcept;

    // Получение звукового буфера по идентификатору (возвращаем указатель)
    [[nodiscard]] std::opti
    onal<sf::SoundBuffer*> getSoundBuffer(std::string_view id,
        const std::source_location& 
        loc = std::source_location::current()) noexcept;

    // Получение текстуры по идентификатору (возвращаем указатель)
    [[nodiscard]] std::optional<
    sf::Texture*> getTexture(std::string_view id,
        const std::source_locat
        ion& loc = std::source_location::current()) noexcept;

    // Получение изображения из текстуры по идентификатору
    [[nodiscard]] std::optional<sf::Image> getImage(std::string_view id,
        const std::source_l
        ocation& loc = std::source_location::current()) noexcept;

    //Получение музыкального потока по идентификатору (возвращаем указатель)
    [[nodiscard]] std::optional<sf::Music*> getMusic(std::string_view id,
        const std::sourc
        e_location& loc = std::source_location::current()) noexcept;

    // Запрещаем копирование и перемещение
    ResourceManager(const ResourceManager&) = delete;
    ResourceManager& operator=(const ResourceManager&) = delete;
    ResourceManager(ResourceManager&&) = delete;
    ResourceManager& operator=(ResourceManager&&) = delete;

private:
    ResourceManager() = default; // Приватный конструктор для Singleton

    // Вспомогательный класс для RAII-управления ресурсами Windows API
    class ResourceHandle {
    public:
        ResourceHandle(HRSRC resource, HGLOBAL handle) noexcept : 
        resource_(resource), handle_(handle) {}
        ~ResourceHandle() { if (handle_) FreeResource(handle_); }
        [[nodiscard]] const void* data() const noexcept { 
        return LockResource(handle_); }
        [[nodiscard]] DWORD size() const noexcept { 
        return SizeofResource(NULL, resource_); }
    private:
        HRSRC resource_;
        HGLOBAL handle_;
    };

    // Шаблонный метод для загрузки ресурса
    template<typename T>
    [[nodiscard]] bool loadResource(int resourceId, T& target,
        const std::source_location& loc = std::source_location::current()) 
        noexcept;

    // Хранилища ресурсов
    std::unordered_map<std::string, sf::Font> fonts_; // Шрифты
    // Звуковые буферы
    std::unordered_map<std::string, sf::SoundBuffer> buffers_; 
    std::unordered_map<std::string, sf::Texture> textures_; // Текстуры
    // Музыкальные потоки
    std::unordered_map<std::string, std::unique_ptr<sf::Music>> 
    musicStreams_; 
    // Кэш изображений
    std::unordered_map<std::string, sf::Image> imageCache_;
};

ResourceManager.cpp

#include "ResourceManager.h"
#include <iostream>

// Получение единственного экземпляра менеджера ресурсов (синглтон)
ResourceManager& ResourceManager::getInstance() noexcept {
    static ResourceManager instance;
    return instance;
}

// Шаблонный метод для загрузки ресурса любого типа
template<typename T>
bool ResourceManager::loadResource(int resourceId, 
T& target, const std::source_location& loc) noexcept {
    // Поиск ресурса в исполняемом файле
    HRSRC resource = FindResource(NULL, MAKEINTRESOURCE(
    resourceId), RT_RCDATA);
    if (!resource) {
        std::cerr << "Ошибка в " << loc.function_name() 
        << " (строка " << loc.line()
            << "): Не удалось найти ресурс с ID " << resourceId << '\n';
        return false;
    }

    // Загрузка ресурса с использованием RAII
    HGLOBAL handle = LoadResource(NULL, resource);
    if (!handle) {
        std::cerr << "Ошибка в " << loc.function
        _name() << " (строка " << loc.line()
            << "): Не удалось загрузить ресу
            рс с ID " << resourceId << '\n';
        return false;
    }

    // Использование RAII-обертки для управления ресурсом
    ResourceHandle resourceHandle(resource, handle);
    const void* data = resourceHandle.data();
    if (!data) {
        std::cerr << "Ошибка в " << loc
        .function_name() << " (строка " << loc.line()
            << "): Не удалось заблокиро
            вать ресурс с ID " << resourceId << '\n';
        return false;
    }

    // Получение размера ресурса и загрузка в целевой объект
    DWORD size = resourceHandle.size();
    return target.loadFromMemory(data, size);
}

// Загрузка шрифта из ресурсов
bool ResourceManager::loa
dFont(std::string_view id, int resourceId, 
const std::source_location& loc) noexcept {
    sf::Font font;
    if (!loadResource(resourceId, font, loc)) {
        std::cerr << "Оши
        бка в " << loc.function_name() << " (строка " << loc.line()
            << "): Не удалось загрузить шрифт '" << id << "'\n";
        return false;
    }
    // Сохранение шрифта в словаре под указанным идентификатором
    fonts_[std::string(id)] = std::move(font);
    return true;
}

// Загрузка звукового буфера из ресурсов
bool Resource
Manager::loadSound(std::string_view id, int resourceId, const 
std::source_location& loc) noexcept {
    sf::SoundBuffer buffer;
    if (!loadResource(resourceId, buffer, loc)) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Не удалось загрузить звук '" << id << "'\n";
        return false;
    }
    // Сохранение звукового буфера в словаре
    buffers_[std::string(id)] = std::move(buffer);
    return true;
}

// Загрузка текстуры из ресурсов
bool ResourceManager::loadTexture(std::string_view id, int resourceId, 
const std::source_location& loc) noexcept {
    sf::Texture texture;
    if (!loadResource(resourceId, texture, loc)) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Не удалось загрузить текстуру '" << id << "'\n";
        return false;
    }
    // Сохранение текстуры в словаре
    textures_[std::string(id)] = std::move(texture);
    return true;
}

// Загрузка музыки из ресурсов (особый случай, так как Music в SFML 
//работает с потоками)
bool ResourceManager::loadMusic(std::string_view id, int resourceId, 
const std::source_location& loc) noexcept {
    // Поиск музыкального ресурса
    HRSRC resource = FindResource(NULL, MAKEINTRESOURCE(resourceId), 
    RT_RCDATA);
    if (!resource) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Не удалось найти музыкальный ресурс '" << id << "'\n";
        return false;
    }

    // Загрузка ресурса
    HGLOBAL handle = LoadResource(NULL, resource);
    if (!handle) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Не удалось загрузить музыкальный ресурс '" << id 
            << "'\n";
        return false;
    }

    // Использование RAII-обертки
    ResourceHandle resourceHandle(resource, handle);
    const void* data = resourceHandle.data();
    if (!data) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Не удалось заблокировать музыкальный ресурс '" << id 
            << "'\n";
        return false;
    }

    // Создание музыкального потока из данных в памяти
    DWORD size = resourceHandle.size();
    auto music = std::make_unique<sf::Music>();
    if (!music->openFromMemory(data, size)) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Не удалось открыть музыкальный поток '" << id 
            << "' из памяти\n";
        return false;
    }

    // Сохранение музыкального потока в словаре
    musicStreams_[std::string(id)] = std::move(music);
    return true;
}

// Получение шрифта по идентификатору
std::optional<sf::Font*> ResourceManager::getFont(std::string_view id, 
const std::source_location& loc) noexcept {
    auto it = fonts_.find(std::string(id));
    if (it == fonts_.end()) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Шрифт '" << id << "' не найден\n";
        return std::nullopt;
    }
    return &(it->second);
}

// Получение звукового буфера по идентификатору
std::optional<sf::SoundBuffer*> ResourceManager::getSoundBuffer(
std::string_view id, const std::source_location& loc) noexcept {
    auto it = buffers_.find(std::string(id));
    if (it == buffers_.end()) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Звуковой буфер '" << id << "' не найден\n";
        return std::nullopt;
    }
    return &(it->second);
}

// Получение текстуры по идентификатору
std::optional<sf::Texture*> ResourceManager::getTexture(
std::string_view id, const std::source_location& loc) noexcept {
    auto it = textures_.find(std::string(id));
    if (it == textures_.end()) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Текстура '" << id << "' не найдена\n";
        return std::nullopt;
    }
    return &(it->second);
}

// Получение изображения по идентификатору (с кэшированием)
std::optional<sf::Image> ResourceManager::getImage(std::string_view id, 
const std::source_location& loc) noexcept {
    // Проверяем, есть ли изображение в кэше
    auto cacheIt = imageCache_.find(std::string(id));
    if (cacheIt != imageCache_.end()) {
        return cacheIt->second;
    }

    // Если нет в кэше, загружаем из текстуры
    auto texIt = textures_.find(std::string(id));
    if (texIt == textures_.end()) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Текстура для изображения '" << id << "' не найдена\n";
        return std::nullopt;
    }

    // Конвертируем текстуру в изображение и кэшируем результат
    sf::Image image = texIt->second.copyToImage();
    imageCache_[std::string(id)] = image; // Кэшируем изображение
    return image;
}

// Получение музыкального потока по идентификатору
std::optional<sf::Music*> ResourceManager::getMusic(std::string_view id, 
const std::source_location& loc) noexcept {
    auto it = musicStreams_.find(std::string(id));
    if (it == musicStreams_.end()) {
        std::cerr << "Ошибка в " << loc.function_name() << " (строка " 
        << loc.line()
            << "): Музыкальный поток '" << id << "' не найден\n";
        return std::nullopt;
    }
    return it->second.get();
}

Теперь мы можем создать класс для создания феерического текста

ColorfulText.h

#pragma once

#include <SFML/Graphics.hpp>
#include <vector>
#include <string_view>
#include <random>
#include <memory>
#include <optional>
#include <ranges>
#include <concepts>
#include <source_location>

class ResourceManager; // Предполагаем, что определен где-то еще

class ColorfulText : public sf::Drawable {
public:
    // Перечисление эффектов с scoped enum
    enum class Effect {
        RandomColors, // Случайные цвета для каждой буквы
        Wave,         // Волна цветов, бегущая по тексту
        Blink,        // Мигание букв с изменением яркости
        Rainbow,      // Радужный переход цветов
        Pulse,        // Пульсация размера букв
        Fade,         // Затухание и появление цветов
        Twinkle       // Мерцание случайных букв
    };

    // Статический метод создания с поддержкой юникода
    [[nodiscard]] static std::optional<ColorfulText> create(
        std::string_view fon
        tId, std::wstring_view text, unsigned int charSize,
        const sf::Vector2f& position, const sf::RenderWindow& window,
        bool centerHorizontally = false, bool centerVertically = false,
        Effect effect = Effect::RandomColors,
        const std::source_locat
        ion& loc = std::source_location::current());

    // Обновление состояния текста
    void update(float deltaTime) noexcept;

    // Установка эффекта с использованием концепций C++20
    template<typename T>
        requires std::same_as<T, Effect>
    void setEffect(T newEffect) noexcept { setEffectImpl(newEffect); }

    // Установка позиции текста
    void setPosition(const sf::Vector2f& position, 
    bool centerHorizontally = false, bool centerVertically = false) 
    noexcept;

    // Запрещаем копирование, разрешаем перемещение
    ColorfulText(const ColorfulText&) = delete;
    ColorfulText& operator=(const ColorfulText&) = delete;
    ColorfulText(ColorfulText&&) = default;
    ColorfulText& operator=(ColorfulText&&) = default;

private:
    // Приватный конструктор для внутреннего использования в create
    ColorfulText() = default;

    // Переопределение метода отрисовки из sf::Drawable
    void draw(sf::RenderTarget& target, sf::RenderStates states) 
    const override;

    // Методы обновления эффектов
    void updateRandomColors();        // Случайные цвета
    void updateWave(float deltaTime); // Волна цветов
    void updateBlink(float deltaTime); // Мигание букв
    void updateRainbow(float deltaTime); // Радужный переход
    void updatePulse(float deltaTime);   // Пульсация размера
    void updateFade(float deltaTime);    // Затухание цветов
    void updateTwinkle(float deltaTime); // Мерцание случайных букв

    // Внутренняя реализия смены эффекта
    void setEffectImpl(Effect newEffect) noexcept;

    // Данные класса
    // Указатель на шрифт (хранится в ResourceManager)
    sf::Font* font_ = nullptr; 
    std::vector<sf::Text> letters_;          // Вектор букв текста
    float colorTimer_ = 0.0f;                // Таймер для эффектов
    Effect currentEffect_;                   // Текущий эффект
    float waveOffset_ = 0.0f;           // Смещение для плавных эффектов
    std::vector<float> twinkleTimers_;  // Таймеры для эффекта мерцания

    // Константы
    // Интервал смены эффектов
    static constexpr float COLOR_CHANGE_INTERVAL = 0.5f; 
    static constexpr float WAVE_SPEED = 1.0f;       // Скорость волны
    static constexpr float PULSE_AMPLITUDE = 0.2f;  // Амплитуда пульсации
    static constexpr float TWINKLE_CHANCE = 0.1f;   // Шанс мерцания
};

ColorfulText.cpp

#include "ColorfulText.h"
#include "ResourceManager.h"
#include <cmath>
#include <algorithm>
#include <iostream>

std::optional<ColorfulText> ColorfulText::create(
    std::string_view fontId, std::wstring_view
     text, unsigned int charSize,
    const sf::Vector2f& position, const sf::RenderWindow& window,
    bool centerHorizontally, bool centerVertically, Effect effect,
    const std::source_location& loc) {

    // Создаем объект с помощью приватного конструктора
    ColorfulText result;
    ResourceManager& rm = ResourceManager::getInstance();
    auto fontOpt = rm.getFont(fontId, loc);
    if (!fontOpt.has_value()) {
        return std::nullopt; // Ошибка уже выведена в getFont
    }
    result.font_ = fontOpt.value(); // Извлекаем указатель на шрифт

    // Расчет позиции текста
    float totalWidth = text.size() * charSize * 0.8f;
    float xPos = centerHorizontally ? (window.get
    Size().x - totalWidth) / 2.0f : position.x;
    float yPos = centerVertically ? (window.
    getSize().y - charSize) / 2.0f : position.y;

    // Резервируем память
    result.letters_.reserve(text.size());
    result.twinkleTimers_.resize(text.size(), 0.0f);

    // Инициализация букв с использованием std::ranges (C++20)
    std::ranges::for_each(std::views::i
    ota(size_t{ 0 }, text.size()), [&](size_t i) {
        sf::Text letter;
        letter.setFont(*result.font_);
        // Устанавливаем символ юникода
        letter.setCharacterSize(charSize);
        letter.setString(std::wstring(1, text[i])); 
        letter.setFillColor(sf::Color::Magenta);
        letter.setPosition(xPos + i * charSize * 0.8f, yPos);
        result.letters_.push_back(std::move(letter));
        });

    // Инициализация остальных полей
    result.currentEffect_ = effect;
    result.colorTimer_ = 0.0f;
    result.waveOffset_ = 0.0f;

    return result;
}

void ColorfulText::update(float deltaTime) noexcept {
    colorTimer_ += deltaTime;
    waveOffset_ += deltaTime * WAVE_SPEED;

    // Обновление в зависимости от текущего эффекта
    switch (currentEffect_) {
    case Effect::RandomColors:
        if (colorTimer_ >= COLOR_CHANGE_INTERVAL) {
            colorTimer_ = 0.0f;
            updateRandomColors();
        }
        break;
    case Effect::Wave: updateWave(deltaTime); break;
    case Effect::Blink: updateBlink(deltaTime); break;
    case Effect::Rainbow: updateRainbow(deltaTime); break;
    case Effect::Pulse: updatePulse(deltaTime); break;
    case Effect::Fade: updateFade(deltaTime); break;
    case Effect::Twinkle: updateTwinkle(deltaTime); break;
    }
}

void ColorfulText::setEffectImpl(Effect newEffect) noexcept {
    currentEffect_ = newEffect;
    colorTimer_ = 0.0f;
    waveOffset_ = 0.0f;
    std::ranges::fill(twinkleTimers_, 0.0f); // Сброс таймеров мерцания
    update(0.0f); // Немедленное обновление состояния
}

void ColorfulText::updateRandomColors() {
    // Генерация случайных цветов для каждой буквы
    thread_local std::mt19937 gen{ std::random_device{}() };
    std::uniform_int_distribution<int> dis(0, 255);

    std::ranges::for_each(letters_, [&](auto& letter) {
        letter.setFillColor(sf::Color(
            static_cast<sf::Uint8>(dis(gen)),
            static_cast<sf::Uint8>(dis(gen)),
            static_cast<sf::Uint8>(dis(gen))));
        });
}

void ColorfulText::updateWave(float deltaTime) {
    // Эффект волны цветов
    std::ranges::for_each(std::views::iota(size_t{ 0 }, 
    letters_.size()), [&](size_t i) {
        float phase = waveOffset_ + i * 0.2f;
        sf::Uint8 value = static_cast<sf::Uint8>(127.5f + 
        127.5f * std::sin(phase));
        letters_[i].setFillColor(sf::Color(value, 255 - 
        value, value / 2));
        });
}

void ColorfulText::updateBlink(float deltaTime) {
    // Мигание букв через изменение прозрачности
    float alpha = 127.5f + 127.5f * std::sin(colorTimer_ * 5.0f);
    std::ranges::for_each(letters_, [alpha](auto& letter) {
        sf::Color color = letter.getFillColor();
        color.a = static_cast<sf::Uint8>(alpha);
        letter.setFillColor(color);
        });
}

void ColorfulText::updateRainbow(float deltaTime) {
    // Радужный эффект с плавным переходом
    std::ranges::for_each(std::views::iota(size_t{ 0 }, 
    letters_.size()), [&](size_t i) {
        float phase = waveOffset_ + i * 0.1f;
        sf::Uint8 r = static_cast<sf::Uint8>(127.5f + 
        127.5f * std::sin(phase));
        sf::Uint8 g = static_cast<sf::Uint8>(127.5f + 
        127.5f * std::sin(phase + 2.0f));
        sf::Uint8 b = static_cast<sf::Uint8>(127.5f + 
        127.5f * std::sin(phase + 4.0f));
        letters_[i].setFillColor(sf::Color(r, g, b));
        });
}

void ColorfulText::updatePulse(float deltaTime) {
    // Пульсация размера букв
    float scale = 1.0f + PULSE_AMPLITUDE * std::sin(colorTimer_ * 3.0f);
    std::ranges::for_each(letters_, [scale](auto& letter) {
        letter.setScale(scale, scale);
        });
}

void ColorfulText::updateFade(float deltaTime) {
    // Затухание и появление цветов
    float alpha = 127.5f + 127.5f * std::sin(colorTimer_ * 2.0f);
    std::ranges::for_each(letters_, [alpha](auto& letter) {
        letter.setFillColor(sf::Color(255, 255, 255, 
        static_cast<sf::Uint8>(alpha)));
        });
}

void ColorfulText::updateTwinkle(float deltaTime) {
    // Мерцание случайных букв
    thread_local std::mt19937 gen{ std::random_device{}() };
    std::uniform_real_distribution<float> dis(0.0f, 1.0f);

    std::ranges::for_each(std::views::iota(size_t{ 0 }, 
    letters_.size()), [&](size_t i) {
        twinkleTimers_[i] += deltaTime;
        if (twinkleTimers_[i] >= COLOR_CHANGE_INTERVAL) {
            if (dis(gen) < TWINKLE_CHANCE) {
                letters_[i].setFillColor(sf::Color::White);
                twinkleTimers_[i] = 0.0f;
            }
            else {
                letters_[i].setFillColor(sf::Color(100, 100, 100));
            }
        }
        });
}

void ColorfulText::draw(sf::RenderTarget& target, 
sf::RenderStates states) const {
    // Отрисовка всех букв
    for (const auto& letter : letters_) {
        target.draw(letter, states);
    }
}

void ColorfulText::setPosition(const sf::Vector2f& position, 
bool centerHorizontally, bool centerVertically) noexcept {
    // Установка новой позиции текста
    float totalWidth = letters_.size() * letters_[0].getCharacterSize() 
    * 0.8f;
    float xPos = centerHorizontally ? position.x - totalWidth 
    / 2.0f : position.x;
    float yPos = centerVertically ? position.y - 
    letters_[0].getCharacterSize() / 2.0f : position.y;

    std::ranges::for_each(std::views::iota(size_t{ 0 }, 
    letters_.size()), [&](size_t i) {
        letters_[i].setPosition(xPos + i * 
        letters_[0].getCharacterSize() * 0.8f, yPos);
        });
}

А теперь все объединим в исполняем файле.

Мигающие_буквы.cpp

#include <SFML/Graphics.hpp>
#include "ColorfulText.h"
#include "ResourceManager.h"
#include "resource.h"
#include <iostream>

// Инициализация ресурсов
void initializeResources() {
    ResourceManager& rm = ResourceManager::getInstance();
    if (!rm.loadTexture("puzzle", IDR_TEXTURE1) || 
    !rm.loadFont("font", IDR_FONT1)) {
        throw std::runtime_error("Не удалось загрузить ресурсы");
    }
}

int main() {
    initializeResources();
    sf::RenderWindow window(sf::VideoMode(1280, 720), 
    L"Весёлый текст", sf::Style::Default);
    window.setFramerateLimit(60);

    // Установка иконки окна
    ResourceManager& rm = ResourceManager::getInstance();
    auto iconOpt = rm.getImage("puzzle");
    if (!iconOpt) {
        std::cerr << "Не удалось загрузить иконку 'puzzle'\n";
        return 1;
    }
    sf::Image icon = *iconOpt; // Извлекаем значение из std::optional
    if (icon.getSize().x == 0 || icon.getSize().y == 0) {
        std::cerr << "Иконка 'puzzle' пуста\n";
        return 1;
    }
    window.setIcon(icon.getSize().x, icon.getSize().y, 
    icon.getPixelsPtr());

    // Создание текста с юникодом
    auto text = ColorfulText::create("font", L"Привет, мир!", 100,
        sf::Vector2f(0, 0), window, true, true, 
        ColorfulText::Effect::Pulse);
    if (!text) {
        std::cerr << "Не удалось создать ColorfulText\n";
        return 1;
    }

    sf::Clock clock;
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
            // Переключение эффектов по нажатию клавиш (только 7 эффектов)
            if (event.type == sf::Event::KeyPressed) {
                switch (event.key.code) {
                case sf::Keyboard::F1: text->setEffect(
                ColorfulText::Effect::RandomColors); break;
                case sf::Keyboard::F2: text->setEffect(
                ColorfulText::Effect::Wave); break;
                case sf::Keyboard::F3: text->setEffect(
                ColorfulText::Effect::Blink); break;
                case sf::Keyboard::F4: text->setEffect(
                ColorfulText::Effect::Rainbow); break;
                case sf::Keyboard::F5: text->setEffect(
                ColorfulText::Effect::Pulse); break;
                case sf::Keyboard::F6: text->setEffect(
                ColorfulText::Effect::Fade); break;
                case sf::Keyboard::F7: text->setEffect(
                ColorfulText::Effect::Twinkle); break;
                }
            }
        }

        // Обновление и отрисовка текста
        float deltaTime = clock.restart().asSeconds();
        text->update(deltaTime);

        window.clear(sf::Color::Blue);
        window.draw(*text);
        window.display();
    }
    return 0;
}

Надеюсь у Вас всё получилось и до новых встреч !!!

Телеграмм канал - Программирование игр С++

Пишем калькулятор на C++ с SFML

2025-03-16T15:03:31.841Z

Привет, коллеги и доброжелательные критики! Сегодня я решил отвлечься от своей громоздкой работы, чтобы написать что-то простое, но с изюминкой — калькулятор с графическим интерфейсом на C++20 и SFML. Этот проект — не претензия на что-то грандиозное, а скорее лёгкий эксперимент, чтобы вспомнить, как приятно писать код, который сразу видно на экране. Заодно я поделюсь с вами своими мыслями, подходами и парой советов. Давайте разберём, как я это закрутил и почему выбрал именно SFML.

Почему калькулятор? И почему SFML?

Калькулятор — это классика программирования. Помню, как в начале карьеры, ещё в нулевых, писал такие на Pascal для курсовых, потом переделывал их на C с самописным парсером для зачётов. Это как "Hello, World", только с кнопками и математикой — отличный способ проверить свои навыки. Сейчас, конечно, можно было бы взять что-то посерьёзнее: Qt для полноценного GUI, SDL для низкоуровневого контроля или даже Unreal Engine, если уж совсем размахнуться. Но я остановился на SFML, а конкретно на версии 2.6.1. Почему именно она? Это последняя стабильная версия на март 2025 года, и она отлично дружит с современными компиляторами — GCC 12, MSVC 2022 и даже Clang 17. В ней есть мелкие улучшения рендеринга, поддержка C++17/20 из коробки и никаких сюрпризов с совместимостью, что для меня как человека без дополнительного запаса времени очень важно — не люблю тратить своё драгоценное время на борьбу с зависимостями.

SFML я выбрал не просто так. Это лёгкая библиотека для 2D-графики, которая не заставляет тебя писать тонны boilerplate-кода, как Qt, или возиться с низкоуровневыми деталями, как SDL. Сравните с другими системами: Qt — это тяжеловес с кучей возможностей, но для калькулятора его функционал избыточен, как если бы вы использовали танк для поездки в магазин. SDL даёт больше контроля, но требует больше ручной работы — например, самому рисовать текстуры или управлять контекстом OpenGL. SFML же сразу предлагает готовые примитивы вроде RectangleShape, Text и Sprite, что идеально для простого GUI. Её плюсы: минимализм (быстро настраивается), производительность (для 2D почти не жрёт ресурсов), кроссплатформенность (Windows, Linux, macOS без лишних телодвижений). Почему не SFML 3.1, потому - что синтаксис поменялся и нужно потратить время, чтобы вникнуть, а времени увы очень мало. Может в будущем я и буду писать код на SFML 3.1, но точно не сейчас. Да и багов хватает всегда с выходом чего-то нового.

Я использую SFML для небольших экспериментов, где нужна быстрая визуализация: прототипы интерфейсов, простые инструменты для отладки, визуализации данных или даже мелкие игрушки для души. Например, пару лет назад я делал простой шутер - "Кощей", рендерил тысячи клеток в реальном времени, и она справилась без лагов. Для больших проектов я бы взял Qt или Unity, но тут задача была другая — сделать что-то рабочее за пару часов, без оверхеда и с удовольствием.

Архитектура: как я это разложил

Проект у меня получился из трёх основных классов плюс точка входа. Я старался держать всё просто, но с учётом современных практик — никаких сырых указателей, никаких C-style массивов. Вот что вышло:

Button — класс для кнопок. Простая обёртка над прямоугольником и текстом, но с умными указателями для управления памятью.

Calculator — главный класс, который собирает интерфейс, обрабатывает клики и связывает всё с вычислениями.

ExpressionEvaluator — рекурсивный парсер выражений. Без него это был бы просто красивый блокнот с кнопками.

main.cpp — минимальный код для запуска окна и цикла событий.

Я сразу решил использовать std::unique_ptr вместо сырых указателей — в 2025 году это уже стандарт, и возиться с new/delete нет никакого смысла. Также заменил все массивы на std::vector — меньше багов, больше читаемости. Давайте разберём каждый кусок подробнее.

Кнопки (Button.h)

#pragma once
#include <string>
#include <memory>
#include <SFML/Graphics.hpp>

class Button : public sf::Drawable, public sf::Transformable {
public:
    Button(std::string text, sf::Font& font, unsigned int characterSize, 
           sf::Vector2f position, sf::Vector2f size)
        : m_rect{std::make_unique<sf::RectangleShape>
        (size)}, // Создаем прямоугольник кнопки
          m_text{std::make_unique<sf::Text>(text, font, charac
          terSize)} { // Создаем текст на кнопке
        
        m_rect->setPosition(position); // Задаем позицию кнопки
        m_rect->setFillColor(sf::Color(200, 200, 200)); // Серый фон
        m_rect->setOutlineColor(sf::Color::Black); // Черная обводка
        m_rect->setOutlineThickness(2); // Толщина обводки

        m_text->setPosition(position.x + 20, p
        osition.y + 20); // Текст с отступом внутри кнопки
        m_text->setFillColor(sf::Color::White); // Белый цвет текста
    }

    void pressEffect() { // Эффект нажатия — меняем цвет
        m_rect->setFillColor(sf::Color(150, 150, 150));
        m_rect->setOutlineColor(sf::Color(150, 150, 150));
    }

    void releaseEffect() { // Эффект отпускания — возвращаем исходный цвет
        m_rect->setFillColor(sf::Color(200, 200, 200));
        m_rect->setOutlineColor(sf::Color::Black);
    }

    std::string getText() const { // Получаем текст кнопки
        return m_text->getString();
    }

    sf::FloatRect getGlobalBounds() const { 
    // Границы кнопки с учетом трансформаций
        return getTransform().transformRect(m_rect->getGlobalBounds());
    }

private:
    void draw(sf::RenderTarget& target, sf::RenderStates states) 
    const override { // Отрисовка кнопки
        states.transform *= getTransform();
        target.draw(*m_rect, states); // Рисуем прямоугольник
        target.draw(*m_text, states); // Рисуем текст
    }

    std::unique_ptr<sf::RectangleShape> m_rect; 
    
    std::unique_ptr<sf::Text> m_text; // Умный указатель на текст
};f::Text> m_text; // Умный указатель на текст
};

Класс кнопки — это мой первый шаг к интерфейсу. Он простой, но функциональный: прямоугольник с текстом, который реагирует на клики. Использовал std::unique_ptr, чтобы памятью управляла сама программа — никаких утечек, никакого ручного delete. Добавил визуальную обратную связь через pressEffect и releaseEffect — кнопка темнеет при нажатии, что делает UI живым. Цвета выбрал на глаз: серый фон и белый текст — классика, но в реальном проекте я бы вынес их в константы или конфиг-файл, чтобы дизайнеры могли играться. SFML тут хорош тем, что сразу даёт RectangleShape и Text — не надо самому писать шейдеры или возиться с текстурами, как в SDL. Ещё я подумал центрировать текст поумнее, но отступ в 20 пикселей для демки сгодился.

Калькулятор (Calculator.h)

#pragma once
#include <string>
#include <vector>
#include <memory>
#include <SFML/Graphics.hpp>
#include "Button.h"
#include "ExpressionEvaluator.h"

class Calculator : public sf::Drawable, public sf::Transformable {
public:
    explicit Calculator(sf::Font& font) { // Конструктор принимает шрифт
        display = std::make_unique<sf::Recta
        ngleShape>(sf::Vector2f(360, 50)); // Создаем дисплей
        display->setPosition(20, 20); // Позиция дисплея
        display->setFillColor(sf::Color(173, 216, 230)); // Голубой фон
        display->setOutlineColor(sf::Color::Black); // Черная обводка
        display->setOutlineThickness(2); // Толщина обводки

        displayText = std::make_unique<sf::Text>("", font, 30); 
        displayText->setPosition(30, 30); // Позиция текста
        displayText->setFillColor(sf::Color::Black); // Черный цвет текста

        windowBackground = std::make_unique<sf::RectangleShape>(
        sf::Vector2f(400, 600)); // Фон окна
        windowBackground->setFillColor(sf::Color::White); 

        const std::vector<std::string> labels = { 
        // Список меток для кнопок
            "7", "8", "9", "/", "4", "5", "6", "*", "1", "2", "3", "-",
            "0", "C", "=", "+", "(", ")", "<<<"
        };

        buttons.reserve(labels.size()); // Резервируем место под кнопки
        for (size_t i = 0; i < labels.size(); ++i) { 
        // Создаем кнопки в цикле
            buttons.emplace_back(std::make_unique<Button>(
                labels[i], font, 24,
                sf::Vector2f(20 + (i % 4) * 90, 100 + (i / 4) * 90),
                sf::Vector2f(80, 80)
            ));
        }
    }

    void handleEvent(const sf::Event& event, sf::RenderWindow& window) { 
    // Обработка событий
        if (event.type == sf::Event::MouseButtonPressed && 
            event.mouseButton.button == sf::Mouse::Left) {
            for (const auto& button : buttons) {
                if (button->getGlobalBounds().contains(
                    static_cast<sf::Vector2f>(
                    sf::Mouse::getPosition(window)))) {
                    button->pressEffect(); // Анимация нажатия
                    processInput(button->getText()); // Обрабатываем ввод
                    displayText->setString(input); // Обновляем дисплей
                }
            }
        }
        if (event.type == sf::Event::MouseButtonReleased && 
            event.mouseButton.button == sf::Mouse::Left) {
            for (const auto& button : buttons) {
                button->releaseEffect(); // Возвращаем цвет
            }
        }
    }

private:
    void draw(sf::RenderTarget& target, sf::RenderStates states) 
    const override { // Отрисовка калькулятора
        states.transform *= getTransform();
        target.draw(*windowBackground, states); // Рисуем фон
        target.draw(*display, states); // Рисуем дисплей
        target.draw(*displayText, states); // Рисуем текст
        for (const auto& button : buttons) {
            target.draw(*button, states); // Рисуем все кнопки
        }
    }

    void processInput(const std::string& text) { // Логика обработки ввода
        using namespace std::string_literals;
        if (text == "C"s) { // Очистка
            input.clear();
        }
        else if (text == "="s) { // Вычисление результата
            try {
                double result = ExpressionEvaluator::evaluate(input);
                input = std::to_string(result);
                if (input.ends_with(".000000")) { // Убираем лишние нули
                    input = input.substr(0, input.find('.'));
                }
            }
            catch (const std::exception&) {
                input = "Error"s; // Ошибка при вычислении
            }
        }
        else if (text == "<<<"s) { // Удаление последнего символа
            if (!input.empty()) {
                input.pop_back();
            }
        }
        else if (text == "+"s || text == "-"s || text == "*"s || text == 
        "/"s) { // Операторы
            std::string_view ops = "+-*/";
            if (!input.empty() && ops.find(input.back()) == 
            std::string_view::npos && input.length() < 19) {
                input += text;
            }
        }
        else if (input.length() < 19) { 
        // Добавляем символ, если не превышен лимит
            input += text;
        }
        displayText->setString(input); // Обновляем текст на дисплее
    }

    std::unique_ptr<sf::RectangleShape> windowBackground; // Фон окна
    std::unique_ptr<sf::RectangleShape> display; // Дисплей
    std::unique_ptr<sf::Text> displayText; // Текст дисплея
    std::vector<std::unique_ptr<Button>> buttons; // Вектор кнопок
    std::string input; // Текущий ввод
};

Это ядро всего проекта. Я долго думал, как организовать кнопки, и решил остановиться на сетке 4x5 — это стандартная раскладка, как на старых калькуляторах Casio, только с парой дополнительных кнопок вроде скобок и "backspace". Размеры окна (400x600) и кнопок (80x80) подбирал вручную, чтобы всё аккуратно влезло, а отступы в 20 пикселей между элементами добавил для читаемости. Дисплей сделал голубым — просто захотелось чего-то яркого на белом фоне. В processInput вся логика ввода: защита от двойных операторов (чтобы не вводились "++" или "*/"), лимит в 19 символов (SFML начинает обрезать текст, если больше), плюс обработка ошибок вроде деления на ноль. Использовал ends_with из C++20 — мелочь, но избавляет от ручной проверки концов строки. SFML тут хорош своей простотой: метод draw сам рендерит всё в нужном порядке, и мне не пришлось писать сложную логику обновления.

Ещё я заметил, что при быстрых кликах SFML немного подтормаживает — это не баг самой библиотеки, а особенность того, как я обрабатываю события. В реальном проекте я бы добавил дебаунсинг или перерисовывал только изменённые элементы, но для демки оставил как есть.

Парсер (ExpressionEvaluator.h)

#pragma once
#include <string>
#include <string_view>
#include <stdexcept>
#include <charconv>

class ExpressionEvaluator {
public:
    static double evaluate(std::string_view expres
    sion) { // Вычисляем выражение
        size_t pos = 0;
        return parseExpression(expression, pos);
    }

private:
    static double parseExpression(std::string_view expr,
     size_t& pos) { // Разбираем выражение (+, -)
        double result = parseTerm(expr, pos);
        while (pos < expr.length()) {
            char op = expr[pos];
            if (op != '+' && op != '-') break;
            pos++;
            double term = parseTerm(expr, pos);
            result = (op == '+') ? result + term : result - term;
        }
        return result;
    }

    static double parseTerm(std::strin
    g_view expr, size_t& pos) { // Разбираем члены (*, /)
        double result = parseFactor(expr, pos);
        while (pos < expr.length()) {
            char op = expr[pos];
            if (op != '*' && op != '/') break;
            pos++;
            double factor = parseFactor(expr, pos);
            if (op == '*') result *= factor;
            else if (factor
             == 0) throw std::invalid_argument("Деление на ноль!");
            else result /= factor;
        }
        return result;
    }

    static double parseFactor(std::string_view expr, size_t& pos) 
    { // Разбираем множители (числа, скобки)
        skipWhitespace(expr, pos);
        if (pos >= expr.length()) throw std::invalid_argument(
        "Некорректное выражение");

        if (expr[pos] == '(') { // Обработка скобок
            pos++;
            double result = parseExpression(expr, pos);
            skipWhitespace(expr, pos);
            if (pos >= expr.length() || expr[pos] != ')') 
                throw std::invalid_argument("Нет закрывающей скобки");
            pos++;
            return result;
        }

        double result{};
        auto [ptr, ec] = std::from_chars(expr.data() + pos, 
        // Парсим число
                                       expr.data() + expr.length(), 
                                       result);
        if (ec != std::errc()) throw std::invalid_argument(
        "Некорректное число");
        pos = ptr - expr.data();
        return result;
    }

    static void skipWhitespace(std::string_view expr, size_t& pos) { 
    // Пропускаем пробелы
        while (pos < expr.length() && std::isspace(expr[pos])) pos++;
    }
};

Парсер — это, пожалуй, самая интересная часть. Я решил сделать рекурсивный спуск. Алгоритм простой, но правильный: сначала парсим скобки и числа (через parseFactor), потом умножение и деление (в parseTerm), и только потом сложение с вычитанием (в parseExpression). Это автоматически учитывает приоритет операций, так что "2 + 3 * 4" даст 14, а не 20. Использовал std::from_chars вместо stringstream — это быстрее и меньше тянет за собой STL-оверхеда. Плюс, std::string_view экономит копирования строк, что для парсера мелочь, но приятная.

Я добавил поддержку пробелов через skipWhitespace, хотя в этом интерфейсе она не особо нужна — просто привычка писать код с запасом на будущее. Ещё парсер выбрасывает исключения при ошибках вроде деления на ноль или незакрытых скобок — в реальном проекте я бы добавил нормальное логирование, но тут просто вывожу "Error" на дисплей. SFML тут не участвует, но без парсера калькулятор был бы просто красивой оболочкой.

Точка входа (main.cpp)

#include <SFML/Graphics.hpp>
#include <iostream>
#include "Calculator.h"

int main() {
    sf::RenderWindow window(sf::VideoMode(400, 600), L"SFML Калькулятор"); 
    // Создаем окно
    auto font = std::make_unique<sf::Font>(); // Загружаем шрифт
    if (!font->loadFromFile("arialmt.ttf")) {
        std::cerr << "Не удалось загрузить шрифт!\n";
        return -1;
    }

    Calculator calculator(*font); // Создаем калькулятор

    while (window.isOpen()) { // Главный цикл
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) window.close(); 
            // Закрытие окна
            calculator.handleEvent(event, window); // Обработка событий
        }

        window.clear(); // Очистка экрана
        window.draw(calculator); // Отрисовка калькулятора
        window.display(); // Показываем результат
    }
    return 0;
}

Точка входа — это стандартный цикл SFML. Окно 400x600 выбрал как компромисс между компактностью и читаемостью. Шрифт взял Arial, потому что он универсален и не требует возни с лицензиями — в продакшене я бы добавил fallback на системный шрифт через sf::Font::loadFromMemory или проверку через std::filesystem. SFML тут стабильно рендерит всё без сюрпризов, хотя я заметил, что при частых кликах FPS может проседать — это не баг библиотеки, а моя реализация без оптимизаций.

Рефлексия: что получилось и что можно лучше

Проект занял у меня пару часов в субботу вечером, и результат меня приятно удивил. Калькулятор считает выражения вроде "2 + 3 * (4 - 1)" (правильно выдаёт 11), ловит ошибки вроде деления на ноль или незакрытых скобок, и выглядит аккуратно. SFML показала себя с лучшей стороны: рендеринг быстрый, API интуитивный, никаких глюков с памятью или шрифтами. C++20 тоже не подвёл: std::string_view экономит копирования, ends_with упрощает обработку строк, а std::from_chars делает парсинг чисел шустрым.

Нет предела совершенству, что можно улучшить:

Десятичные числа. Сейчас парсер понимает только целые — надо добавить поддержку точек и, возможно, научные форматы вроде "1.23e-4".

Производительность. Для коротких выражений мой рекурсивный спуск норм, но на длинных строках (например, 100 операторов) лучше взять стековый алгоритм или подключить Boost.Spirit. Я даже прикинул, как это сделать, но для демки оставил как есть.

UI/UX. Клавиатурный ввод был бы логичным дополнением — сейчас только мышью тыкать. Ещё можно добавить масштабируемость окна, тёмную тему или анимации переходов между состояниями.

Тестирование. Я писал на коленке, но в реальном проекте нужны юнит-тесты для парсера — хотя бы на базовые случаи вроде "2+2", "1/0" и "(2+3)*4".

Логирование. Ошибки сейчас просто пишут "Error" на дисплей. В продакшене я бы вывел их в файл или консоль с деталями: где упало, что ввели.

Оптимизация рендеринга. SFML немного подтормаживает при частых кликах — можно добавить дебаунсинг на события или перерисовывать только изменённые элементы через dirty rectangles.

Ещё я подумал про локализацию — например, заменить точку на запятую для регионов, где так принято, но это уже избыточно для такого проекта. В целом, SFML 2.6.1 дала мне ровно то, что я хотел: быстрый старт и минимум головной боли.

Чистая архитектура в играх на SFML С++: как разложить код по полочкам

2025-03-15T14:05:15.145Z

Привет, разработчики! Сегодня поговорим о том, как применить чистую архитектуру (Clean Architecture) в разработке игр с использованием библиотеки SFML. Если вы хотите, чтобы ваш код был модульным, тестируемым и не привязанным к конкретной библиотеке, этот подход для вас. Давайте разберем, как разделить код на слои и сделать вашу игру структурированной и гибкой.

Что такое чистая архитектура?

Чистая архитектура — это концепция, предложенная Робертом Мартином (дядей Бобом), которая помогает организовать код так, чтобы он был:

Независимым от фреймворков (в нашем случае — SFML).
Тестируемым без запуска всей игры.
Четко разделенным по зонам ответственности.

Идея в том, чтобы игровая логика не знала о том, как рисуются спрайты или как обрабатываются нажатия клавиш. Вместо этого мы разбиваем код на слои, где каждый слой делает свою работу.

Слои чистой архитектуры в игре

Представьте игру как торт: каждый слой — это отдельный уровень со своей задачей. Вот как это может выглядеть в контексте SFML:

Структура проекта

1. Сущности (Entities)

Это сердце игры — основные объекты, такие как игрок, враги или пули. Они содержат данные (позицию, здоровье, скорость) и базовую логику, но не знают ничего о SFML.

Пример:

class Player {
public:
    float x, y;
    float speed;
    int health;

    void move(float dx, float dy) {
        x += dx * speed;
        y += dy * speed;
    }
};

2. Бизнес-логика (Use Cases / Interactors)

Здесь живут правила игры. Это слой, который отвечает за "что происходит". Например, движение игрока, проверка столкновений или условия победы.

Пример:

class MovePlayerUseCase {
public:
    void execute(Player& player, float dx, float dy) {
        player.move(dx, dy);
    }
};

3. Интерфейсы (Controllers / Presenters)

Этот слой связывает бизнес-логику с внешним миром. Например:

InputController — превращает нажатия клавиш в команды для игры.
Renderer — отвечает за отрисовку.

Пример обработки ввода:

class InputController {
public:
    void handleInput(sf::RenderWindow& window, 
    MovePlayerUseCase& moveUseCase, Player& player) {
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) {
            moveUseCase.execute(player, 0, -1);
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) {
            moveUseCase.execute(player, 0, 1);
        }
    }
};

4. Инфраструктура (Frameworks & Drivers)

Тут живет код, который зависит от SFML: рендеринг, обработка событий, создание окон. Этот слой изолирован от остальной логики.

Пример рендеринга:

class SfmlRenderer {
public:
    void render(sf::RenderWindow& window, const Player& player) {
        sf::CircleShape shape(20.f);
        shape.setPosition(player.x, player.y);
        shape.setFillColor(sf::Color::Green);
        window.draw(shape);
    }
};

Собираем игру: главный цикл

Теперь соединим всё в главном цикле игры.

Вот пример:

#include <SFML/Graphics.hpp>
#include "Entities/Player.hpp"
#include "UseCases/MovePlayerUseCase.hpp"
#include "Interfaces/InputController.hpp"
#include "Infrastructure/SfmlRenderer.hpp"

int main() {
    sf::RenderWindow window(sf::VideoMode(800, 600), "Clean SFML Game");

    Player player{400.f, 300.f, 5.f, 100}; // Начальная позиция и параметры
    MovePlayerUseCase moveUseCase;
    InputController inputController;
    SfmlRenderer renderer;

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }

        // Ввод
        inputController.handleInput(window, moveUseCase, player);

        // Рендеринг
        window.clear();
        renderer.render(window, player);
        window.display();
    }

    return 0;
}

Почему это круто?

Гибкость: Хотите заменить SFML на SDL? Просто перепишите слой инфраструктуры — остальной код не тронется.
Тестируемость: Можно проверять логику движения или столкновений без запуска окна.
Порядок: Каждый слой отвечает за своё, и код становится читаемым.

Полезные советы

Используйте абстрактные классы или интерфейсы, чтобы слои общались через четкие границы.

Не храните состояние игры (например, координаты) в объектах SFML — держите их в сущностях.

Избегайте соблазна смешивать логику с рендерингом — это путь к хаосу.

Чистая архитектура в играх на SFML — это не просто модный подход, а способ сделать ваш проект масштабируемым и удобным для поддержки. Да, на старте придется потратить чуть больше времени на разделение кода, но в долгосрочной перспективе это окупается.

Если у вас есть вопросы или вы хотите разобрать конкретный пример — пишите в комментариях!

А как вы организуете код в своих играх? Делитесь опытом!

Телеграмм канал - Программирование игр С++

Визуализация быстрой сортировки с SFML и C++20

2025-03-08T15:04:05.096Z

В этой статье мы создадим интерактивную визуализацию алгоритма быстрой сортировки (QuickSort) с использованием библиотеки SFML и современных возможностей C++20. Этот проект поможет вам лучше понять, как работает один из самых популярных алгоритмов сортировки, и покажет, как можно комбинировать графику и алгоритмы для создания образовательных инструментов.

Зачем визуализировать алгоритмы?

Алгоритмы сортировки, такие как QuickSort, могут быть сложными для понимания, особенно для новичков.

Визуализация помогает:

Увидеть, как данные перемещаются и сравниваются на каждом шаге.
Понять концепции разбиения и рекурсии.
Сделать обучение более интерактивным и увлекательным.

Если вы хотите не только изучить алгоритмы, но и создать что-то наглядное и красивое, этот проект для вас!

Что нам понадобится?

SFML: Библиотека для работы с графикой, событиями и окнами. Скачать и установить.

Компилятор с поддержкой C++20: Например, GCC или Clang.

Базовые знания C++: Работа с векторами, лямбда-функциями и рекурсией.

Описание проекта

Цель

Создать программу, которая:

Генерирует случайный массив чисел.
Визуализирует его как набор столбцов.
Анимирует процесс сортировки с помощью QuickSort.

Особенности

Использование std::ranges из C++20 для удобной работы с диапазонами.

Рекурсивная реализация QuickSort с визуализацией на каждом шаге.

Простая, но эффективная анимация с задержкой для наглядности.

Код проекта

Подготовка

Установите SFML и настройте ваш проект (например, через CMake или вручную подключите библиотеки).
Убедитесь, что ваш компилятор поддерживает C++20 (флаг -std=c++20).

Полный код

#include <SFML/Graphics.hpp>
#include <vector>
#include <ranges>
#include <random>
#include <chrono>
#include <thread>

int main() {
    // Настройки окна
    sf::RenderWindow window(sf::VideoMode(1280, 720), "QuickSort Visualization");
    window.setFramerateLimit(60);

    // Генерация случайного массива чисел
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(10, 700);

    std::vector<int> arr(150);
    for (auto& x : arr) x = dis(gen);

    // Функция быстрой сортировки с визуализацией процесса
    auto quickSort = [&](auto& range, int low, int high, auto& recur) mutable {
        if (low >= high) return; // Базовый случай рекурсии

        int pivot = range[high]; // Выбираем опорный элемент (последний в диапазоне)
        int i = low - 1;

        // Разделение элементов: меньшие идут влево, большие вправо
        for (int j = low; j < high; ++j) {
            if (range[j] <= pivot) {
                ++i;
                std::swap(range[i], range[j]);
            }
        }
        std::swap(range[i + 1], range[high]); // Устанавливаем опорный элемент на своё место
        int pi = i + 1; // Индекс опорного элемента

        // Рекурсивная сортировка левой и правой частей
        recur(range, low, pi - 1, recur);
        recur(range, pi + 1, high, recur);

        // Визуализация текущего состояния массива
        window.clear();
        float barWidth = static_cast<float>(window.getSize().x) / arr.size();
        for (int k = 0; k < arr.size(); ++k) {
            sf::RectangleShape bar(sf::Vector2f(barWidth - 1, arr[k]));
            bar.setPosition(k * barWidth, window.getSize().y - arr[k]);
            bar.setFillColor(sf::Color::White);
            window.draw(bar);
        }
        window.display();
        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // Задержка для анимации
        };

    // Используем std::ranges для удобной работы с массивом
    auto range = std::ranges::subrange(arr.begin(), arr.end());
    bool sorting = true; // Флаг, чтобы сортировка выполнялась только один раз

    // Основной цикл программы
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) window.close(); // Закрытие окна
        }

        if (sorting) {
            quickSort(range, 0, arr.size() - 1, quickSort); // Запуск сортировки
            sorting = false; // Отключаем повторную сортировку
        }

        // Отрисовка финального состояния массива
        window.clear();
        float barWidth = static_cast<float>(window.getSize().x) / arr.size();
        for (int i = 0; i < arr.size(); ++i) {
            sf::RectangleShape bar(sf::Vector2f(barWidth - 1, arr[i]));
            bar.setPosition(i * barWidth, window.getSize().y - arr[i]);
            bar.setFillColor(sf::Color::White);
            window.draw(bar);
        }
        window.display();
    }

    return 0;
}

Пояснения к коду

Генерация массива: Создаем вектор из 150 случайных чисел от 10 до 700 с помощью std::random_device и std::mt19937.

QuickSort: Реализован как лямбда-функция с рекурсией. На каждом шаге разбиения массива мы визуализируем текущее состояние.

Визуализация: Каждый элемент массива отображается как прямоугольник (sf::RectangleShape), высота которого пропорциональна значению элемента.

Анимация: Задержка в 50 миллисекунд (std::this_thread::sleep_for) между шагами сортировки создает эффект плавной анимации.

Как это работает?

При запуске программы генерируется случайный массив, который отображается как набор столбцов в окне SFML.
Алгоритм QuickSort начинает сортировку, и на каждом шаге разбиения массива окно обновляется, показывая текущее состояние.
После завершения сортировки вы видите отсортированный массив.

Попробуйте запустить код и понаблюдать за процессом — это действительно увлекательно!

Расширяемость проекта

Хотите сделать проект еще интереснее? Вот несколько идей:

Добавьте другие алгоритмы сортировки (например, пузырьковую или сортировку слиянием) и сравните их визуально.
Включите интерактивные элементы: кнопки для запуска сортировки или изменения скорости анимации.
Экспериментируйте с цветами: выделяйте опорный элемент (pivot) другим цветом для наглядности.

Заключение

Визуализация алгоритмов — это мощный инструмент для обучения и отладки. С помощью SFML и C++20 вы можете создавать не только полезные, но и красивые образовательные проекты. Этот пример демонстрирует, как комбинировать графику, алгоритмы и современные возможности языка для создания интерактивных приложений.

Попробуйте улучшить этот проект: добавьте звуковые эффекты, измените стиль визуализации или реализуйте другой алгоритм. Делитесь своими идеями в комментариях — мне будет интересно узнать, что вы придумали!

Телеграмм канал - Программирование игр С++

CRTP в игровых механиках

2025-03-02T19:10:20.797Z

В мире разработки игр часто возникает необходимость создавать гибкие и производительные системы. Одним из мощных инструментов в C++ для достижения этой цели является CRTP — Curiously Recurring Template Pattern. Сегодня мы разберём, как CRTP может помочь в создании игровых механик, и реализуем простой пример с использованием библиотеки SFML.

Что такое CRTP?

CRTP — это шаблонный паттерн в C++, где базовый класс является шаблоном, а производный класс передаётся в качестве параметра шаблона самому себе. Это позволяет базовому классу вызывать методы производного класса без использования виртуальных функций, что даёт выигрыш в производительности за счёт статической диспетчеризации.

Пример структуры CRTP:

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() {
        // Реализация в производном классе
    }
};

Зачем использовать CRTP в играх?

Производительность: Виртуальные функции добавляют накладные расходы из-за таблицы vtable. CRTP позволяет обойтись без них.
Гибкость: Легко добавлять новые типы объектов с общей логикой.
Типобезопасность: Компилятор проверяет корректность типов на этапе компиляции.

В игровых механиках это особенно полезно для систем вроде управления объектами (игроки, враги, снаряды), где нужно минимизировать задержки и упростить расширение.

Cистема игровых объектов с SFML

Давайте создадим простую систему игровых сущностей с использованием CRTP и SFML. Мы реализуем базовый класс GameObject, от которого будут наследоваться Player и Enemy. Каждый объект будет обновляться и отрисовываться через SFML.

Перед началом убедитесь, что у вас установлена библиотека SFML.

Минимальные зависимости:

sfml-graphics
sfml-window
sfml-system

Создадим абстрактный базовый класс IGameObject и шаблонный класс с CRTP для реализации общей логики игровых объектов GameObject.

#pragma once
#include <SFML/Graphics.hpp>

// Абстрактный базовый класс для всех игровых объектов
class IGameObject {
public:
    // Виртуальный деструктор для корректного удаления объектов
    virtual ~IGameObject() = default; 
    // Чисто виртуальный метод для обновления состояния объекта
    virtual void update(float deltaTime) = 0; 
    // Чисто виртуальный метод для отрисовки объекта
    virtual void draw(sf::RenderWindow& window) = 0; 
    // Чисто виртуальный метод для получения позиции объекта
    virtual sf::Vector2f getPosition() const = 0; 
};

#pragma once

#include <SFML/Graphics.hpp>
// Шаблонный класс с CRTP для реализации общей логики игровых объектов
template <typename Derived>
class GameObject : public IGameObject {
public:
    // Переопределяем метод update, вызывая реализацию из производного класса
    void update(float deltaTime) override {
        static_cast<Derived*>(this)->updateImpl(deltaTime);
    }

    // Переопределяем метод draw, вызывая реализацию из производного класса
    void draw(sf::RenderWindow& window) override {
        static_cast<Derived*>(this)->drawImpl(window);
    }

    // Переопределяем метод getPosition, вызывая реализацию из производного класса
    sf::Vector2f getPosition() const override {
        return static_cast<const Derived*>(this)->getPositionImpl();
    }
};

В этом коде:

update обновляет состояние объекта.
draw отвечает за отрисовку.
getPosition возвращает позицию объекта.

Методы вызывают соответствующие реализации в производных классах через static_cast.

Теперь определим два игровых объекта: Player (игрок) и Enemy (враг).

#pragma once
#include "GameObject.h"
// Класс игрока, наследующийся от GameObject с использованием CRTP
class Player : public GameObject<Player> {
private:
    // Графический объект — круг для представления игрока
    sf::CircleShape shape; 
    // Позиция игрока на экране
    sf::Vector2f position = sf::Vector2f(200.0f, 200.0f); 
    // Скорость перемещения игрока
    float speed = 200.0f;  

public:
    // Конструктор игрока
    Player() { 
    // Устанавливаем радиус круга
        shape.setRadius(20.0f); 
    // Задаём зелёный цвет
        shape.setFillColor(sf::Color::Green);
    // Устанавливаем позицию круга
        shape.setPosition(position);     
    }

    // Реализация обновления состояния игрока
    void updateImpl(float deltaTime) {
        // Движение влево
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) position.x -= speed * deltaTime; 
        // Движение вправо
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) position.x += speed * deltaTime; 
        // Движение вверх
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) position.y -= speed * deltaTime;
        // Движение вниз
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) position.y += speed * deltaTime; 
        // Обновляем позицию графического объекта
        shape.setPosition(position); 
    }

    // Реализация отрисовки игрока
    void drawImpl(sf::RenderWindow& window) const {
    // Отрисовываем круг в окне
        window.draw(shape); 
    }

    // Реализация получения позиции игрока
    sf::Vector2f getPositionImpl() const {
    // Возвращаем текущую позицию
        return position; 
    }
};

#pragma once  
#include "GameObject.h"  
// Класс врага, наследующийся от GameObject с использованием CRTP  
class Enemy : public GameObject<Enemy> {  
private:  
// Графический объект — прямоугольник для врага
    sf::RectangleShape shape;
// Позиция врага на экране
   sf::Vector2f position = {400.0f, 300.0f}; 
// Скорость перемещения врага  
   float speed = 100.0f;     

public:
// Конструктор врага
   Enemy() { 
// Устанавливаем размер прямоугольника 
       shape.setSize({ 30.0f, 30.0f });
// Задаём красный цвет 
       shape.setFillColor(sf::Color::Red); 
// Устанавливаем позицию прямоугольника
       shape.setPosition(position);           
   }  

   // Реализация обновления состояния врага  
   void updateImpl(float deltaTime) {  
// Движение врага по горизонтали  
       position.x += speed * deltaTime;
// Разворот при достижении границ  
       if (position.x > 700 || position.x < 100) speed = -speed; 
// Обновляем позицию графического объекта 
       shape.setPosition(position);  
   }  

   // Реализация отрисовки врага  
   void drawImpl(sf::RenderWindow& window) const { 
// Отрисовываем прямоугольник в окне
       window.draw(shape);   
   }  

   // Реализация получения позиции врага  
   sf::Vector2f getPositionImpl() const { 
// Возвращаем текущую позицию 
       return position;  
   }  
};

Теперь соберём всё вместе в главном файле.

#include <SFML/Graphics.hpp> 
#include <vector>            
#include <memory>            
#include "IGameObject.h"     
#include "GameObject.h"      
#include "Player.h"          
#include "Enemy.h"           

// Основная функция программы
int main() {
// Создаём окно 800x600
    sf::RenderWindow window(sf::VideoMode(800, 600), "CRTP Game Example"); 
// Ограничиваем частоту кадров до 60 FPS
    window.setFramerateLimit(60); 

    // Вектор умных указателей для хранения всех игровых объектов
    std::vector<std::unique_ptr<IGameObject>> objects;
// Добавляем игрока в вектор
    objects.push_back(std::make_unique<Player>()); 
// Добавляем врага в вектор
    objects.push_back(std::make_unique<Enemy>());  
// Часы для расчёта времени между кадрами
    sf::Clock clock; 
// Главный игровой цикл
    while (window.isOpen()) { 
        sf::Event event;
// Обрабатываем события
        while (window.pollEvent(event)) { 
// Закрываем окно при нажатии на крестик
            if (event.type == sf::Event::Closed) window.close(); 
        }
// Вычисляем время с последнего кадра
        float deltaTime = clock.restart().asSeconds(); 

        // Обновляем состояние всех объектов
        for (auto const& obj : objects) {
            obj->update(deltaTime);
        }
// Очищаем окно перед отрисовкой
        window.clear(); 
        // Отрисовываем все объекты
        for (auto const& obj : objects) {
            obj->draw(window);
        }
        // Отображаем нарисованное на экране
        window.display(); 
    }

    return 0; 
}

Как это работает?

Player управляется клавишами W, A, S, D и отображается как зелёный круг.

Enemy движется автоматически влево-вправо и отображается как красный квадрат.

Базовый класс GameObject через CRTP вызывает методы конкретных классов (Player или Enemy) без виртуальных функций.

Преимущества подхода

Скорость: Отсутствие vtable ускоряет вызовы методов.

Расширяемость: Чтобы добавить новый тип объекта (например, Projectile), достаточно унаследовать его от GameObject<Projectile> и реализовать нужные методы.

Простота: Логика обновления и отрисовки сосредоточена в одном месте.

Итог

CRTP — это мощный инструмент для игровых движков, где важны производительность и гибкость. В примере с SFML мы создали систему объектов, которую легко расширить без потери скорости. Попробуйте добавить новые сущности вроде снарядов или бонусов — это займёт всего несколько строк кода!

vtable (от англ. virtual table) — это механизм в C++, который используется для реализации динамического полиморфизма через виртуальные функции. Когда вы объявляете функцию в базовом классе как virtual, компилятор создаёт специальную таблицу указателей (vtable) для каждого класса, который содержит виртуальные функции. Эта таблица хранит адреса реализаций виртуальных методов для конкретного класса.

Телеграмм канал - Программирование игр С++

Разработка игр на C++

2025-02-26T22:33:55.612Z

Разработка игр на C++ — это увлекательный и сложный процесс, который требует понимания как самого языка программирования, так и основ игрового дизайна, математики и компьютерной графики. C++ является одним из самых популярных языков для создания игр благодаря своей производительности и гибкости. В этом введении мы рассмотрим основные этапы и концепции, которые помогут вам начать путь в разработке игр на C++.

1. Основы C++

Прежде чем приступать к созданию игр, важно освоить базовые концепции языка C++:

Типы данных и переменные: int, float, double, char, bool и т.д.

Управляющие конструкции: if, else, switch, циклы (for, while, do-while).

Функции: создание и использование функций, передача параметров, возврат значений.

Классы и объекты: основы объектно-ориентированного программирования (ООП).

Указатели и ссылки: работа с динамической памятью.

STL (Standard Template Library): использование контейнеров (vector, map, set) и алгоритмов.

2. Основы разработки игр

Разработка игр включает в себя несколько ключевых аспектов:

Игровой цикл: основной цикл игры, который обновляет состояние игры и отрисовывает кадры.

Графика: работа с 2D и 3D графикой, использование библиотек для рендеринга.

Физика: реализация физических взаимодействий (гравитация, столкновения и т.д.).

Звук: добавление звуковых эффектов и музыки.

Управление: обработка ввода от пользователя (клавиатура, мышь, геймпад).

Искусственный интеллект (ИИ): создание поведения для NPC (неигровых персонажей).

3. Библиотеки и фреймворки для разработки игр

Для упрощения разработки игр на C++ используются различные библиотеки и фреймворки. Вот некоторые из них:

SFML (Simple and Fast Multimedia Library): библиотека для работы с графикой, звуком и вводом. Отлично подходит для 2D-игр.

SDL (Simple DirectMedia Layer): кросс-платформенная библиотека для работы с графикой, звуком и вводом.

OpenGL: низкоуровневая библиотека для работы с 3D-графикой.

Unreal Engine: мощный игровой движок, который использует C++ для написания логики игр.

Unity (с использованием C++ через плагины): популярный игровой движок, который поддерживает C++ для расширения функциональности.

Godot: открытый игровой движок, который также поддерживает C++.

4. Создание простой игры

Давайте рассмотрим основные шаги для создания простой 2D-игры на C++ с использованием SFML:

Шаг 1: Установка SFML

Скачайте и установите SFML с официального сайта: https://www.sfml-dev.org/.
Настройте проект в вашей IDE (например, Visual Studio, Code::Blocks или CLion).

Шаг 2: Создание окна игры

#include <SFML/Graphics.hpp>

int main() {
    sf::RenderWindow window(sf::VideoMode(800, 600), "My Game");

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }

        window.clear();
        // Здесь будет отрисовка объектов
        window.display();
    }

    return 0;
}

Шаг 3: Добавление спрайта

#include <SFML/Graphics.hpp>

int main() {
    sf::RenderWindow window(sf::VideoMode(800, 600), "My Game");

    // Загрузка текстуры и создание спрайта
    sf::Texture texture;
    if (!texture.loadFromFile("player.png")) {
        return -1;
    }
    sf::Sprite player(texture);
    player.setPosition(400, 300);

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }

        window.clear();
        window.draw(player); // Отрисовка спрайта
        window.display();
    }

    return 0;
}

Шаг 4: Обработка ввода

if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
    player.move(-0.1f, 0.0f);
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
    player.move(0.1f, 0.0f);
}

Заключение

Разработка игр на C++ — это сложный, но очень интересный процесс. Начните с простых проектов, постепенно углубляя свои знания в области графики, физики и ИИ. Используйте доступные библиотеки и движки, чтобы ускорить разработку. Удачи в создании ваших игр!

Телеграмм канал - Программирование игр С++

Построение минимального дерева Штейнера в евклидовой плоскости

2025-02-02T17:38:43.736Z

Условие:

Даны три точки в евклидовой плоскости с координатами A(x1,y1), B(x2,y2) и C(x3,y3). Необходимо построить минимальное дерево, соединяющее эти точки с минимальной общей длиной рёбер.

Разрешается добавление одной дополнительной точки S(xs,ys)(точки Штейнера), которая может уменьшить суммарную длину соединяющих отрезков.

Требования:

Найти координаты точки S, которая минимизирует сумму расстояний от неё до заданных точек.
Визуализировать полученное дерево с помощью библиотеки SFML.
Вывести терминальные точки (красным), точку Штейнера (синим) и соединяющие рёбра (жёлтым).

Формат входных данных:

На вход подаются три пары вещественных чисел (x1,y1), (x2,y2), (x3,y3) — координаты заданных точек.

Формат выходных данных:

Программа должна:

Вычислить координаты точки Штейнера S(xs,ys).
Вывести общую длину построенного дерева.
Открыть графическое окно с визуализацией результата.

Пример работы программы:

Входные данные:

Выходные данные:

Порядок решения задачи о минимальном дереве Штейнера

Шаг 1: Определение входных данных

Заданы три точки A(x1,y1), B(x2,y2) и C(x3,y3) в евклидовой плоскости. Нужно найти минимальное дерево, соединяющее их, с возможностью добавления одной точки Штейнера S(xs,ys), которая минимизирует сумму расстояний.

Шаг 2: Поиск точки Штейнера

Метод градиентного спуска применяется для нахождения оптимальной точки S.

Начальная точка

Используем центр масс терминальных точек в качестве начальной точки

2. Минимизация суммы расстояний

Вычисляем сумму расстояний от текущего положения S до всех терминалов:

Двигаемся в направлениях вверх, вниз, влево и вправо с некоторым шагом Δ, уменьшая его, когда не находим лучшего положения.
Останавливаемся, когда шаг становится меньше заданной точности.

Шаг 3: Визуализация графа (SFML)

После нахождения S(xs,ys), строим дерево:

Рисуем точки:

Красные круги для терминальных точек A,B,C.
Синяя точка для найденной точки Штейнера.

Рисуем рёбра:

Жёлтые линии от точки S к каждой из терминальных точек.

Отображение в окне SFML

Создаём окно SFML.
Отображаем точки и соединяющие линии.
Обновляем экран.

Шаг 4: Вывод результатов

Вывод координат точки Штейнера
Вывод длинны минимального дерева
Графическое представление :

- Красные точки — исходные точки

- Синяя точка — точка Штейнера

- Жёлтые линии — минимальное дерево

Код программы

#include <SFML/Graphics.hpp>
#include <iostream>
#include <cmath>
#include <vector>
#include <limits>

using namespace std;
using namespace sf;

struct Point {
    double x, y;
};

// Вычисление расстояния между двумя точками
double distance(Point a, Point b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

// Сумма расстояний от точки p до всех остальных
double totalDistance(Point p, const vector<Point>& terminals) {
    double sum = 0;
    for (const auto& t : terminals) {
        sum += distance(p, t);
    }
    return sum;
}

// Метод градиентного спуска для поиска точки Штейнера
Point steinerPoint(const vector<Point>& terminals) {
    double step = 0.1;
    double precision = 1e-6;
    Point steiner = { 0, 0 };

    for (const auto& t : terminals) {
        steiner.x += t.x;
        steiner.y += t.y;
    }
    steiner.x /= terminals.size();
    steiner.y /= terminals.size();

    double prevDist = totalDistance(steiner, terminals);

    while (step > precision) {
        bool improved = false;

        for (double dx : {-step, step}) {
            for (double dy : {-step, step}) {
                Point newPoint = { steiner.x + dx, steiner.y + dy };
                double newDist = totalDistance(newPoint, terminals);

                if (newDist < prevDist) {
                    steiner = newPoint;
                    prevDist = newDist;
                    improved = true;
                }
            }
        }

        if (!improved) {
            step /= 2;
        }
    }

    return steiner;
}

// Основная функция
int main() {
    // Размер окна
    const int WIDTH = 600, HEIGHT = 600;

    // Исходные точки
    vector<Point> terminals = { {100, 500}, {500, 500}, {300, 100}};

    // Найдём точку Штейнера
    Point s = steinerPoint(terminals);

    // Создание окна SFML
    RenderWindow window(VideoMode(WIDTH, HEIGHT), "Steiner Tree Visualization");

    while (window.isOpen()) {
        Event event;
        while (window.pollEvent(event)) {
            if (event.type == Event::Closed)
                window.close();
        }

        // Очистка экрана
        window.clear(Color::Black);

        // Рисуем рёбра (жёлтые линии)
        for (const auto& t : terminals) {
            Vertex line[] = {
                Vertex(Vector2f(s.x, s.y), Color::Yellow),
                Vertex(Vector2f(t.x, t.y), Color::Yellow)
            };
            window.draw(line, 2, Lines);
        }

        // Рисуем терминальные точки (красные)
        for (const auto& t : terminals) {
            CircleShape terminal(5);
            terminal.setPosition(t.x - 5, t.y - 5);
            terminal.setFillColor(Color::Red);
            window.draw(terminal);
        }

        // Рисуем точку Штейнера (синяя)
        CircleShape steiner(5);
        steiner.setPosition(s.x - 5, s.y - 5);
        steiner.setFillColor(Color::Blue);
        window.draw(steiner);

        // Отображение кадра
        window.display();
    }

    return 0;
}

Итог

Метод использует градиентный спуск для поиска точки Штейнера и SFML для визуализации. Это позволяет эффективно решать задачу и демонстрировать результат в графическом окне.

Телеграмм канал - Программирование игр С++/С#

Паттерны состояния (State) и стратегии (Strategy) в играх на C++

2025-02-02T13:51:28.104Z

В мире разработки игр существует множество способов улучшить код и сделать его более гибким и масштабируемым. Два популярных паттерна, которые часто используются в этой области, - это паттерны состояния (State) и стратегии (Strategy). В этой статье мы подробно рассмотрим каждый из них и объясним, как их можно применять в разработке игр.

Паттерн состояния (State)

Паттерн состояния - это поведенческий паттерн проектирования, который позволяет объекту изменять свое поведение в зависимости от своего внутреннего состояния. Вместо того чтобы использовать условные операторы для обработки различных состояний объекта, мы можем делегировать ответственность за каждое состояние отдельному классу. Представьте себе персонажа в игре, который может находиться в разных состояниях: "стоит", "идет", "прыгает", "атакует" и т.д. С помощью паттерна состояния мы можем создать отдельный класс для каждого из этих состояний, и каждый класс будет отвечать за конкретное поведение персонажа.

Преимущества использования паттерна состояния

Улучшение читаемости кода: Код становится более структурированным и понятным, так как логика каждого состояния отделена от основной логики объекта.

Упрощение добавления новых состояний: Добавить новое состояние становится легко, достаточно создать новый класс, реализующий интерфейс состояния.

Повышение гибкости: Изменение поведения объекта в зависимости от состояния становится более гибким и управляемым.

Паттерн стратегии (Strategy)

Паттерн стратегии - это также поведенческий паттерн проектирования, который позволяет выбирать алгоритм или стратегию во время выполнения программы. Вместо того чтобы жестко задавать алгоритм в коде, мы можем предоставить возможность выбора из нескольких доступных стратегий. Рассмотрим игру, в которой персонаж может использовать разные виды оружия: меч, лук, магический посох и т.д. С помощью паттерна стратегии мы можем создать отдельный класс для каждого вида оружия, и каждый класс будет реализовывать свою собственную стратегию атаки.

Преимущества использования паттерна стратегии

Гибкость выбора алгоритма: Мы можем легко менять алгоритм или стратегию во время выполнения программы, не изменяя основной код.

Улучшение масштабируемости: Добавление новых стратегий становится простым и не требует изменения существующего кода.

Повышение производительности: Мы можем выбирать наиболее подходящую стратегию в зависимости от ситуации, что может привести к улучшению производительности игры.

Пример кода моделей поведения игрового бота, используя оба паттерна.

#include <iostream>
#include <memory>

// Предварительное объявление класса Bot
class Bot;

// Базовый интерфейс состояния
class State {
public:
    virtual ~State() = default;
// Метод для обработки состояния бота
    virtual void handle(Bot& bot) = 0;  
};

// --- Реализация состояний ---

// Состояние "Спокойствие" - когда бот не активен, патрулирует.
class IdleState : public State {
public:
    void handle(Bot& bot) override;  // Переход к следующему состоянию
};

// Состояние "Охота" - когда бот преследует цель.
class ChaseState : public State {
public:
    void handle(Bot& bot) override;  // Переход к следующему состоянию
};

// Состояние "Атака" - когда бот готовится атаковать цель.
class AttackState : public State {
public:
    void handle(Bot& bot) override;  // Переход к следующему состоянию
};

// Класс бота
class Bot {
protected:
    std::shared_ptr<State> currentState;  // Текущее состояние бота

public:
    Bot();  // Конструктор, инициализирующий начальное состояние
    void setState(std::shared_ptr<State> newState);  // Установка нового состояния
    virtual void update();  // Обновление состояния бота
    virtual void attack() {}  // Виртуальная функция атаки (будет переопределена)
};

// Конструктор бота: начальное состояние - "Спокойствие"
Bot::Bot() : currentState(std::make_shared<IdleState>()) {}

void Bot::setState(std::shared_ptr<State> newState) {
    currentState = std::move(newState);  // Меняем состояние на новое
}

void Bot::update() {
    if (currentState) {
        currentState->handle(*this);  // Обработка текущего состояния
    }
}

// Реализация методов состояний

// В состоянии "Спокойствие" бот патрулирует, затем переходит в состояние "Охота"
void IdleState::handle(Bot& bot) {
    std::cout << "Бот патрулирует...\n";
    bot.setState(std::make_shared<ChaseState>());  // Переход к состоянию охоты
}

// В состоянии "Охота" бот преследует игрока, затем переходит в состояние "Атака"
void ChaseState::handle(Bot& bot) {
    std::cout << "Бот преследует игрока!\n";
    bot.setState(std::make_shared<AttackState>());  // Переход к состоянию атаки
}

// В состоянии "Атака" бот готовится атаковать, затем выполняет атаку и переходит в состояние "Спокойствие"
void AttackState::handle(Bot& bot) {
    std::cout << "Бот готовится к атаке!\n";
    bot.attack();  // Вызов функции атаки
    bot.setState(std::make_shared<IdleState>());  // Переход в спокойное состояние
}

// --- Реализация стратегий атаки ---

// Интерфейс стратегии атаки
class AttackStrategy {
public:
    virtual ~AttackStrategy() = default;
    virtual void attack() = 0;  // Метод для выполнения атаки
};

// Реализация атаки в ближнем бою
class MeleeAttack : public AttackStrategy {
public:
    void attack() override {
        std::cout << "Бот атакует в ближнем бою!\n";  // Атака в ближнем бою
    }
};

// Реализация атаки дальнего боя
class RangedAttack : public AttackStrategy {
public:
    void attack() override {
        std::cout << "Бот стреляет издалека!\n";  // Атака дальнего боя
    }
};

// Добавление поддержки стратегии атаки в бота
class BotWithStrategy : public Bot {
private:
    std::shared_ptr<AttackStrategy> attackStrategy;  // Стратегия атаки

public:
    BotWithStrategy();  // Конструктор, устанавливающий начальную стратегию атаки
    void setAttackStrategy(std::shared_ptr<AttackStrategy> newStrategy);  // Установка новой стратегии атаки
    void attack() override;  // Переопределенная атака
};

// Конструктор бота с поддержкой стратегии, начальная стратегия - ближний бой
BotWithStrategy::BotWithStrategy()
    : Bot(), attackStrategy(std::make_shared<MeleeAttack>()) {}

void BotWithStrategy::setAttackStrategy(std::shared_ptr<AttackStrategy> newStrategy) {
    attackStrategy = std::move(newStrategy);  // Устанавливаем новую стратегию атаки
}

void BotWithStrategy::attack() {
    if (attackStrategy) {
        attackStrategy->attack();  // Выполняем атаку с текущей стратегией
    }
    else {
        std::cout << "Стратегия атаки не установлена!\n";  // Если стратегия не установлена
    }
}

// --- Тестирование ---

int main() {
    system("chcp 1251>null");

    BotWithStrategy bot;  // Создаем объект бота с поддержкой стратегии

    // Симуляция игрового цикла
    bot.update();  // Бот патрулирует...
    bot.update();  // Бот преследует игрока!
    bot.update();  // Бот готовится к атаке!
    // Бот атакует в ближнем бою!

    // Меняем стратегию атаки на дальний бой
    bot.setAttackStrategy(std::make_shared<RangedAttack>());

    // Ещё один цикл для демонстрации изменения стратегии
    bot.update();  // Бот патрулирует...
    bot.update();  // Бот преследует игрока!
    bot.update();  // Бот готовится к атаке!
    // Бот стреляет издалека!
    system("pause");
    return 0;
}

Заключение

Паттерны состояния и стратегии - это мощные инструменты, которые могут значительно улучшить качество вашего кода при разработке игр. Они помогают сделать код более читаемым, гибким и масштабируемым. Использование этих паттернов может привести к созданию более сложных и интересных игровых механик.

Телеграмм канал - Программирование игр С++/С#

Задача "Испытание автомата"

2025-01-18T16:13:43.507Z

Компания Bookface, основанная в Ужляндии, где работает Степан, решила установить в своих офисах автоматы по продаже чая и кофе, чтобы программисты могли с пользой провести время во время перерывов. Стоимость стаканчика чая или кофе в автомате установлена равной пяти ужикам (местная валюта Ужляндии). Автоматы принимают монеты по 5 и 10 ужиков, а также купюры номиналом 10, 50 и 100 ужиков.

Если программисту необходимо дать сдачу (то есть он оплатил монетой 10 ужиков или купюрой 10, 50, 100 ужиков), автомат выдает сдачу монетами по 5 ужиков. Если программист заплатил монетой в 5 ужиков, автомат сохраняет её и может использовать для сдачи следующим покупателям.

Очевидно, что для обеспечения возможности выдачи сдачи всем программистам потребуется заранее загрузить в автомат некоторое количество монет номиналом 5 ужиков. Известен порядок, в котором программисты производили оплату. Ваша задача — определить минимальное количество монет номиналом 5 ужиков, которые нужно было загрузить в автомат перед началом рабочего дня, чтобы всем покупателям хватило сдачи.

Входные данные:

В первой строке входного файла дано одно натуральное число N — количество покупок, совершенных в ходе испытания (1≤N≤50,000).
Во второй строке записаны N натуральных чисел, каждое из которых соответствует номиналу монеты или купюры, которую использовал очередной программист для оплаты (5,10,50,100).

Выходные данные:

Выведите одно число — минимальное количество монет номиналом 5 ужиков, которые нужно загрузить в автомат перед началом рабочего дня.

Примеры ввода и вывода данных:

Код решения задача на С++

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n; // Количество покупок
    cin >> n;

    vector<int> payments(n); // Массив для хранения номиналов оплат
    for (int i = 0; i < n; ++i) {
        cin >> payments[i];
    }

    int coins_in_machine = 0; // Текущее количество монет в автомате
    int min_initial_coins = 0; // Минимальное начальное количество монет

    for (int payment : payments) {
        if (payment == 5) {
            // Если программист платит монетой 5 ужиков
            coins_in_machine += 1;
        } else {
            // Расчёт сдачи
            int change_needed = (payment - 5) / 5;
            if (coins_in_machine >= change_needed) {
                // Если в автомате хватает монет на сдачу
                coins_in_machine -= change_needed;
            } else {
                // Если не хватает монет, нужно добавить в автомат
                min_initial_coins += change_needed - coins_in_machine;
                coins_in_machine = 0; // Использовали все монеты
            }
        }
    }

    cout << min_initial_coins << endl; // Вывод минимального количества монет
    return 0;
}

Телеграмм канал - Программирование игр С++/С#

Искусство разработки игр

Разработка игры "Пятнашки" на SFML C++

Подготовка среды разработки

Например:

Скачайте и установите SFML:

Общая структура проекта

Базовый класс Screen — основа всех экранов

Основные компоненты класса

Реализация класса ResourceManager с поддержкой ресурсов Windows

Кастомный класс Button для интерфейса

Анимированный разноцветный текст, класс ColorfulText

Возможности данного класса

Плавный переход между экранами в игре, класс Transition

Возможности данного класса:

Реализация игры “Пятнашки” в классе FifteenPuzzle, который наследуется от sf::Drawable для отрисовки.

Инициализация

Перемешивание

Обработка кликов

Отрисовка

Проверка решения

Создаём главное меню для игры "Пятнашки", класс MainMenu

Создание игрового окна, класс GameScreen

Перечисление GameState

Окно "Правила игры", класс RulesScreen

main — Сердце игры "Пятнашки"

Менеджер ресурсов и динамический текст на SFML

Структура проекта в Visual Studio 2022

Файлы ресурсов

Ожидаемый результат от программы

Начинаем творить чудеса

resource.h

resource.rc

ResourceManager.h

ResourceManager.cpp

ColorfulText.h

ColorfulText.cpp

Мигающие_буквы.cpp

Пишем калькулятор на C++ с SFML

Почему калькулятор? И почему SFML?

Архитектура: как я это разложил

Рефлексия: что получилось и что можно лучше

Рекомендации новичкам и не только

Чистая архитектура в играх на SFML С++: как разложить код по полочкам

Что такое чистая архитектура?

Слои чистой архитектуры в игре

1. Сущности (Entities)

2. Бизнес-логика (Use Cases / Interactors)

3. Интерфейсы (Controllers / Presenters)

4. Инфраструктура (Frameworks & Drivers)

Собираем игру: главный цикл

Почему это круто?

Полезные советы

Визуализация быстрой сортировки с SFML и C++20

Зачем визуализировать алгоритмы?

Что нам понадобится?

Описание проекта

Цель

Особенности

Код проекта

Подготовка

Полный код

Пояснения к коду

Как это работает?

Расширяемость проекта

Заключение

CRTP в игровых механиках

Что такое CRTP?

Зачем использовать CRTP в играх?

Cистема игровых объектов с SFML

Как это работает?

Преимущества подхода

Итог

Разработка игр на C++

1. Основы C++

2. Основы разработки игр

3. Библиотеки и фреймворки для разработки игр

4. Создание простой игры

Шаг 1: Установка SFML

Шаг 2: Создание окна игры

Шаг 3: Добавление спрайта