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

#include <iostream>
#include <string>
#include <list>
//класс Hero, суперкласс для Warrior и Mage, содержит общие характеристики: имя, хп, армор, сила атаки
class Hero {
public:
    Hero(const std::string& name, int health, int armor, int attack_power)
        : name_(name), health_(health), armor_(armor), attack_power_(attack_power) {}
 
    // Получение свойств класса
    const std::string& GetName() const { return name_; }
    int GetHealth() const { return health_; }
    int GetArmor() const { return armor_; }
    int GetAttackPower() const { return attack_power_; }
 
    // Установка свойств класса
    void SetName(const std::string& name) { name_ = name; }
    void SetHealth(int health) { health_ = health; }
    void SetArmor(int armor) { armor_ = armor; }
    void SetAttackPower(int attack_power) { attack_power_ = attack_power; }
    
    
private:
    std::string name_;
    int health_;
    int armor_;
    int attack_power_;
};
 
//класс Воина
class Warrior : public Hero {
public:
    //наследование воина от Hero, добавление свойства weapon - название оружия
    Warrior(const std::string& name, int health, int armor, int attackDamage, const std::string& weapon)
        : Hero(name, health, armor, attackDamage), weapon_(weapon) {}
    //Получение названия и замена оружия
    const std::string& GetWeapon() const { return weapon_; }
    void SetWeapon(const std::string& weapon) { weapon_ = weapon; }
    //Полиморфный метод Info, печатающий информацию о персонаже
    void Info() {
        std::cout << "Имя: " << GetName() << std::endl
            << "Здоровье: " << GetHealth() << std::endl
            << "Броня: " << GetArmor() << std::endl
            << "Оружие: " << GetWeapon() << std::endl
            << "Сила атаки: " << GetAttackPower() << std::endl << std::endl;
    }
    //полиморфный метод strike, симулирующий удар воина. Пока у противника есть броня, урон проходит по ней. Если её нет - по хп
    void Strike(Hero& target) {
        int damage = GetAttackPower();
        int armor = target.GetArmor();
        if (armor > 0) {
            armor -= damage;
            if (armor < 0) {
                damage = -armor;
                armor = 0;
            }
            else {
                damage = 0;
            }
            target.SetArmor(armor);
        }
        if (damage > 0) {
            int health = target.GetHealth() - damage;
            if (health < 0) {
                health = 0;
            }
            target.SetHealth(health);
        }
        std::cout << GetName() << " атакует " << target.GetName()
            << " с помощью " << GetWeapon() << " (физический урон: " << GetAttackPower() << ") " << std::endl <<
            target.GetName() << " броня: " << target.GetArmor() << ", здоровье: " << target.GetHealth() << std::endl;
    }
    private:
        std::string weapon_;
 
};
//класс Воина
class Mage : public Hero {
public:
    //наследование мага от Hero, добавление свойства spell - название заклинания
    Mage(const std::string& name, int health, int armor, int attackDamage, const std::string& spell)
        : Hero(name, health, armor, attackDamage), spell_(spell) {}
    //Получение названия и замена заклинания
    const std::string& GetSpell() const { return spell_; }
    void SetSpell(const std::string& spell) { spell_ = spell; }
    //Полиморфный метод Info, печатающий информацию о персонаже
    void Info() {
        std::cout << "Имя: " << GetName() << std::endl
            << "Здоровье: " << GetHealth() << std::endl
            << "Броня: " << GetArmor() << std::endl
            << "Заклинание: " << GetSpell() << std::endl
            << "Сила атаки: " << GetAttackPower() << std::endl << std::endl;
    }
    //полиморфный метод strike, симулирующий удар мага. Пока у противника есть броня, урон проходит по ней. Если её нет - по хп
    void Strike(Hero& target) {
        int damage = GetAttackPower();
        int armor = target.GetArmor();
        if (armor > 0) {
            armor -= damage;
            if (armor < 0) {
                damage = -armor;
                armor = 0;
            }
            else {
                damage = 0;
            }
            target.SetArmor(armor);
        }
        if (damage > 0) {
            int health = target.GetHealth() - damage;
            if (health < 0) {
                health = 0;
            }
            target.SetHealth(health);
        }
 
        std::cout << GetName() << " атакует " << target.GetName()
            << " с помощью " << GetSpell() << " (магический урон: " << GetAttackPower() << ") " << std::endl <<
            target.GetName() << " броня: " << target.GetArmor() << ", здоровье: " << target.GetHealth() << std::endl;
    }
    private:
        std::string spell_;
 
};
int main() {
    setlocale(LC_ALL, "Russian");
    //создание по экземпляру воина и мага
    Warrior warrior("Довакин", 100, 50, 10, "Деревянный меч (легендарн.)");
    Mage mage("Ксардас", 100, 50, 50, "Огненный шторм");
    warrior.Info();
    mage.Info();
    std::cout << "Да начнётся битва" << std::endl;
    bool Turn = true;
    
    //симуляция дуэли до тех пор, пока у одного из персонажей хп не упадёт до 0
    while (true)
    {
        if (Turn)
        {
            warrior.Strike(mage);
        }
        else
        {
            mage.Strike(warrior);
        }
 
        if (warrior.GetHealth() <= 0)
        {
            std::cout << warrior.GetName() << " повержен!\n";
            break;
        }
        else if (mage.GetHealth() <= 0)
        {
            std::cout << mage.GetName() << " повержен\n";
            break;
        }
        Turn = !Turn;
    }
    
    Warrior warrior2("Старнник", 100, 50, 10, "Посох");
    Mage mage2("Саурон", 100, 50, 50, "Огненный шар");
    Warrior warrior3("Мастер Чиф", 100, 50, 10, "Плазменный меч");
    Mage mage3("Скарлет", 100, 50, 50, "Кровавый дождь");
    //список георев разных классов
    std::list<Hero> heroes;
    heroes.push_back(mage);
    heroes.push_back(warrior);
    heroes.push_back(mage2);
    heroes.push_back(warrior2);
    heroes.push_back(mage3);
    heroes.push_back(warrior3);
    //просмотр списка
    for (Hero i: heroes) {
        std::cout << "Имя: " << i.GetName() << std::endl;
    }
    return 0;
}

/список георев разных классов
    std::list<Hero> heroes;
    heroes.push_back(mage);
    heroes.push_back(warrior);
    heroes.push_back(mage2);
    heroes.push_back(warrior2);
    heroes.push_back(mage3);
    heroes.push_back(warrior3);
    //просмотр списка
    for (Hero i: heroes) {
        std::cout << "Имя: " << i.GetName() << std::endl;
    }
    return 0;
}

