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

Разработка игры «Сокобан» на SFML C++: ящики, лабиринты и чистая архитектура

2026-08-07T19:19:09.296Z

Привет, разработчики!

Сегодня предлагаю написать классическую головоломку «Сокобан» на C++20 с
использованием библиотеки SFML. На первый взгляд игра кажется совсем простой: есть человек, несколько ящиков и отмеченные клетки. Ходим по лабиринту, толкаем ящики — что здесь вообще может пойти не так?

А пойти не так может многое.

Ящик нельзя тянуть назад. Два ящика могут заблокировать друг друга. Один
неудачный толчок в угол способен сделать уровень непроходимым. Кроме того, нам понадобятся отмена хода, несколько уровней, плавная анимация, русский текст и нормальная структура проекта, которую не захочется переписать через неделю. Именно поэтому Sokoban — замечательный учебный проект. Здесь нет сложной физики и огромного количества графики, зато есть настоящие игровые правила, состояния, работа с картами и хороший повод отделить логику от отрисовки.

В результате мы получим игру с тремя лабиринтами, счётчиком ходов, отменой
действий и аккуратным интерфейсом. Давайте разберём всё по порядку.

Что мы будем использовать

Для проекта нам понадобятся:

Visual Studio 2022 с компонентом «Разработка классических приложений на C++».
C++20.
SFML 2.6.1.
Немного терпения — ящики иногда упрямее, чем компилятор.

У меня SFML установлена в каталоге:

C:/IT/SFML-2.6.1-windows-vc17-64-bit/SFML-2.6.1

Вы можете использовать другой путь. Главное — правильно указать каталоги
include и lib в Visual Studio либо передать SFML_DIR при настройке CMake.

Вспоминаем правила Sokoban

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

Если перед игроком стоит ящик, происходит дополнительная проверка:

клетка за ящиком свободна — ящик можно толкнуть;
там стена или другой ящик — ход запрещён;
тянуть ящик на себя нельзя.

Уровень завершён, когда каждый ящик находится на цели.

Важно заметить одну вещь: игровое правило ничего не говорит о пикселях,
спрайтах или sf::RectangleShape. Для него существуют только клетки, стены,
ящики и направление движения. Это наблюдение поможет нам правильно разделить
проект.

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

Я не советую складывать всё в один main.cpp. На первом уровне это ещё будет
работать, но после добавления undo и интерфейса файл быстро превратится в
смесь условий, координат и вызовов window.draw().

Используем следующую структуру:

Sokoban/
├── src/
│   ├── main.cpp
│   ├── core/
│   │   ├── Game.hpp
│   │   ├── Game.cpp
│   │   ├── GameConfig.hpp
│   │   └── GameState.hpp
│   ├── entities/
│   │   ├── Cell.hpp
│   │   ├── Board.hpp
│   │   └── Board.cpp
│   ├── levels/
│   │   ├── LevelDefinition.hpp
│   │   ├── LevelManager.hpp
│   │   └── LevelManager.cpp
│   ├── rendering/
│   │   ├── SceneRenderer.hpp
│   │   └── SceneRenderer.cpp
│   ├── resources/
│   │   ├── SystemFontLoader.hpp
│   │   └── SystemFontLoader.cpp
│   └── ui/
│       ├── Hud.hpp
│       └── Hud.cpp
└── tests/
    └── SokobanTests.cpp

Здесь каждый класс решает одну задачу:

Game связывает все системы и содержит главный цикл;
Board знает правила Sokoban;
LevelManager хранит карты и переключает уровни;
SceneRenderer рисует лабиринт и игровые объекты;
Hud отвечает за текст и сообщения;
SystemFontLoader ищет установленный системный шрифт.

Самое важное — Board вообще не зависит от SFML. Его можно тестировать без
окна, OpenGL-контекста и графики.

Создаём координату клетки

Начнём с самого маленького типа — координаты клетки.

Cell.hpp

#pragma once

#include <compare>

struct Cell {
    int x{0};
    int y{0};

    auto operator<=>(const Cell&) const = default;
};

inline Cell operator+(Cell left, Cell right) noexcept
{
    return {left.x + right.x, left.y + right.y};
}

enum class Direction {
    Up,
    Down,
    Left,
    Right
};

[[nodiscard]] inline Cell directionOffset(Direction direction) noexcept
{
    switch (direction) {
    case Direction::Up:    return {0, -1};
    case Direction::Down:  return {0, 1};
    case Direction::Left:  return {-1, 0};
    case Direction::Right: return {1, 0};
    }
    return {};
}

Почему не sf::Vector2i? Потому что клетка относится к правилам игры, а не к
SFML. Если однажды мы захотим сделать консольную версию или перенести проект на
другую библиотеку, доменную часть менять не придётся.

