Prototype.cpp

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>

// Prototype Interface
class Monster {
public:
    virtual ~Monster() = default;

    virtual std::unique_ptr<Monster> clone() const = 0;
    
    virtual void print() const = 0;
    virtual void setHealth(int health) = 0;
};

// Concrete Prototype 1
class Goblin : public Monster {
private:
    std::string name;
    int health;
    int agility;

public:
    Goblin(std::string name, int health, int agility)
        : name(std::move(name)), health(health), agility(agility) {}

    Goblin(const Goblin& other) = default;

    std::unique_ptr<Monster> clone() const override {
        return std::make_unique<Goblin>(*this);
    }

    void print() const override {
        std::cout << "[Goblin] " << name << " | HP: " << health << " | Agility: " << agility << "\n";
    }

    void setHealth(int h) override { health = h; }
};

// Concrete Prototype 2
class Dragon : public Monster {
private:
    std::string name;
    int health;
    int firePower;

public:
    Dragon(std::string name, int health, int firePower)
        : name(std::move(name)), health(health), firePower(firePower) {}

    Dragon(const Dragon& other) = default;

    std::unique_ptr<Monster> clone() const override {
        return std::make_unique<Dragon>(*this);
    }

    void print() const override {
        std::cout << "[Dragon] " << name << " | HP: " << health << " | Fire Power: " << firePower << "\n";
    }

    void setHealth(int h) override { health = h; }
};

// Prototype Registry / Manager
class MonsterRegistry {
private:
    std::unordered_map<std::string, std::unique_ptr<Monster>> prototypes;

public:
    void registerPrototype(const std::string& key, std::unique_ptr<Monster> prototype) {
        prototypes[key] = std::move(prototype);
    }

    std::unique_ptr<Monster> createMonster(const std::string& key) const {
        auto it = prototypes.find(key);
        if (it != prototypes.end()) {
            return it->second->clone();
        }
        return nullptr;
    }
};

int main() {
    MonsterRegistry registry;

    registry.registerPrototype("weak_goblin", 
        std::make_unique<Goblin>("Goblin Scout", 50, 15));
    registry.registerPrototype("red_dragon", 
        std::make_unique<Dragon>("Flame Dragon", 500, 100));

    std::unique_ptr<Monster> g1 = registry.createMonster("weak_goblin");
    std::unique_ptr<Monster> g2 = registry.createMonster("weak_goblin");
    
    g2->setHealth(20);

    std::unique_ptr<Monster> d1 = registry.createMonster("red_dragon");

    std::cout << "--- Spawned Monsters ---\n";
    g1->print();
    g2->print();
    d1->print();

    return 0;
}