#include <iostream>
 
struct LinkedListNodeBase {
    LinkedListNodeBase() : next{this}, prev{this} {}
 
    LinkedListNodeBase(LinkedListNodeBase *before) : next{before}, prev{before->prev} {
        next->prev = prev->next = this;
    }
 
    virtual ~LinkedListNodeBase() {
        prev->next = next;
        next->prev = prev;
    }
 
    LinkedListNodeBase *next;
    LinkedListNodeBase *prev;
};
 
// структура, хранящая один элемент списка;
template<typename T>
struct LinkedListNode : public LinkedListNodeBase {
    T value;
 
    LinkedListNode(LinkedListNodeBase *before, const T &value) : LinkedListNodeBase{before}, value{value} {}
};
 
// простенький класс-обёртка для удобства работы с нодой двусвязного списка
// класс позволет удобно ходить по двусвязному списку,
// сравнивать позиции и получать значения ноды с помощью операторов
template<typename T>
struct LinkedListIterator {
    using iterator_category = std::bidirectional_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = value_type *;
    using reference = value_type &;
 
    LinkedListIterator(LinkedListNodeBase *node) : node{node} {}
 
    // получение значения в ноде
    reference operator*() const {
        return dynamic_cast<LinkedListNode<T> *>(node)->value;
    }
 
    // получение значения в ноде
    pointer operator->() {
        return &(dynamic_cast<LinkedListNode<T> *>(node)->value);
    }
 
    // переход на следующую ноду префиксный
    LinkedListIterator &operator++() {
        node = node->next;
        return *this;
    }
 
    // переход на следующую ноду постфиксный
    LinkedListIterator operator++(int) {
        LinkedListIterator tmp = *this;
        ++(*this);
        return tmp;
    }
 
    // переход на предыдущую ноду префиксный
    LinkedListIterator &operator--() {
        node = node->prev;
        return *this;
    }
 
    // переход на предыдущую ноду постфиксный
    LinkedListIterator operator--(int) {
        LinkedListIterator tmp = *this;
        --(*this);
        return tmp;
    }
 
    // сравнения нод
    friend bool operator==(const LinkedListIterator &a, const LinkedListIterator &b) {
        return a.node == b.node;
    };
 
    friend bool operator!=(const LinkedListIterator &a, const LinkedListIterator &b) {
        return a.node != b.node;
    };
 
    // увеличение на значение
    friend LinkedListIterator operator+(LinkedListIterator iterator, std::size_t n) {
        while (n--) {
            ++iterator;
        }
        return iterator;
    }
 
    // уменьшение на значение
    friend LinkedListIterator operator-(LinkedListIterator iterator, std::size_t n) {
        while (n--) {
            --iterator;
        }
        return iterator;
    }
 
    // нода двусвязного списка
    LinkedListNodeBase *node;
};
 
// такой же, но для константного контекста
template<typename T>
struct ConstLinkedListIterator {
    using iterator_category = std::bidirectional_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = value_type *;
    using reference = value_type &;
 
    ConstLinkedListIterator(const LinkedListNodeBase *node) : node{node} {}
 
    ConstLinkedListIterator(LinkedListIterator<T> other) : node{other.node} {}
 
    // получение значения в ноде
    reference operator*() const {
        return const_cast<LinkedListNode<T>*>(dynamic_cast<const LinkedListNode<T> *>(node))->value;
    }
 
    // получение значения в ноде
    pointer operator->() {
        return &(const_cast<LinkedListNode<T>*>(dynamic_cast<const LinkedListNode<T> *>(node))->value);
    }
 
    // переход на следующую ноду префиксный
    ConstLinkedListIterator &operator++() {
        node = node->next;
        return *this;
    }
 
    // переход на следующую ноду постфиксный
    ConstLinkedListIterator operator++(int) {
        LinkedListIterator tmp = *this;
        ++(*this);
        return tmp;
    }
 
    // переход на предыдущую ноду префиксный
    ConstLinkedListIterator &operator--() {
        node = node->prev;
        return *this;
    }
 
    // переход на предыдущую ноду постфиксный
    ConstLinkedListIterator operator--(int) {
        LinkedListIterator tmp = *this;
        --(*this);
        return tmp;
    }
 
    // сравнения нод
    friend bool operator==(const ConstLinkedListIterator &a, const ConstLinkedListIterator &b) {
        return a.node == b.node;
    };
 
    friend bool operator!=(const ConstLinkedListIterator &a, const ConstLinkedListIterator &b) {
        return a.node != b.node;
    };
 
    // увеличение на значение
    friend ConstLinkedListIterator operator+(ConstLinkedListIterator iterator, std::size_t n) {
        while (n--) {
            ++iterator;
        }
        return iterator;
    }
 
    // уменьшение на значение
    friend ConstLinkedListIterator operator-(ConstLinkedListIterator iterator, std::size_t n) {
        while (n--) {
            --iterator;
        }
        return iterator;
    }
 
    // нода двусвязного списка
    const LinkedListNodeBase *node;
};
 
// структура двусвязного списка
template<typename T>
struct LinkedList {
public:
    using ConstIterator = ConstLinkedListIterator<T>;
    using Iterator = LinkedListIterator<T>;
 
    LinkedList() : base{} {}
 
    LinkedList(const LinkedList<T> &other) : base{} {
        for (const auto &i : other) {
            pushBack(i);
        }
    }
 
    LinkedList(LinkedList<T> && other) noexcept : base{} {
        swap(*this, other);
    }
 
    LinkedList<T> &operator=(LinkedList<T> other) noexcept {
        swap(*this, other);
        return *this;
    }
 
    ~LinkedList() {
        clear();
    }
 
    friend void swap(LinkedList<T> &a, LinkedList<T> &b) noexcept {
        using std::swap;
        swap(a.base, b.base);
    }
 
    // добавление элемента в конец списка;
    Iterator pushBack(const T &value) {
        return insert(end(), value);
    }
 
    Iterator pushFront(const T &value) {
        return insert(begin(), value);
    }
 
    // добавление элемента в заданную позицию списка
    Iterator insert(ConstIterator position, const T &value) {
        return new LinkedListNode{const_cast<LinkedListNodeBase*>(position.node), value};
    }
 
    // удаление элемента списка по указанной позиции в списке
    Iterator erase(ConstIterator position) {
        LinkedListNodeBase *result = position.node->next;
        delete position.node;
        return result;
    }
 
    // получение элемента списка по указанной позиции в списке
    Iterator begin() {
        return base.next;
    }
 