Оператор сравнения нужен для хранения клеток в std::set. Оператор сложения
позволяет получить соседнюю клетку без постоянного ручного сложения x и y.

Описываем уровень обычным текстом

Карту удобно хранить как набор строк. Для этого создадим небольшую структуру.

LevelDefinition.hpp

#pragma once

#include <string>
#include <vector>

struct LevelDefinition {
    std::wstring name;
    std::wstring subtitle;
    std::vector<std::string> map;
};

Условимся использовать следующие символы:

#  стена
@  игрок
$  ящик
.  цель
*  ящик, уже стоящий на цели
+  игрок, стоящий на цели
   свободный пол

Например, первый лабиринт выглядит так:

{
    L"Лабиринт I",
    L"Развилка смотрителя",
    {
        "###########",
        "#   #     #",
        "# .   # . #",
        "# ##  #   #",
        "#  $  ##$ #",
        "##   @    #",
        "#   ###   #",
        "#         #",
        "###########"
    }
}

Такую карту легко читать прямо в исходном коде. Чтобы передвинуть стену или
ящик, не нужно высчитывать пиксельную позицию — достаточно изменить символ.

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

Сердце игры — класс Board

Теперь создадим класс игрового поля. Он будет хранить стены, цели, ящики,
позицию игрока и историю ходов.

Для начала опишем результат одного движения:

using CellSet = std::set<Cell>;

struct MoveResult {
    bool moved{false};
    bool pushedBox{false};
    Cell playerFrom{};
    Cell playerTo{};
    std::optional<Cell> boxFrom;
    std::optional<Cell> boxTo;
    bool levelCompleted{false};
};

Можно было вернуть из move() обычный bool, но тогда отрисовка не знала бы,
откуда и куда переместился объект. MoveResult пригодится для плавной анимации
и при этом не заставит Board заниматься графикой.

Board.hpp

#pragma once

#include "entities/Cell.hpp"
#include "levels/LevelDefinition.hpp"

#include <optional>
#include <set>
#include <vector>

using CellSet = std::set<Cell>;

class Board {
public:
    explicit Board(LevelDefinition definition);

    [[nodiscard]] MoveResult move(Direction direction);
    [[nodiscard]] MoveResult undo();
    void restart();

    [[nodiscard]] bool isComplete() const noexcept;
    [[nodiscard]] bool isWall(Cell cell) const noexcept;
    [[nodiscard]] bool hasBox(Cell cell) const noexcept;
    [[nodiscard]] bool isGoal(Cell cell) const noexcept;

    [[nodiscard]] Cell player() const noexcept;
    [[nodiscard]] const CellSet& walls() const noexcept;
    [[nodiscard]] const CellSet& goals() const noexcept;
    [[nodiscard]] const CellSet& boxes() const noexcept;

private:
    struct Snapshot {
        Cell player;
        CellSet boxes;
        int moves{0};
        int pushes{0};
    };

    void parseAndValidate();

    LevelDefinition definition_;
    CellSet walls_;
    CellSet goals_;
    CellSet initialBoxes_;
    CellSet boxes_;
    Cell initialPlayer_{};
    Cell player_{};
    std::vector<Snapshot> history_;
    int moves_{0};
    int pushes_{0};
};

В заголовке нет ни одного типа SFML. Именно этого мы и добивались.

Разбираем карту и проверяем ошибки

В конструкторе сохраняем определение, разбираем символы и запускаем уровень:

Board::Board(LevelDefinition definition)
    : definition_(std::move(definition))
{
    parseAndValidate();
    restart();
}

Основная часть разбора выглядит так:

for (int y = 0; y < height_; ++y) {
    const auto& row = definition_.map[static_cast<std::size_t>(y)];

    if (static_cast<int>(row.size()) != width_) {
        throw std::invalid_argument(
            "Every level row must have the same width");
    }

    for (int x = 0; x < width_; ++x) {
        const char tile = row[static_cast<std::size_t>(x)];
        const Cell cell{x, y};

        if (tile == '#') {
            walls_.insert(cell);
        }
        if (tile == '.' || tile == '*' || tile == '+') {
            goals_.insert(cell);
        }
        if (tile == '$' || tile == '*') {
            initialBoxes_.insert(cell);
        }
        if (tile == '@' || tile == '+') {
            initialPlayer_ = cell;
            ++playerCount;
        }
    }
}

После этого проверяем два важных условия:

if (playerCount != 1) {
    throw std::invalid_argument(
        "Level must contain exactly one player");
}

if (goals_.empty() || goals_.size() != initialBoxes_.size()) {
    throw std::invalid_argument(
        "The number of boxes and goals must match");
}

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

