Abstract Classes

#include <iostream>
#include <string>
#include <vector>

class GameEntity {
protected:
    std::string name;
    int x;
    int y;
    int health;
    bool alive;

public:
    GameEntity(std::string name, int x, int y, int hp)
        : name{name}, x{x}, y{y}, health{hp}, alive{true} {
        std::cout << "GameEntity created: " << name << "\n";
    }

    virtual void update() = 0;

    virtual void render() const = 0;

    void takeDamage(int damage) {
        health -= damage;
        if (health <= 0) {
            health = 0;
            alive = false;
            onDeath();
        }
        std::cout << name << " took " << damage << " damage. HP: " << health << "\n";
    }

    void move(int dx, int dy) {
        x += dx;
        y += dy;
        std::cout << name << " moved to (" << x << ", " << y << ")" << "\n";
    }

    bool isAlive() const {
        return alive;
    }

    std::string getName() const {
        return name;
    }

    virtual void onDeath() {
        std::cout << name << " has died!" << "\n";
    }

    virtual ~GameEntity() {
        std::cout << "GameEntity destroyed: " << name << "\n";
    }
};

class Player : public GameEntity {
private:
    int score;
    int lives;

public:
    Player(std::string name, int x, int y)
        : GameEntity{name, x, y, 100}, score{0}, lives{3} {
        std::cout << "Player created with " << lives << " lives" << "\n";
    }

    void update() override {
        if (alive) {
            std::cout << name << " (Player) updating... Score: " << score << "\n";
        }
    }

    void render() const override {
        if (alive) {
            std::cout << "Rendering player '" << name << "' at (" << x << ", " << y << ")" << "\n";
        }
    }

    void collectCoin() {
        score += 10;
        std::cout << name << " collected coin! Score: " << score << "\n";
    }

    void onDeath() override {
        lives--;
        std::cout << name << " died! Lives remaining: " << lives << "\n";
        if (lives > 0) {
            health = 100;
            alive = true;
            std::cout << name << " respawned!" << "\n";
        }
    }

    ~Player() override {
        std::cout << "Player destroyed" << "\n";
    }
};

class Enemy : public GameEntity {
private:
    int attackPower;
    std::string enemyType;

public:
    Enemy(std::string type, int x, int y, int hp, int power)
        : GameEntity{type + "_Enemy", x, y, hp}, attackPower{power}, enemyType{type} {
    }

    void update() override {
        if (alive) {
            std::cout << name << " (Enemy) patrolling..." << "\n";
        }
    }

    void render() const override {
        if (alive) {
            std::cout << "Rendering enemy '" << name << "' at (" << x << ", " << y << ")" << "\n";
        }
    }

    void attack(GameEntity& target) {
        if (alive) {
            std::cout << name << " attacks " << target.getName() << "!" << "\n";
            target.takeDamage(attackPower);
        }
    }

    ~Enemy() override {
        std::cout << "Enemy destroyed" << "\n";
    }
};

int main() {
    // GameEntity* entity = new GameEntity{"Generic", 0, 0, 100};  // ERROR: Abstract class!

    std::vector<GameEntity*> gameWorld;

    Player* player = new Player{"Hero", 0, 0};
    gameWorld.push_back(player);

    gameWorld.push_back(new Enemy{"Goblin", 10, 5, 50, 15});
    gameWorld.push_back(new Enemy{"Orc", 15, 8, 80, 25});

    std::cout << "\n=== Game Update Loop ===" << "\n";
    for (GameEntity* entity : gameWorld) {
        entity->update();
        entity->render();
        std::cout << "\n";
    }

    std::cout << "=== Combat ===" << "\n";
    Enemy* goblin = dynamic_cast<Enemy*>(gameWorld[1]);
    if (goblin) {
        goblin->attack(*player);
        goblin->attack(*player);
    }

    player->collectCoin();

    std::cout << "\n=== Cleanup ===" << "\n";
    for (GameEntity* entity : gameWorld) {
        delete entity;
    }

    return 0;
}