    ConstIterator begin() const {
        return base.next;
    }
 
    Iterator end() {
        return &base;
    }
 
    ConstIterator end() const {
        return &base;
    }
 
    typename Iterator::difference_type getSize() const {
        return distance(begin(), end());
    }
 
    bool isEmpty() const {
        return base.next == &base;
    }
 
    void clear() {
        while (!isEmpty()) {
            delete base.next;
        }
    }
 
private:
    LinkedListNodeBase base;
};
 
class Hero {
public:
    // вот этот метод -- виртуальный
    virtual const std::string &GetName() const = 0;
    virtual ~Hero() = default;
};
 
class Warrior : public Hero {
public:
    Warrior(const std::string &name) : name(name) {}
 
    const std::string &GetName() const override {
        return name;
    }
 
private:
    std::string name;
};
 
class Mage : public Hero {
public:
    Mage(const std::string &name) : name(name) {}
 
    const std::string &GetName() const override {
        return name;
    }
 
private:
    std::string name;
};
 
int main() {
 
    // чтоб был полиморфизм в списке должны быть указатели
    LinkedList<Hero*> x;
 
    x.pushBack(new Warrior("ImaWarrior!"));
    x.pushBack(new Mage("ImaMage!"));
    x.pushBack(new Mage("ImAnotherMage!"));
 
    // вот теперь полиморфизм
    for (const auto &i : x) {
        std::cout << i->GetName() << '\n';
    }
 
    // и не забыть их освободить
    for (const auto &i : x) {
        delete i;
    }
 
    return 0;
}

#include <iostream>
#include <string>
#include <list>
 
// Класс Hero, суперкласс для Warrior и Mage, содержит общие характеристики: имя, хп, армор, сила атаки
class Hero {
public:
    Hero(const std::string& name, int health, int armor, int attack_power)
        : name_(name), health_(health), armor_(armor), attack_power_(attack_power) {}
 
    // Получение свойств класса
    const std::string& GetName() const { return name_; }
    int GetHealth() const { return health_; }
    int GetArmor() const { return armor_; }
    int GetAttackPower() const { return attack_power_; }
 
    // Установка свойств класса
    void SetName(const std::string& name) { name_ = name; }
    void SetHealth(int health) { health_ = health; }
    void SetArmor(int armor) { armor_ = armor; }
    void SetAttackPower(int attack_power) { attack_power_ = attack_power; }
 
private:
    std::string name_;
    int health_;
    int armor_;
    int attack_power_;
};
 
// Класс Воина
class Warrior : public Hero {
public:
    // Наследование воина от Hero, добавление свойства weapon - название оружия
    Warrior(const std::string& name, int health, int armor, int attackDamage, const std::string& weapon)
        : Hero(name, health, armor, attackDamage), weapon_(weapon) {}
 
    // Получение названия и замена оружия
    const std::string& GetWeapon() const { return weapon_; }
    void SetWeapon(const std::string& weapon) { weapon_ = weapon; }
 
    // Полиморфный метод Info, печатающий информацию о персонаже
    void Info() {
        std::cout << "Имя: " << GetName() << std::endl
            << "Здоровье: " << GetHealth() << std::endl
            << "Броня: " << GetArmor() << std::endl
            << "Оружие: " << GetWeapon() << std::endl
            << "Сила атаки: " << GetAttackPower() << std::endl << std::endl;
    }
 
    // Полиморфный метод strike, симулирующий удар воина. Пока у противника есть броня, урон проходит по ней. Если её нет - по хп
    void Strike(Hero& target) {
        int damage = GetAttackPower();
        int armor = target.GetArmor();
        if (armor > 0) {
            armor -= damage;
            if (armor < 0) {
                damage = -armor;
                armor = 0;
            }
            else {
                damage = 0;
            }
            target.SetArmor(armor);
        }
        if (damage > 0) {
            int health = target.GetHealth() - damage;
            if (health < 0) {
                health = 0;
            }
            target.SetHealth(health);
        }
 
        std::cout << GetName() << " атакует " << target.GetName()
            << " с помощью " << GetWeapon() << " (физический урон: " << GetAttackPower() << ") " << std::endl <<
            target.GetName() << " броня: " << target.GetArmor() << ", здоровье: " << target.GetHealth() << std::endl;
    }
 
private:
    std::string weapon_;
};
class Mage : public Hero {
public:
    // Наследование мага от Hero, добавление свойства spell - название заклинания
    Mage(const std::string& name, int health, int armor, int attackDamage, const std::string& spell)
        : Hero(name, health, armor, attackDamage), spell_(spell) {}
 
    // Получение названия и замена заклинания
    const std::string& GetSpell() const { return spell_; }
    void SetSpell(const std::string& spell) { spell_ = spell; }
 
    // Полиморфный метод Info, печатающий информацию о персонаже
    void Info() {
        std::cout << "Имя: " << GetName() << std::endl
            << "Здоровье: " << GetHealth() << std::endl
            << "Броня: " << GetArmor() << std::endl
            << "Заклинание: " << GetSpell() << std::endl
            << "Сила атаки: " << GetAttackPower() << std::endl << std::endl;
    }
 
    // Полиморфный метод strike, симулирующий удар мага. Пока у противника есть броня, урон проходит по ней. Если её нет - по хп
    void Strike(Hero& target) {
        int damage = GetAttackPower();
        int armor = target.GetArmor();
        if (armor > 0) {
            armor -= damage;
            if (armor < 0) {
                damage = -armor;
                armor = 0;
            }
            else {
                damage = 0;
            }
            target.SetArmor(armor);
        }
        if (damage > 0) {
            int health = target.GetHealth() - damage;
            if (health < 0) {
                health = 0;
            }
            target.SetHealth(health);
        }
 
        std::cout << GetName() << " атакует " << target.GetName()
            << " с помощью " << GetSpell() << " (магический урон: " << GetAttackPower() << ") " << std::endl <<
            target.GetName() << " броня: " << target.GetArmor() << ", здоровье: " << target.GetHealth() << std::endl;
    }
 
private:
    std::string spell_;
};
 
// Класс HeroList, представляющий двусвязный список героев
class HeroList {
public:
    HeroList() : head(nullptr), tail(nullptr) {}
 
    // Добавить героя в начало списка
    void PushFront(Hero* hero) {
        // Создать новый узел списка
        HeroNode* newNode = new HeroNode();
        newNode->hero = hero;
 
        // Если список пуст, то новый узел будет и первым, и последним
        if (head == nullptr) {
            head = newNode;
            tail = newNode;
        } else {
            // Иначе, новый узел будет первым, а предыдущий первый узел будет указывать на него
            newNode->next = head;
            head->prev = newNode;
            head = newNode;
        }
    }
 