Реализуем движение игрока и ящика

Теперь самая интересная часть. Метод move() должен проверить ход, сохранить
состояние для undo и только потом изменить позиции.

Board::move()

MoveResult Board::move(Direction direction)
{
    const Cell next = player_ + directionOffset(direction);

    if (isWall(next)) {
        return {};
    }

    const bool pushesBox = hasBox(next);
    const Cell boxDestination = next + directionOffset(direction);

    if (pushesBox
        && (isWall(boxDestination) || hasBox(boxDestination))) {
        return {};
    }

    history_.push_back({player_, boxes_, moves_, pushes_});

    MoveResult result;
    result.moved = true;
    result.playerFrom = player_;
    result.playerTo = next;

    if (pushesBox) {
        boxes_.erase(next);
        boxes_.insert(boxDestination);
        ++pushes_;

        result.pushedBox = true;
        result.boxFrom = next;
        result.boxTo = boxDestination;
    }

    player_ = next;
    ++moves_;
    result.levelCompleted = isComplete();
    return result;
}

Обратите внимание: снимок добавляется в history_ только после всех проверок.
Если игрок нажал клавишу возле стены, состояние не изменилось, поэтому и
отменять здесь нечего.

Порядок проверки простой:

Находим соседнюю клетку.
Останавливаемся, если это стена.
Определяем, находится ли там ящик.
Для ящика проверяем следующую клетку.
Сохраняем снимок.
Изменяем игровое состояние.

Именно в этом методе живёт почти всё главное правило Sokoban.

Проверяем победу

Уровень считается завершённым, если каждый ящик находится в наборе целей:

bool Board::isComplete() const noexcept
{
    return std::all_of(
        boxes_.begin(),
        boxes_.end(),
        [this](Cell box) {
            return goals_.contains(box);
        });
}

Благодаря C++20 и методу contains() код читается почти как обычное
предложение: «все ящики содержатся среди целей».

Добавляем отмену хода

Sokoban без undo может быть довольно беспощадным. Один неверный толчок — и
приходится начинать уровень заново. Поэтому сохраним перед каждым успешным
ходом:

позицию игрока;
набор ящиков;
число ходов;
число толчков.

Само восстановление получается небольшим:

MoveResult Board::undo()
{
    if (history_.empty()) {
        return {};
    }

    const Snapshot snapshot = history_.back();
    history_.pop_back();

    MoveResult result = transitionTo(snapshot);
    player_ = snapshot.player;
    boxes_ = snapshot.boxes;
    moves_ = snapshot.moves;
    pushes_ = snapshot.pushes;
    return result;
}

Метод transitionTo() сравнивает текущий и предыдущий наборы ящиков. Так мы
узнаём, двигался ли ящик при отмене, и можем анимировать его возвращение.

Для трёх небольших уровней полная копия std::set вполне подходит. Если Вы
создаёте огромную карту и храните тысячи ходов, можно перейти к компактным
командам, но начинать проект с такой оптимизации точно не нужно.

Управляем уровнями

Board отвечает за одну карту. Кампанией занимается LevelManager.

LevelManager.hpp

class LevelManager {
public:
    LevelManager();

    [[nodiscard]] MoveResult move(Direction direction);
    [[nodiscard]] MoveResult undo();

    void resetCurrentLevel();
    void restartCampaign();
    [[nodiscard]] bool loadNextLevel();
    [[nodiscard]] bool selectLevel(std::size_t index);

    [[nodiscard]] std::size_t currentLevelIndex() const noexcept;
    [[nodiscard]] std::size_t levelCount() const noexcept;
    [[nodiscard]] bool isLastLevel() const noexcept;
    [[nodiscard]] const Board& board() const noexcept;

private:
    void createLevelDefinitions();
    void loadLevel(std::size_t index);

    std::vector<LevelDefinition> definitions_;
    std::unique_ptr<Board> board_;
    std::size_t currentIndex_{0};
};

При загрузке создаём новый Board из определения:

void LevelManager::loadLevel(std::size_t index)
{
    if (index >= definitions_.size()) {
        throw std::out_of_range("Level index is out of range");
    }

    currentIndex_ = index;
    board_ = std::make_unique<Board>(definitions_[currentIndex_]);
}

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

Разделяем игру и отрисовку

Теперь у нас есть полностью рабочая логика, но на экране пока ничего нет.

Можно передать Board& в класс отрисовки и позволить ему делать всё подряд.
Но тогда одна случайная строка в рендерере сможет переместить ящик. Лучше
передавать константную ссылку и небольшой снимок анимации:

struct SceneData {
    const Board& board;
    float totalTime{0.0f};
    float moveProgress{1.0f};
    const MoveResult* transition{nullptr};
};

SceneRenderer рисует:

фон;
пол;
цели;
стены;
ящики;
игрока.

Позиция клетки преобразуется в пиксели только здесь:

sf::Vector2f SceneRenderer::cellPosition(
    const SceneLayout& layout,
    Cell cell)
{
    return layout.boardOrigin
        + sf::Vector2f(
            static_cast<float>(cell.x),
            static_cast<float>(cell.y))
        * layout.cellSize;
}

Получается полезная граница: Board оперирует клетками, а SceneRenderer —
пикселями.

Делаем плавное движение

Логика перемещает игрока сразу из одной клетки в другую. Это правильно:
состояние поля всегда однозначно. Но визуально резкие скачки выглядят не очень
приятно.

Для анимации сохраним MoveResult и время перехода:

std::optional<MoveResult> transition_;
float animationElapsed_{0.0f};

Прогресс движения вычислим через smoothstep:

float Game::animationProgress() const noexcept
{
    if (!transition_) {
        return 1.0f;
    }

    const float linear = std::clamp(
        animationElapsed_ / GameConfig::MoveAnimationDuration,
        0.0f,
        1.0f);

    return linear * linear * (3.0f - 2.0f * linear);
}

После этого рендерер интерполирует координаты:

sf::Vector2f interpolate(Cell from, Cell to, float amount)
{
    return {
        static_cast<float>(from.x)
            + static_cast<float>(to.x - from.x) * amount,
        static_cast<float>(from.y)
            + static_cast<float>(to.y - from.y) * amount
    };
}

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

Рисуем HUD отдельно

Текстовый интерфейс лучше не смешивать со стенами и ящиками. Создадим снимок
данных:

struct HudData {
    std::size_t levelNumber{1};
    std::size_t levelCount{1};
    std::wstring levelName;
    std::wstring levelSubtitle;
    int moves{0};
    int pushes{0};
    bool boardComplete{false};
    bool showCompletion{false};
    GameState state{GameState::Playing};
    sf::FloatRect panel{};
};

Теперь Hud не получает доступ к Game и не может менять уровень. Он знает
только те значения, которые действительно нужны для текущего кадра.

Загружаем системный шрифт

С русским текстом иногда возникает знакомая проблема: окно работает, панели
рисуются, а вместо букв появляются квадраты. Причина почти всегда в шрифте.

Чтобы не хранить отдельный TTF-файл возле программы, найдём системный каталог
Windows:

std::filesystem::path SystemFontLoader::systemFontDirectory()
{
#ifdef _WIN32
    std::array<wchar_t, MAX_PATH> buffer{};
    const UINT length = GetWindowsDirectoryW(
        buffer.data(),
        static_cast<UINT>(buffer.size()));

    if (length > 0 && length < buffer.size()) {
        return std::filesystem::path(buffer.data()) / L"Fonts";
    }
#endif
    return {};
}

Затем пробуем известные шрифты с кириллицей:

for (const wchar_t* filename : {
         L"segoeui.ttf",
         L"tahoma.ttf",
         L"arial.ttf",
         L"calibri.ttf",
         L"verdana.ttf"}) {
    result.push_back(windowsFonts / filename);
}

В нашем случае загружается Segoe UI, который уже установлен в Windows. Если
стандартные имена не найдены, можно пройти по каталогу Fonts и попробовать
другой TTF или OTF-файл.

Собираем всё в классе Game

Game — координатор. Он создаёт окно, принимает события, обновляет анимацию и
вызывает отрисовку.

Главный цикл выглядит привычно:

void Game::run()
{
    while (window_.isOpen()) {
        processEvents();

        const float deltaTime = std::min(
            frameClock_.restart().asSeconds(),
            GameConfig::MaximumDeltaTime);

        update(deltaTime);
        render();
    }
}

Обработка клавиши переводит код SFML в наше доменное направление:

if (key == sf::Keyboard::Up || key == sf::Keyboard::W) {
    movePlayer(Direction::Up);
}
else if (key == sf::Keyboard::Down || key == sf::Keyboard::S) {
    movePlayer(Direction::Down);
}
else if (key == sf::Keyboard::Left || key == sf::Keyboard::A) {
    movePlayer(Direction::Left);
}
else if (key == sf::Keyboard::Right || key == sf::Keyboard::D) {
    movePlayer(Direction::Right);
}

А movePlayer() обращается к менеджеру уровня:

void Game::movePlayer(Direction direction)
{
    const MoveResult result = levelManager_.move(direction);
    startAnimation(result);

    if (result.levelCompleted) {
        state_ = levelManager_.isLastLevel()
            ? GameState::CampaignComplete
            : GameState::LevelComplete;

        completionDelay_ = GameConfig::CompletionRevealDelay;
        completionVisible_ = false;
    }
}

Обратите внимание, как обязанности проходят по цепочке:

Клавиатура -> Game -> LevelManager -> Board

В обратную сторону возвращается MoveResult, который используется для
анимации и проверки победы.

Точка входа

После такого разделения main.cpp остаётся очень маленьким:

#include "core/Game.hpp"

#include <exception>
#include <iostream>

int main()
{
    try {
        Game game;
        game.run();
    }
    catch (const std::exception& exception) {
        std::cerr << "Sokoban startup error: "
                  << exception.what() << '\n';
        return 1;
    }

    return 0;
}

Так и должно быть. Точка входа создаёт приложение, запускает его и обрабатывает
критическую ошибку запуска.

Проверяем уровни автоматически

Нарисовать красивый лабиринт недостаточно — он должен иметь решение. Причём
желательно узнать об ошибке до того, как уровень попадёт к игроку.

Для каждой карты я сохранил проверенную последовательность команд:

const std::vector<std::string> verifiedSolutions = {
    "LLLURDRUURULLRDDDRRRRUU",
    "LLLLLULLLULLDRRRRDRUDRRURDRULLULLDLUUULUULRRDLDRRRRDRUU",
    "DLLLULDDDDDLDRRRDRULLLLLDLLLDLUURUUURUULRDDRRRRDRUU"
};

Буквы означают направления Up, Down, Left, Right. Тест загружает каждый
уровень, выполняет все команды и проверяет результат:

for (std::size_t index = 0;
     index < verifiedSolutions.size();
     ++index) {
    levels.selectLevel(index);

    for (const char command : verifiedSolutions[index]) {
        const MoveResult result = levels.move(
            parseDirection(command));

        require(result.moved,
                "A verified solution contains an illegal move");
    }

    require(levels.board().isComplete(),
            "A verified solution did not complete its level");
}

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

Настраиваем CMake

Доменную часть удобно собрать в отдельную библиотеку:

add_library(sokoban_domain STATIC
    src/entities/Board.cpp
    src/entities/Board.hpp
    src/entities/Cell.hpp
    src/levels/LevelDefinition.hpp
    src/levels/LevelManager.cpp
    src/levels/LevelManager.hpp
)

