LevelManager.cpp - master - del00n/Space_Lab

LevelManager.cpp
184 строки6 KB
del00n
upload files
22 янв 2026, 13:52
22 янв 2026, 13:524016b42
#include "LevelManager.h"

#include <sstream>
#include <vector>

static LevelConfig makeDefaultLevel(int i) {
    LevelConfig cfg;
    cfg.name = "Level " + std::to_string(i + 1);

    const float masses[5] = {
        1900.f + i * 50.f,
        1500.f + i * 30.f,
        2400.f + i * 40.f,
        1700.f + i * 35.f,
        2000.f + i * 45.f
    };
    const float radii[5] = {25.f, 35.f, 30.f, 20.f, 30.f};
    const float xs[5] = {150.f, 650.f, 400.f, 320.f, 700.f};
    const float ysBase[5] = {300.f, 290.f, 500.f, 150.f, 480.f};

    cfg.planets.clear();
    cfg.planets.reserve(5);
    for (int p = 0; p < 5; p++) {
        PlanetConfig pc;
        pc.x = xs[p];
        pc.y = ysBase[p] + i * 10.f;
        pc.mass = masses[p];
        pc.radius = radii[p];
        cfg.planets.push_back(pc);
    }

    cfg.offsetY = i * 10.f;
    cfg.waypointCount = 5;
    cfg.planetMass = 6000.f + i * 500.f;
    return cfg;
}

LevelManager::LevelManager() {
    std::filesystem::create_directory("levels");
    createDefaultLevels();
    loadLevel(0);
}

std::string LevelManager::levelFilePath(int idx) const {
    return "levels/level_" + std::to_string(idx) + ".txt";
}

void LevelManager::createDefaultLevels() {
    std::vector<LevelConfig> defaults;
    defaults.reserve(TOTAL_LEVELS);

    for (int i = 0; i < TOTAL_LEVELS; i++) {
        defaults.push_back(makeDefaultLevel(i));
    }

    for (int i = 0; i < TOTAL_LEVELS; i++) {
        std::string path = levelFilePath(i);
        if (!std::filesystem::exists(path)) {
            saveLevel(i, defaults[i]);
        }
    }
}

void LevelManager::loadLevel(int levelIdx) {
    if (levelIdx < 0 || levelIdx >= TOTAL_LEVELS) return;

    currentLevelIdx = levelIdx;
    currentLevel = makeDefaultLevel(levelIdx);

    std::ifstream file(levelFilePath(levelIdx));
    if (!file.is_open()) {
        return;
    }

    bool sawPlanet = false;

    float oldMass[5] = {
        1900.f + levelIdx * 50.f,
        1500.f + levelIdx * 30.f,
        2400.f + levelIdx * 40.f,
        1700.f + levelIdx * 35.f,
        2000.f + levelIdx * 45.f
    };

    float oldX[5] = {150.f, 650.f, 400.f, 320.f, 700.f};
    float oldY[5] = {300.f + levelIdx * 10.f, 290.f + levelIdx * 10.f, 500.f + levelIdx * 10.f, 150.f + levelIdx * 10.f, 480.f + levelIdx * 10.f};

    bool gotLegacy = false;

    std::string line;
    while (std::getline(file, line)) {
        if (line.empty()) continue;

        auto pos = line.find('=');
        if (pos == std::string::npos) continue;

        std::string key = line.substr(0, pos);
        std::string value = line.substr(pos + 1);

        try {
            if (key == "name") {
                currentLevel.name = value;
            } else if (key == "offsetY") {
                currentLevel.offsetY = std::stof(value);
            } else if (key == "waypointCount") {
                currentLevel.waypointCount = std::clamp(std::stoi(value), 2, 10);
            } else if (key == "planetMass") {
                currentLevel.planetMass = std::stof(value);
            } else if (key == "planet") {

                std::istringstream ss(value);
                PlanetConfig p;
                if (ss >> p.x >> p.y >> p.mass >> p.radius) {
                    if (!sawPlanet) {
                        currentLevel.planets.clear();
                        sawPlanet = true;
                    }
                    currentLevel.planets.push_back(p);
                }
            }

            else if (key == "mass1") { oldMass[0] = std::stof(value); gotLegacy = true; }
            else if (key == "mass2") { oldMass[1] = std::stof(value); gotLegacy = true; }
            else if (key == "mass3") { oldMass[2] = std::stof(value); gotLegacy = true; }
            else if (key == "mass4") { oldMass[3] = std::stof(value); gotLegacy = true; }
            else if (key == "mass5") { oldMass[4] = std::stof(value); gotLegacy = true; }

            else if (key == "pos1X") { oldX[0] = std::stof(value); gotLegacy = true; }
            else if (key == "pos1Y") { oldY[0] = std::stof(value); gotLegacy = true; }
            else if (key == "pos2X") { oldX[1] = std::stof(value); gotLegacy = true; }
            else if (key == "pos2Y") { oldY[1] = std::stof(value); gotLegacy = true; }
            else if (key == "pos3X") { oldX[2] = std::stof(value); gotLegacy = true; }
            else if (key == "pos3Y") { oldY[2] = std::stof(value); gotLegacy = true; }
            else if (key == "pos4X") { oldX[3] = std::stof(value); gotLegacy = true; }
            else if (key == "pos4Y") { oldY[3] = std::stof(value); gotLegacy = true; }
            else if (key == "pos5X") { oldX[4] = std::stof(value); gotLegacy = true; }
            else if (key == "pos5Y") { oldY[4] = std::stof(value); gotLegacy = true; }
        } catch (...) {

        }
    }

    if (!sawPlanet && gotLegacy) {

        const float radii[5] = {25.f, 35.f, 30.f, 20.f, 30.f};
        currentLevel.planets.clear();
        currentLevel.planets.reserve(5);
        for (int i = 0; i < 5; i++) {
            PlanetConfig p;
            p.x = oldX[i];
            p.y = oldY[i];
            p.mass = oldMass[i];
            p.radius = radii[i];
            currentLevel.planets.push_back(p);
        }
    }

    if (currentLevel.planets.empty()) {
        PlanetConfig p;
        p.x = 400.f;
        p.y = 300.f;
        p.mass = 2000.f;
        p.radius = 30.f;
        currentLevel.planets.push_back(p);
    }
}

void LevelManager::saveLevel(int levelIdx, const LevelConfig& config) {
    if (levelIdx < 0 || levelIdx >= TOTAL_LEVELS) return;

    std::filesystem::create_directory("levels");

    std::ofstream file(levelFilePath(levelIdx));
    if (!file.is_open()) return;

    file << "name=" << config.name << "\n";
    file << "offsetY=" << config.offsetY << "\n";
    file << "waypointCount=" << std::clamp(config.waypointCount, 2, 10) << "\n";
    file << "planetMass=" << config.planetMass << "\n";

    for (const auto& p : config.planets) {
        file << "planet=" << p.x << " " << p.y << " " << p.mass << " " << p.radius << "\n";
    }
}