    // Добавить героя в конец списка
    void PushBack(Hero* hero) {
        // Создать новый узел списка
        HeroNode* newNode = new HeroNode();
        newNode->hero = hero;
 
        // Если список пуст, то новый узел будет и первым, и последним
        if (tail == nullptr) {
            head = newNode;
            tail = newNode;
        } else {
            // Иначе, новый узел будет последним, а следующий последний узел будет указывать на него
            newNode->prev = tail;
            tail->next = newNode;
            tail = newNode;
        }
    }
 
    // Вставить героя после определенного героя
    void InsertAfter(Hero* hero, Hero* after) {
        // Если after == nullptr, то добавить героя в начало списка
        if (after == nullptr) {
            PushFront(hero);
            return;
        }
 
        // Найти узел, после которого нужно вставить новый узел
        HeroNode* current = head;
        while (current != nullptr && current->hero != after) {
            current = current->next;
        }
 
        // Если after не найден, то ничего не делать
        if ( if (after != nullptr) {
            return;
    }
            // Если after найден, то вставить новый узел после него
        if (current != nullptr) {
            // Создать новый узел списка
            HeroNode* newNode = new HeroNode();
            newNode->hero = hero;
 
            // Связать новый узел с предыдущим и последующим узлами
            newNode->prev = current;
            newNode->next = current->next;
            current->next->prev = newNode;
            current->next = newNode;
        }
    }
 
    // Удалить героя из списка
    void Remove(Hero* hero) {
        // Если список пуст, то ничего не делать
        if (head == nullptr) {
            return;
        }
 
        // Найти узел с указанным героем
        HeroNode* current = head;
        while (current != nullptr && current->hero != hero) {
            current = current->next;
        }
 
        // Если герой не найден, то ничего не делать
        if (current == nullptr) {
            return;
        }
 
        // Если удаляемый герой является первым или последним, то изменить ссылки на первый или последний элемент списка
        if (current == head) {
            head = current->next;
            if (head != nullptr) {
                head->prev = nullptr;
            }
        } else if (current == tail) {
            tail = current->prev;
            if (tail != nullptr) {
                tail->next = nullptr;
            }
        } else {
            // Если удаляемый герой находится в середине списка, то изменить ссылки на предыдущий и следующий узлы
            current->prev->next = current->next;
            current->next->prev = current->prev;
        }
 
        // Удалить узел из памяти
        delete current;
    }
 
    // Получить первый элемент списка
    Hero* GetHead() {
        return head->hero;
    }
 
    // Получить последний элемент списка
    Hero* GetTail() {
        return tail->hero;
    }
 
    // Получить количество элементов в списке
    int GetSize() {
        int size = 0;
        HeroNode* current = head;
        while (current != nullptr) {
            size++;
            current = current->next;
        }
        return size;
    }
 
private:
    // Структура узла списка
    struct HeroNode {
        Hero* hero;
        HeroNode* prev;
        HeroNode* next;
    };
 
    HeroNode* head;
    HeroNode* tail;
};
 
int main() {
    // Создать список героев
    HeroList list;
 
    // Добавить героев в список
    list.PushFront(new Warrior("Довакин", 100, 50, 10, "Деревянный меч (легендарн.)"));
    list.PushFront(new Mage("Ксардас", 100, 50, 50, "Огненный шторм"));
    list.PushBack(new Warrior("Старнник", 100, 50, 10, "Посох"));
    list.PushBack(new Mage("Саурон", 100, 50, 50, "Огненный шар"));
    list.PushBack(new Warrior("Мастер Чиф", 100, 50, 10, "Плазменный меч"));
    list.PushBack(new Mage("Скарлет", 100, 50, 50, "Кровавый дождь"));
 
    // Просмотреть список
    for (Hero* hero : list) {
        std::cout << "Имя: " << hero->GetName() << std::endl;
    }
 
    // Удалить героя из списка
    list.Remove(new Warrior("Мастер Чиф"));
 
    // Просмотреть список после удаления
    for (Hero* hero : list) {
        std::cout << "Имя: " << hero->GetName() << std::endl;
    }
 
    return 0;
}

#include <iostream>
#include <string>
 
// Класс Hero, суперкласс для Warrior и Mage, содержит общие характеристики: имя, хп, армор, сила атаки
class Hero {
public:
    Hero(const std::string &name) : name(name) {}
 
    virtual const std::string &getName() const {
        return name;
    }
 
    virtual std::ostream &operator<<(std::ostream &os) const = 0;
 
    virtual ~Hero() = default;
 
 
private:
    std::string name;
};
 
class Fighter : public Hero {
public:
    Fighter(const std::string &name, int strength) : Hero(name), strength(strength) {}
 
    virtual int getStrength() const {
        return strength;
    };
 
private:
    int strength;
};
 
class Caster : public Hero {
public:
    Caster(const std::string &name, int intelligence) : Hero(name), intelligence(intelligence) {}
 
    virtual int getIntelligence() const {
        return intelligence;
    }
 
private:
    int intelligence;
};
 
class Warrior : public Fighter {
public:
    Warrior(const std::string &name, int strength, const std::string &weapon)
        : Fighter(name, strength), weapon(weapon) {}
 
    virtual const std::string &getWeapon() const {
        return weapon;
    }
 
    std::ostream &operator<<(std::ostream &out) const override {
        return out << "Warrior{"
                << "name='" << getName() << "',"
                << "weapon='" << getWeapon() << "',"
                << "strength=" << getStrength()
                << "}";
    }
 
private:
    std::string weapon;
};
 
class Wizard : public Caster {
public:
    Wizard(const std::string &name, int intelligence, const std::string &spell)
        : Caster(name, intelligence), spell(spell) {}
 
    virtual const std::string &getSpell() const {
        return spell;
    }
 
