Spawning Waves of Enemies From Tuned Templates

#include <chrono>
#include <print>
#include <string>
#include <thread>
#include <vector>

// Naive: Every spawn parses config strings and rebuilds complex structures from scratch!
struct MonsterConfig {
    std::string type;
    int hp;
    int attack;
    std::string weapon;
    std::vector<std::string> lootTable;
};

// Simulates expensive parsing/loading from disk or network
MonsterConfig loadConfigFromDisk(const std::string& type) {
    // In production game engines, disk I/O and JSON parsing take substantial CPU cycles
    if (type == "goblin") {
        return {"Goblin Scout", 45, 12, "Rusty Dagger", {"10 Gold", "Cloth Scrap"}};
    } else if (type == "orc") {
        return {"Elite Orc", 180, 28, "Battle Axe", {"Heavy Belt", "Ruby"}};
    }
    return {"Unknown", 10, 5, "Fist", {}};
}

class NaiveMonster {
    MonsterConfig cfg_;
    int x_{0};
    int y_{0};
public:
    explicit NaiveMonster(MonsterConfig cfg) : cfg_(std::move(cfg)) {}

    void setPosition(int x, int y) { x_ = x; y_ = y; }
    void print() const {
        std::println("Spawned {} at ({}, {}) [HP: {}, Atk: {}, Weapon: {}]",
                     cfg_.type, x_, y_, cfg_.hp, cfg_.attack, cfg_.weapon);
    }
};

class NaiveSpawner {
public:
    NaiveMonster spawn(const std::string& type, int x, int y) {
        // Flaw: Disk/JSON config parsing repeated for every single spawn!
        MonsterConfig cfg = loadConfigFromDisk(type);
        NaiveMonster m(std::move(cfg));
        m.setPosition(x, y);
        return m;
    }
};

int main() {
    NaiveSpawner spawner;

    std::println("--- Naive Horde Spawning (Re-parsing config on every spawn) ---");
    for (int i = 0; i < 3; ++i) {
        auto goblin = spawner.spawn("goblin", 10 * i, 20 * i);
        goblin.print();
    }
    auto orc = spawner.spawn("orc", 100, 100);
    orc.print();
}