target_include_directories(sokoban_domain
    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/src")

Исполняемый файл уже зависит от SFML:

add_executable(Sokoban
    src/main.cpp
    src/core/Game.cpp
    src/rendering/SceneRenderer.cpp
    src/resources/SystemFontLoader.cpp
    src/ui/Hud.cpp
)

target_link_libraries(Sokoban PRIVATE
    sokoban_domain
    sfml-graphics
    sfml-window
    sfml-system
)

А тесты используют только доменный слой:

add_executable(sokoban_tests tests/SokobanTests.cpp)
target_link_libraries(sokoban_tests PRIVATE sokoban_domain)
add_test(NAME sokoban_domain_levels_and_undo
         COMMAND sokoban_tests)

Собираем и запускаем проект

Для Visual Studio 2022:

Откройте Sokoban.sln.
Выберите платформу x64.
Выберите Debug или Release.
Нажмите Ctrl+Shift+B.
Запустите проект.

Альтернативная сборка через CMake:

cmake -S . -B build-cmake -A x64
cmake --build build-cmake --config Release
ctest --test-dir build-cmake -C Release --output-on-failure
.\build-cmake\Release\Sokoban.exe

Если SFML установлена в другом месте:

cmake -S . -B build-cmake -A x64 `
  -DSFML_DIR="D:/Libraries/SFML/lib/cmake/SFML"

Что получилось

В итоге у нас есть не просто перемещение квадратиков по экрану, а законченный
небольшой проект:

три лабиринтных уровня;
правила классического Sokoban;
отмена последнего хода;
перезапуск и выбор уровня;
счётчик ходов и толчков;
плавное движение игрока и ящиков;
русский интерфейс на системном шрифте;
автоматическая проверка всех решений;
разделение логики, уровней, отрисовки и UI.

Мне особенно нравится, что самая важная часть игры — Board — получилась
полностью независимой от SFML. Интерфейс можно перерисовать, библиотеку можно
заменить, а правила Sokoban останутся прежними.

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

Надеюсь, у Вас всё получилось. Если появились вопросы или Вы нашли интересный способ улучшить архитектуру — пишите в комментариях и делитесь своими идеями!

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

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

Наш Ютюб

Разработка игры «Рикошет во тьме» на SFML C++

2026-08-02T17:51:50.457Z

Привет, разработчики и любители экспериментов с графикой! Сегодня хочу рассказать о создании небольшой, но атмосферной игры «Рикошет во тьме» на C++20 с использованием SFML.

Концепт игрового поля «Рикошет во тьме»

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

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

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

Идея игры

Игрок запускает светящийся шар в тёмное помещение. Шар движется с постоянной скоростью, рикошетит от стен и препятствий и на короткое время освещает пространство вокруг себя. Задача — уничтожить все спрятанные цели за ограниченное количество запусков.

Основные правила получились такими:

направление выстрела задаётся мышью;
левая кнопка мыши запускает шар;
после столкновения со стеной или препятствием шар отражается;
при попадании цель исчезает, а игрок получает очки;
клавиша R перезапускает уровень;
Esc возвращает в меню или закрывает игру.

На первый взгляд всё просто. Но именно в таких проектах хорошо видны важные темы игровой разработки: работа со временем, нормализация векторов, проверка столкновений, разделение ответственности между классами и создание визуальной атмосферы.

Подготовка проекта

Для разработки я использовал C++20 и SFML 2.6. Проект можно собрать в Visual Studio, CLion или через CMake.

Нам понадобятся модули:

sfml-graphics — отрисовка объектов и света;
sfml-window — окно и события;
sfml-system — время и векторы;
sfml-audio — звуки выстрела и столкновений.

CMakeLists.txt

cmake_minimum_required(VERSION 3.20)
project(RicochetInTheDark)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(SFML 2.6 COMPONENTS
    graphics
    window
    system
    audio
    REQUIRED
)

add_executable(RicochetInTheDark
    src/main.cpp
    src/Game.cpp
    src/Ball.cpp
    src/Obstacle.cpp
    src/Target.cpp
    src/LightSystem.cpp
)

target_link_libraries(RicochetInTheDark PRIVATE
    sfml-graphics
    sfml-window
    sfml-system
    sfml-audio
)

Если SFML подключена правильно, сначала откройте обычное окно. Это маленькая проверка, которая экономит много времени: лучше сразу убедиться, что компилятор видит заголовочные файлы и библиотеки.

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

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

RicochetInTheDark/
├── assets/
│   ├── fonts/
│   ├── sounds/
│   └── shaders/
│       └── light.frag
├── src/
│   ├── main.cpp
│   ├── Game.h
│   ├── Game.cpp
│   ├── Ball.h
│   ├── Ball.cpp
│   ├── Obstacle.h
│   ├── Obstacle.cpp
│   ├── Target.h
│   ├── Target.cpp
│   ├── LightSystem.h
│   └── LightSystem.cpp
└── CMakeLists.txt

Класс Game управляет игровым циклом. Ball отвечает за движение и отражение. Obstacle хранит геометрию препятствия, Target — состояние цели, а LightSystem создаёт карту освещения.

Главный игровой цикл

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

main.cpp

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

int main()
{
    sf::RenderWindow window(
        sf::VideoMode(1280, 720),
        "Рикошет во тьме",
        sf::Style::Close
    );

    window.setFramerateLimit(144);

    Game game(window);
    sf::Clock clock;

    while (window.isOpen())
    {
        const float deltaTime = clock.restart().asSeconds();

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

            game.handleEvent(event);
        }

        game.update(deltaTime);

        window.clear(sf::Color(5, 7, 12));
        game.render();
        window.display();
    }

    return 0;
}

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

Создаём светящийся шар

Шар хранит позицию, скорость, радиус и флаг активности. Пока игрок выбирает направление, шар остаётся на стартовой точке. После выстрела он начинает двигаться.

Ball.h

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

class Ball : public sf::Drawable
{
public:
    explicit Ball(float radius = 12.0f);

    void launch(const sf::Vector2f& direction, float speed);
    void reset(const sf::Vector2f& position);
    void setPosition(const sf::Vector2f& position);
    void update(float deltaTime);

    void reflect(const sf::Vector2f& normal);

    [[nodiscard]] bool isActive() const;
    [[nodiscard]] float getRadius() const;
    [[nodiscard]] sf::Vector2f getPosition() const;
    [[nodiscard]] sf::Vector2f getVelocity() const;

private:
    sf::CircleShape shape;
    sf::Vector2f velocity{};
    bool active{false};

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

Ball.cpp

#include "Ball.h"
#include <cmath>

namespace
{
    sf::Vector2f normalize(const sf::Vector2f& vector)
    {
        const float length = std::sqrt(
            vector.x * vector.x + vector.y * vector.y
        );

        if (length == 0.0f)
            return {0.0f, 0.0f};

        return vector / length;
    }

    float dot(
        const sf::Vector2f& left,
        const sf::Vector2f& right
    )
    {
        return left.x * right.x + left.y * right.y;
    }
}

Ball::Ball(float radius)
{
    shape.setRadius(radius);
    shape.setOrigin(radius, radius);
    shape.setFillColor(sf::Color(190, 235, 255));
    shape.setOutlineThickness(3.0f);
    shape.setOutlineColor(sf::Color(80, 180, 255));
}

void Ball::launch(
    const sf::Vector2f& direction,
    float speed
)
{
    velocity = normalize(direction) * speed;
    active = true;
}

void Ball::reset(const sf::Vector2f& position)
{
    shape.setPosition(position);
    velocity = {};
    active = false;
}

void Ball::setPosition(const sf::Vector2f& position)
{
    shape.setPosition(position);
}

void Ball::update(float deltaTime)
{
    if (active)
        shape.move(velocity * deltaTime);
}

void Ball::reflect(const sf::Vector2f& normal)
{
    velocity -= 2.0f * dot(velocity, normal) * normal;
}

bool Ball::isActive() const
{
    return active;
}

float Ball::getRadius() const
{
    return shape.getRadius();
}

sf::Vector2f Ball::getPosition() const
{
    return shape.getPosition();
}

sf::Vector2f Ball::getVelocity() const
{
    return velocity;
}

void Ball::draw(
    sf::RenderTarget& target,
    sf::RenderStates states
) const
{
    target.draw(shape, states);
}

Формула отражения выглядит так:

V′ = V − 2(V · N)N

Здесь V — текущая скорость, а N — нормаль поверхности. Эта формула универсальна: она работает и для горизонтальной стены, и для вертикальной, и для наклонных поверхностей.

Запуск шара мышью

При нажатии левой кнопки мыши вычисляем направление от стартовой позиции к курсору.

void Game::handleEvent(const sf::Event& event)
{
    if (event.type == sf::Event::KeyPressed)
    {
        if (event.key.code == sf::Keyboard::Escape)
            window.close();

        if (event.key.code == sf::Keyboard::R)
            restartLevel();
    }

    if (event.type == sf::Event::MouseButtonPressed
        && event.mouseButton.button == sf::Mouse::Left
        && !ball.isActive())
    {
        const sf::Vector2f mousePosition =
            window.mapPixelToCoords({
                event.mouseButton.x,
                event.mouseButton.y
            });

        const sf::Vector2f direction =
            mousePosition - ball.getPosition();

        ball.launch(direction, 520.0f);
    }
}

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

Рикошет от границ окна

Для стен уровня достаточно проверить положение центра шара с учётом его радиуса. После столкновения меняем направление движения и возвращаем объект внутрь игрового поля.

void Game::handleWindowCollision()
{
    auto position = ball.getPosition();
    const float radius = ball.getRadius();

    if (position.x - radius < 0.0f)
    {
        position.x = radius;
        ball.setPosition(position);
        ball.reflect({1.0f, 0.0f});
    }
    else if (position.x + radius > window.getSize().x)
    {
        position.x = window.getSize().x - radius;
        ball.setPosition(position);
        ball.reflect({-1.0f, 0.0f});
    }

    if (position.y - radius < 0.0f)
    {
        position.y = radius;
        ball.setPosition(position);
        ball.reflect({0.0f, 1.0f});
    }
    else if (position.y + radius > window.getSize().y)
    {
        position.y = window.getSize().y - radius;
        ball.setPosition(position);
        ball.reflect({0.0f, -1.0f});
    }
}

Простое отражение скорости без коррекции позиции иногда приводит к дрожанию: шар остаётся внутри стены и на следующем кадре сталкивается с ней снова.

Столкновение с препятствиями

Препятствия удобно хранить как прямоугольники. Для столкновения круга с прямоугольником находим ближайшую к центру шара точку внутри границ препятствия.

#include <algorithm>

bool intersects(
    const Ball& ball,
    const sf::FloatRect& rectangle
)
{
    const sf::Vector2f center = ball.getPosition();

    const float closestX = std::clamp(
        center.x,
        rectangle.left,
        rectangle.left + rectangle.width
    );

    const float closestY = std::clamp(
        center.y,
        rectangle.top,
        rectangle.top + rectangle.height
    );

    const float dx = center.x - closestX;
    const float dy = center.y - closestY;
    const float radius = ball.getRadius();

    return dx * dx + dy * dy < radius * radius;
}

После обнаружения столкновения определяем нормаль. Для прямоугольных препятствий можно сравнить проникновение по осям X и Y. Отражаем скорость по той оси, где проникновение меньше, и выталкиваем шар наружу.

void Game::resolveObstacleCollision(
    const sf::FloatRect& bounds
)
{
    if (!intersects(ball, bounds))
        return;

    auto position = ball.getPosition();

    const sf::Vector2f obstacleCenter{
        bounds.left + bounds.width * 0.5f,
        bounds.top + bounds.height * 0.5f
    };

    const float dx = position.x - obstacleCenter.x;
    const float dy = position.y - obstacleCenter.y;

    const float overlapX =
        bounds.width * 0.5f + ball.getRadius() - std::abs(dx);
    const float overlapY =
        bounds.height * 0.5f + ball.getRadius() - std::abs(dy);

    if (overlapX < overlapY)
    {
        const float sign = dx < 0.0f ? -1.0f : 1.0f;
        position.x += sign * overlapX;
        ball.setPosition(position);
        ball.reflect({sign, 0.0f});
    }
    else
    {
        const float sign = dy < 0.0f ? -1.0f : 1.0f;
        position.y += sign * overlapY;
        ball.setPosition(position);
        ball.reflect({0.0f, sign});
    }
}

Для быстрых объектов позже стоит добавить непрерывную проверку столкновений. Иначе на низкой частоте кадров шар может успеть «проскочить» через тонкую стену.

Освещение и атмосфера

Главная особенность проекта — темнота. Простого чёрного прямоугольника поверх сцены недостаточно: нам нужно оставить видимой область вокруг шара.

Я использовал отдельную sf::RenderTexture как карту света. Каждый кадр она очищается тёмным цветом, после чего на неё с аддитивным смешиванием рисуется мягкий световой круг. Затем фрагментный шейдер умножает цвет игрового мира на значение карты света.

light.frag

uniform sampler2D texture;
uniform sampler2D lightMap;

void main()
{
    vec2 uv = gl_TexCoord[0].xy;

    vec4 worldColor = texture2D(texture, uv);
    vec4 lightColor = texture2D(lightMap, uv);

    float ambient = 0.08;
    float brightness = max(
        ambient,
        max(lightColor.r, max(lightColor.g, lightColor.b))
    );

    gl_FragColor = vec4(
        worldColor.rgb * brightness,
        worldColor.a
    );
}

Мягкий круг можно подготовить в графическом редакторе или создать программно как радиальный градиент. Его центр совпадает с позицией шара.

lightMap.clear(sf::Color::Black);

lightSprite.setPosition(ball.getPosition());
lightMap.draw(lightSprite, sf::BlendAdd);

lightMap.display();

lightShader.setUniform(
    "lightMap",
    lightMap.getTexture()
);

window.draw(worldSprite, &lightShader);

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

Цели и подсчёт очков

Каждая цель хранит форму и флаг активности. При столкновении с шаром цель выключается, счёт увеличивается, а на её месте появляется вспышка.

void Game::checkTargets()
{
    for (auto& target : targets)
    {
        if (!target.isActive())
            continue;

        const sf::Vector2f difference =
            target.getPosition() - ball.getPosition();

        const float radius =
            target.getRadius() + ball.getRadius();

        const float distanceSquared =
            difference.x * difference.x
            + difference.y * difference.y;

        if (distanceSquared <= radius * radius)
        {
            target.destroy();
            score += 100;
            createHitParticles(target.getPosition());
        }
    }
}

Когда активных целей не осталось, уровень завершён. Игроку можно начислять дополнительный бонус за количество рикошетов или за неиспользованные попытки.

Обновление игрового состояния

Метод update соединяет отдельные механики, но не содержит их внутреннюю реализацию.

void Game::update(float deltaTime)
{
    ball.update(deltaTime);

    if (ball.isActive())
    {
        handleWindowCollision();

        for (const auto& obstacle : obstacles)
            resolveObstacleCollision(obstacle.getBounds());

        checkTargets();
        updateTrail(deltaTime);
        updateParticles(deltaTime);
    }

    lightSystem.setLightPosition(ball.getPosition());
    lightSystem.update(deltaTime);

    if (allTargetsDestroyed())
        state = GameState::Victory;
}

Такой код легко читать сверху вниз. Мы видим порядок действий, но детали столкновений, частиц и света находятся в отдельных функциях и классах.

Небольшие детали, которые делают игру живой

Механика может работать идеально, но без обратной связи игра всё равно будет ощущаться пустой. Я добавил несколько простых эффектов:

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

Важно не переборщить. Если экран постоянно трясётся и мигает, игрок уже сражается не с уровнем, а с собственным монитором.

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

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

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

Наш Ютюб

Разработка игры "Пятнашки" на 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 для визуализации. Это позволяет эффективно решать задачу и демонстрировать результат в графическом окне.

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