    std::ostream &operator<<(std::ostream &out) const override {
        return out << "Wizard{"
                   << "name='" << getName() << "',"
                   << "spell='" << getSpell() << "',"
                   << "strength=" << getIntelligence()
                   << "}";
    }
 
private:
    std::string spell;
};
 
std::ostream &operator<<(std::ostream &out, const Hero &hero) {
    hero << out;
    return out;
}
 
// добавим сущность "базового" узла двусвязного списка
// который будет самовставляться
struct Node {
    // в базовом конструкторе нода ссылается на саму себя
    Node() : prev(this), next(this) {}
    // в этом конструкторе нода сама вставляется после указанной ноды
    Node(Node *after) : prev(after), next(after->next) {
        prev->next = next->prev = this;
    }
    // при вызове деструктора такая нода самоудаляется из двусвязного списка
    virtual ~Node() {
        prev->next = next;
        next->prev = prev;
    }
    Node *prev;
    Node *next;
};
 
// Структура узла списка
struct HeroNode : public Node {
    HeroNode(Node *after, Hero *hero) : Node(after), hero(hero) {}
    Hero* hero;
};
 
// Класс HeroList, представляющий двусвязный список героев
class HeroList {
public:
    HeroList() : base() {}
 
    // в деструкторе удаляются все ноды
    ~HeroList() {
        clear();
    }
 
    // следующие пять штук надо по "правилу пяти"
    // для простоты оставил пустыми
    HeroList(const HeroList &) = delete;
    HeroList(HeroList &&) noexcept = delete;
    HeroList &operator=(const HeroList &) = delete;
    HeroList &operator=(HeroList &&) noexcept = delete;
 
    // Добавить героя в начало списка
    void PushFront(Hero* hero) {
        // Создать новый узел списка
        new HeroNode(&base, hero);
    }
 
    // Добавить героя в конец списка
    void PushBack(Hero* hero) {
        // Создать новый узел списка
        new HeroNode(base.prev, hero);
    }
 
    // Вставить героя после определенного героя
    void InsertAfter(Hero* hero, Node* after) {
        new HeroNode(after, hero);
    }
 
    // Удалить героя из списка
    void Remove(Node* position) {
        delete position;
    }
 
    // метод, удаляющий все ноды из списка
    void clear() {
        while (base.next != &base) {
            delete base.next;
        }
    }
 
    Node *begin() {
        return base.next;
    }
 
    Node *end() {
        return &base;
    }
 
private:
    // базовая нода двусвязного списка
    Node base;
};
 
int main() {
    // Создать список героев
    HeroList list;
 
    // Добавить героев в список
    list.PushFront(new Warrior("Довакин", 100, "Деревянный меч (легендарн.)"));
    list.PushFront(new Wizard("Ксардас", 100, "Огненный шторм"));
    list.PushBack(new Warrior("Старнник", 100, "Посох"));
    list.PushBack(new Wizard("Саурон", 100, "Огненный шар"));
    list.PushBack(new Warrior("Мастер Чиф", 100, "Плазменный меч"));
    list.PushBack(new Wizard("Скарлет", 100,"Кровавый дождь"));
 
    // Просмотреть список
    for (Node *i = list.begin(); i != list.end(); i = i->next) {
        std::cout << "Герой: "
            << *dynamic_cast<HeroNode*>(i)->hero
            << std::endl;
    }
 
    // Удалить первого героя из списка
    // сначала освободить память, выделенную ранее под героя
    delete dynamic_cast<HeroNode*>(list.begin())->hero;
    // теперь удалить указатель из списка
    list.Remove(list.begin());
 
    // Просмотреть список после удаления
    for (Node *i = list.begin(); i != list.end(); i = i->next) {
        std::cout << "Герой: "
            << *dynamic_cast<HeroNode*>(i)->hero
            << std::endl;
    }
 
    // освободить выделенную под героев память
    for (Node *i = list.begin(); i != list.end(); i = i->next) {
        delete dynamic_cast<HeroNode*>(i)->hero;
    }
 
    return 0;
}

#include <iostream>
#include <string>
 
// Базовый класс героя
class Hero {
public:
    Hero(const std::string& name, int health, const std::string& weapon)
        : name(name), health(health), armor(50), weapon(weapon) {}
 
    virtual ~Hero() {}
 
    virtual int attack() = 0;
    virtual void defend(int damage) = 0;
 
    const std::string& getName
() const {
        return name;
    }
 
    int getHealth() const {
        return health;
    }
 
    int getArmor() const {
        return armor;
    }
 
    const std::string& getWeapon() const {
        return weapon;
    }
 
protected:
    std::string name;
    int health;
    int armor;
    std::string weapon;
};
// Класс воина, наследуется от класса героя
class Warrior : public Hero {
public:
    Warrior(const std::string& name, int health, const std::string& weapon)
        : Hero(name, health, weapon) {}
 
    int attack() override {
        return 10;
    }
    void defend(int damage) override {
        int actualDamage = damage - armor;
        if (actualDamage > 0) {
            health -= actualDamage;
        }
    }
};
// Класс мага, наследуется от класса героя
class Wizard : public Hero {
public:
    Wizard(const std::string& name, int health, const std::string& spell)
        : Hero(name, health, spell) {}
 
    int attack() override {
        return 50;
    }
 
    void defend(int damage) override {
        int actualDamage = damage - armor;
        if (actualDamage > 0) {
            health -= actualDamage;
        }
    }
};
// Узел списка героев
struct Node {
    Node* next;
    Node* prev;
};
// Узел списка героев, содержит указатель на объект героя
struct HeroNode : public Node {
    Hero* hero;
};
 
// Список героев
class HeroList {
public:
    HeroList() : head(nullptr), tail(nullptr) {}
 
    ~HeroList() {
        Node* current = head;
        while (current != nullptr) {
            Node* next = current->next;
            delete current;
            current = next;
        }
    }
 
    void PushFront(Hero* hero) {
        HeroNode* heroNode = new HeroNode;
        heroNode->hero = hero;
        heroNode->prev = nullptr;
        heroNode->next = head;
 
        if (head != nullptr) {
            head->prev = heroNode;
        } else {
            tail = heroNode;
        }
 
        head = heroNode;
    }
 
    void PushBack(Hero* hero) {
        HeroNode* heroNode = new HeroNode;
        heroNode->hero = hero;
        heroNode->prev = tail;
        heroNode->next = nullptr;
 
        if (tail != nullptr) {
            tail->next = heroNode;
        } else {
            head = heroNode;
        }
 
        tail = heroNode;
    }
 
    Node* begin() const {
        return head;
    }
 
    Node* end() const {
        return nullptr;
    }
 
private:
    Node* head;
    Node* tail;
};
 
// Добавим функцию для проведения дуэли
void duel(Hero* hero1, Hero* hero2) {
    std::cout << "Да начнётся битва" << std::endl;
 
    while (hero1->getHealth() > 0 && hero2->getHealth() > 0) {
        // Герой 1 атакует героя 2
        int damage1 = hero1->attack();
        hero2->defend(damage1);
        std::cout << hero1->getName() << " атакует " << hero2->getName() << " с помощью " << hero1->getWeapon() << " (физический урон: " << damage1 << ")" << std::endl;
        std::cout << hero2->getName() << " броня: " << hero2->getArmor() << ", здоровье: " << hero2->getHealth() << std::endl;
 
        if (hero2->getHealth() <= 0) {
            std::cout << hero2->getName() << " повержен!" << std::endl;
            break;
        }
        // Герой 2 атакует героя 1
        int damage2 = hero2->attack();
        hero1->defend(damage2);
        std::cout << hero2->getName() << " атакует " << hero1->getName() << " с помощью " << hero2->getWeapon() << " (физический урон: " << damage2 << ")" << std::endl;
        std::cout << hero1->getName() << " броня: " << hero1->getArmor() << ", здоровье: " << hero1->getHealth() << std::endl;
 
        if (hero1->getHealth() <= 0) {
            std::cout << hero1->getName() << " повержен!" << std::endl;
            break;
        }
    }
}
int main() {
    // Создать список героев
    HeroList list;
 
    // Добавить героев в список
    list.PushFront(new Warrior("Довакин", 100, "Деревянный меч (легендарн.)"));
    list.PushFront(new Wizard("Ксардас", 100, "Огненный шторм"));
    list.PushBack(new Warrior("Старнник", 100, "Посох"));
    list.PushBack(new Wizard("Саурон", 100, "Огненный шар"));
    list.PushBack(new Warrior("Мастер Чиф", 100, "Плазменный меч"));
    list.PushBack(new Wizard("Скарлет", 100, "Кровавый дождь"));
 
    // Просмотреть список
    for (Node* i = list.begin(); i != list.end(); i = i->next) {
        std::cout << "Герой: " << *dynamic_cast<HeroNode*>(i)->hero << std::endl;
    }
 
    // Начать дуэль между первыми двумя героями
    Hero* hero1 = dynamic_cast<HeroNode*>(list.begin())->hero;
    Hero* hero2 = dynamic_cast<HeroNode*>(list.begin()->next)->hero;
    duel(hero1, hero2);
 
    // Освободить выделенную под героев память
    for (Node* i = list.begin(); i != list.end(); i = i->next) {
        delete dynamic_cast<HeroNode*>(i)->hero;
    }
 
    return 0;
}

#include <iostream>
#include <string>
 
// Класс Hero, суперкласс для Warrior и Mage, содержит общие характеристики: имя, хп, армор, сила атаки
class Hero {
public:
    Hero(const std::string& name) : name(name) {}
 
    virtual const std::string& getName() const {
        return name;
    }
 
    virtual std::ostream& operator<<(std::ostream& os) const = 0;
 
    virtual ~Hero() = default;
 
private:
    std::string name;
};
 
class Fighter : public Hero {
public:
    Fighter(const std::string& name, int strength) : Hero(name), strength(strength) {}
 
    virtual int getStrength() const {
        return strength;
    };
 
private:
    int strength;
};
 
class Caster : public Hero {
public:
    Caster(const std::string& name, int intelligence) : Hero(name), intelligence(intelligence) {}
 
    virtual int getIntelligence() const {
        return intelligence;
    }
 
private:
    int intelligence;
};
 
class Warrior : public Fighter {
public:
    Warrior(const std::string& name, int strength, const std::string& weapon)
        : Fighter(name, strength), weapon(weapon) {}
 
    virtual const std::string& getWeapon() const {
        return weapon;
    }
 
    std::ostream& operator<<(std::ostream& out) const override {
        return out << "Warrior{"
                   << "name='" << getName() << "',"
                   << "weapon='" << getWeapon() << "',"
                   << "strength=" << getStrength()
                   << "}";
    }
 
private:
    std::string weapon;
};
 
class Wizard : public Caster {
public:
    Wizard(const std::string& name, int intelligence, const std::string& spell)
        : Caster(name, intelligence), spell(spell) {}
 
    virtual const std::string& getSpell() const {
        return spell;
    }
 
    std::ostream& operator<<(std::ostream& out) const override {
        return out << "Wizard{"
                   << "name='" << getName() << "',"
                   << "spell='" << getSpell() << "',"
                   << "intelligence=" << getIntelligence()
                   << "}";
    }
 
private:
    std::string spell;
};
 
std::ostream& operator<<(std::ostream& out, const Hero& hero) {
    hero << out;
    return out;
}
 
// добавим сущность "базового" узла двусвязного списка
// который будет самовставляться
struct Node {
    // в базовом конструкторе нода ссылается на саму себя
    Node() : prev(this), next(this) {}
    // в этом конструкторе нода сама вставляется после указанной ноды
    Node(Node* after) : prev(after), next(after->next) {
        prev->next = next->prev = this;
    }
    // при вызове деструктора такая нода самоудаляется из двусвязного списка
    virtual ~Node() {
        prev->next = next;
        next->prev = prev;
    }
    Node* prev;
    Node* next;
};
 
// Структура узла списка
struct HeroNode : public Node {
    HeroNode(Node* after, Hero* hero) : Node(after), hero(hero) {}
    Hero* hero;
};
 
// Класс HeroList, представляющий двусвязный список героев
class HeroList {
public:
    HeroList() : base() {}
 
    // в деструкторе удаляются все ноды
    ~HeroList() {
        clear();
    }
 
    // следующие пять штук надо по "правилу пяти"
    // для простоты оставил пустыми
    HeroList(const HeroList&) = delete;
    HeroList(HeroList&&) noexcept = delete;
    HeroList& operator=(const HeroList&) = delete;
    HeroList& operator=(HeroList&&) noexcept = delete;
 
    // Добавить героя в начало списка
    void PushFront(Hero* hero) {
        // Создать новый узел списка
        new HeroNode(&base, hero);
    }
 
    // Добавить героя в конец списка
    void PushBack(Hero* hero) {
        // Создать новый узел списка
        new HeroNode(base.prev, hero);
    }
 
    // Вставить героя после определенного героя
    void InsertAfter(Hero* hero, Node* a
 
fter) {
        new HeroNode(after, hero);
    }
 
    // Удалить героя из списка
    void Remove(Node* position) {
        delete position;
    }
 
    // метод, удаляющий все ноды из списка
    void clear() {
        while (base.next != &base) {
            delete base.next;
        }
    }
 
    Node* begin() {
        return base.next;
    }
 
    Node* end() {
        return &base;
    }
 
    void Duel(Hero* h1, Hero* h2) {
        std::cout << "Дуэль между " << h1->getName() << " и " << h2->getName() << " начинается!" << std::endl;
 
        // Логика для проведения дуэли между персонажами
        // Например, вы можете сравнивать их характеристики и выводить результаты
 
        if (h1->getStrength() > h2->getIntelligence()) {
            std::cout << h1->getName() << " побеждает " << h2->getName() << "!" << std::endl;
        } else if (h1->getStrength() < h2->getIntelligence()) {
            std::cout << h2->getName() << " побеждает " << h1->getName() << "!" << std::endl;
        } else {
            std::cout << "Ничья!" << std::endl;
        }
    }
 
private:
    // базовая нода двусвязного списка
    Node base;
};
 
int main() {
    // Создать список героев
    HeroList list;
 
    // Добавить героев в список
    list.PushFront(new Warrior("Довакин", 100, "Деревянный меч (легендарн.)"));
    list.PushFront(new Wizard("Ксардас", 100, "Огненный шторм"));
    list.PushBack(new Warrior("Старнник", 100, "Посох"));
    list.PushBack(new Wizard("Саурон", 100, "Огненный шар"));
    list.PushBack(new Warrior("Мастер Чиф", 100, "Плазменный меч"));
    list.PushBack(new Wizard("Скарлет", 100, "Кровавый дождь"));
 
    // Просмотреть список и вывод характеристик героев
    for (Node* i = list.begin(); i != list.end(); i = i->next) {
        std::cout << "Герой: " << *dynamic_cast<HeroNode*>(i)->hero << std::endl;
    }
 
    // Выбрать персонажей для дуэли
    Hero* hero1 = dynamic_cast<HeroNode*>(list.begin())->hero;
    Hero* hero2 = dynamic_cast<HeroNode*>(list.begin()->next)->hero;
 
    // Проведение дуэли
    list.Duel(hero1, hero2);
 
    // Освобождение памяти, выделенной под героев
    list.clear();
 
    return 0;
}

#include <iostream>
#include <string>
 
class Hero {
 public:
  Hero(const std::string& name, int health, int armor, int attack_power)
      : name_(name), health_(health), armor_(armor), attack_power_(attack_power) {}
 
  const std::string& GetName() const { return name_; }
  int GetHealth() const { return health_; }
  int GetArmor() const { return armor_; }
  int GetAttackPower() const { return attack_power_; }
 
  void SetName(const std::string& name) { name_ = name; }
  void SetHealth(int health) { health_ = health; }
  void SetArmor(int armor) { armor_ = armor; }
  void SetAttackPower(int attack_power) { attack_power_ = attack_power; }
 
  virtual void Strike(Hero& target) {
    std::cout << "Метод Strike должен быть переопределен в классах-наследниках" << std::endl;
  }
 
  virtual ~Hero() {}
 
  friend std::ostream& operator<<(std::ostream& out, const Hero& hero) {
    out << "Имя: " << hero.GetName() << std::endl
        << "Здоровье: " << hero.GetHealth() << std::endl
        << "Броня: " << hero.GetArmor() << std::endl
        << "Сила атаки: " << hero.GetAttackPower() << std::endl;
    return out;
  }
 
 private:
  std::string name_;
  int health_;
  int armor_;
  int attack_power_;
};
 
class Warrior : public Hero {
 public:
  Warrior(const std::string& name, int health, int armor, int attack_power,
           const std::string& weapon)
      : Hero(name, health, armor, attack_power), weapon_(weapon) {}
 
  const std::string& GetWeapon() const { return weapon_; }
  void SetWeapon(const std::string& weapon) { weapon_ = weapon; }
 
  void Strike(Hero& target) override {
    int damage = GetAttackPower();
    int armor = target.GetArmor();
    if (armor > 0) {
      armor -= damage;
      if (armor < 0) {
        damage = -armor;
        armor = 0;
      } else {
        damage = 0;
      }
      target.SetArmor(armor);
    }
    if (damage > 0) {
      int health = target.GetHealth() - damage;
      if (health < 0) {
        health = 0;
      }
      target.SetHealth(health);
    }
    std::cout << GetName() << " атакует " << target.GetName()
              << " с помощью " << GetWeapon() << " (физический урон: " << GetAttackPower() << ") " << std::endl
              << target.GetName() << " броня: " << target.GetArmor() << ", здоровье: " << target.GetHealth() << std::endl;
  }
 
 private:
  std::string weapon_;
};
 
class Mage : public Hero {
 public:
  Mage(const std::string& name, int health, int armor, int attack_power,
         const std::string& spell)
      : Hero(name, health, armor, attack_power), spell_(spell) {}
 
  const std::string& GetSpell() const { return spell_; }
  void SetSpell(const std::string& spell) { spell_ = spell; }
 
  void Strike(Hero& target) override {
    int damage = GetAttackPower();
    int armor = target.GetArmor();
    if (armor > 0) {
      armor -= damage;
      if (armor < 0) {
        damage = -armor;
        armor = 0;
      } else {
        damage = 0;
      }
      target.SetArmor(armor);
    }
    if (damage > 0) {
      int health = target.GetHealth() - damage;
      if (health < 0) {
        health = 0;
      }
      target.SetHealth(health);
    }
    std::cout << GetName() << " атакует " << target.GetName()
              << " с помощью " << GetSpell() << " (магический урон: " << GetAttackPower() << ") " << std::endl
              << target.GetName() << " броня: " << target.GetArmor() << ", здоровье: " << target.GetHealth() << std::endl;
  }
 
 private:
  std::string spell_;
};
 
class LinkedList {
 private:
  struct Node {
    Hero* data;
    Node* prev;
    Node* next;
 
    Node(Hero* hero, Node* previous = nullptr, Node* nextNode = nullptr)
        : data(hero), prev(previous), next(nextNode) {}
  };
 
 public:
  LinkedList() : head(nullptr), tail(nullptr) {}
 
  ~LinkedList() {
    Node* current = head;
    while (current != nullptr) {
      Node* next = current->next;
      delete current->data;
      delete current;
      current = next;
    }
  }
 
  void PushBack(Hero* hero) {
    Node* newNode = new Node(hero, tail);
    if (tail != nullptr) {
      tail->next = newNode;
    } else {
      head = newNode;
    }
    tail = newNode;
  }
 
  void PopFront() {
    if (head != nullptr) {
      Node* next = head->next;
      delete head->data;
      delete head;
      head = next;
      if (next != nullptr) {
        next->prev = nullptr;
      } else {
        tail = nullptr;
      }
    }
  }
 
  void PrintList() const {
    Node* current = head;
    while (current != nullptr) {
      std::cout << *current->data << std::endl;
      current = current->next;
    }
  }
 
 private:
  Node* head;
  Node* tail;
};
 
int main() {
  Warrior warrior("Довакин", 100, 50, 10, "Деревянный меч (легендарный)");
  Mage mage("Ксардас", 100, 50, 50, "Огненный шторм");
 
  LinkedList heroes;
  heroes.PushBack(&warrior);
  heroes.PushBack(&mage);
 
  std::cout << "Да начнётся битва" << std::endl;
 
  while (warrior.GetHealth() > 0 && mage.GetHealth() > 0) {
    warrior.Strike(mage);
    if (mage.GetHealth() <= 0) {
      std::cout << "Ксардас повержен!" << std::endl;
      break;
    }
    mage.Strike(warrior);
    if (warrior.GetHealth() <= 0) {
        std::cout << "Довакин повержен!" << std::endl;
      break;
    }
  }
 
  std::cout << "Герой: Маг" << std::endl << mage << std::endl;
 
  return 0;
}

#include <iostream>
#include <string>
 
using namespace std;
 
class Hero {
 public:
  Hero(const string& name, int health, int armor, int attack_power)
      : name_(name), health_(health), armor_(armor), attack_power_(attack_power) {}
 
  const string& GetName() const { return name_; }
  int GetHealth() const { return health_; }
  int GetArmor() const { return armor_; }
  int GetAttackPower() const { return attack_power_; }
 
  void SetName(const string& name) { name_ = name; }
  void SetHealth(int health) { health_ = health; }
  void SetArmor(int armor) { armor_ = armor; }
  void SetAttackPower(int attack_power) { attack_power_ = attack_power; }
 
  virtual void Strike(Hero& target) {
    cout << "Метод Strike должен быть переопределен в классах-наследниках" << endl;
  }
 
  virtual ~Hero() {}
 
  friend ostream& operator<<(ostream& out, const Hero& hero) {
    out << "Имя: " << hero.GetName() << endl
        << "Здоровье: " << hero.GetHealth() << endl
        << "Броня: " << hero.GetArmor() << endl
        << "Сила атаки: " << hero.GetAttackPower() << endl;
    return out;
  }
 
 private:
  string name_;
  int health_;
  int armor_;
  int attack_power_;
};
 
class Warrior : public Hero {
 public:
  Warrior(const string& name, int health, int armor, int attack_power,
           const string& weapon)
      : Hero(name, health, armor, attack_power), weapon_(weapon) {}
 
  const string& GetWeapon() const { return weapon_; }
  void SetWeapon(const string& weapon) { weapon_ = weapon; }
 
  void Strike(Hero& target) override {
    int damage = GetAttackPower();
    int armor = target.GetArmor();
    if (armor > 0) {
      armor -= damage;
      if (armor < 0) {
        damage = -armor;
        armor = 0;
      } else {
        damage = 0;
      }
      target.SetArmor(armor);
    }
    if (damage > 0) {
      int health = target.GetHealth() - damage;
      if (health < 0) {
        health = 0;
      }
      target.SetHealth(health);
    }
    cout << GetName() << " атакует " << target.GetName()
              << " с помощью " << GetWeapon() << " (физический урон: " << GetAttackPower() << ") " << endl
              << target.GetName() << " броня: " << target.GetArmor() << ", здоровье: " << target.GetHealth() << endl;
  }
 
 private:
  string weapon_;
};
 
class Mage : public Hero {
 public:
  Mage(const string& name, int health, int armor, int attack_power,
         const string& spell)
      : Hero(name, health, armor, attack_power), spell_(spell) {}
 
  const string& GetSpell() const { return spell_; }
  void SetSpell(const string& spell) { spell_ = spell; }
 
  void Strike(Hero& target) override {
    int damage = GetAttackPower();
    int armor = target.GetArmor();
    if (armor > 0) {
      armor -= damage;
      if (armor < 0) {
        damage = -armor;
        armor = 0;
      } else {
        damage = 0;
      }
      target.SetArmor(armor);
    }
    if (damage > 0) {
      int health = target.GetHealth() - damage;
      if (health < 0) {
        health = 0;
      }
      target.SetHealth(health);
    }
    cout << GetName() << " атакует " << target.GetName()
              << " с помощью " << GetSpell() << " (магический урон: " << GetAttackPower() << ") " << endl
              << target.GetName() << " броня: " << target.GetArmor() << << ", здоровье: " << target.GetHealth() << std::endl;
  }
class LinkedList {
 private:
  struct Node {
    Hero* data;
    Node* prev;
    Node* next;
 
    Node(Hero* hero, Node* previous = nullptr, Node* nextNode = nullptr)
        : data(hero), prev(previous), next(nextNode) {}
  };
 
 public:
  LinkedList() : head(nullptr), tail(nullptr) {}
 
  ~LinkedList() {
    Node* current = head;
    while (current != nullptr) {
      Node* next = current->next;
      delete current->data;
      delete current;
      current = next;
    }
  }
 
  void PushBack(Hero* hero) {
    Node* newNode = new Node(hero, tail);
    if (tail != nullptr) {
      tail->next = newNode;
    } else {
      head = newNode;
    }
    tail = newNode;
  }
 
  void PopFront() {
    if (head != nullptr) {
      Node* next = head->next;
      delete head->data;
      delete head;
      head = next;
      if (next != nullptr) {
        next->prev = nullptr;
      } else {
        tail = nullptr;
      }
    }
  }
 
  void PrintList() const {
    Node* current = head;
    while (current != nullptr) {
      cout << *current->data << endl;
      current = current->next;
    }
  }
 
  void PrintHeroes() const {
    Node* current = head;
    while (current != nullptr) {
      cout << current->data->GetName() << endl;
      current = current->next;
    }
  }
 
 private:
  Node* head;
  Node* tail;
};
 
int main() {
  Warrior warrior("Довакин", 100, 50, 10, "Деревянный меч (легендарный)");
  Mage mage("Ксардас", 100, 50, 50, "Огненный шторм");
 
  LinkedList heroes;
  heroes.PushBack(&warrior);
  heroes.PushBack(&mage);
 
  cout << "Да начнётся битва" << endl;
 
  while (warrior.GetHealth() > 0 && mage.GetHealth() > 0) {
    heroes.PrintHeroes();
    warrior.Strike(mage);
    if (mage.GetHealth() <= 0) {
      cout << "Ксардас повержен!" << endl;
      break;
    }
    mage.Strike(warrior);
    if (warrior.GetHealth() <= 0) {
      cout << "Довакин повержен!" << endl;
      break;
    }
  }
 
  return 0;
}