P5.h

#ifndef P5_H_INCLUDED
#define P5_H_INCLUDED

#include <iostream>
#include <list>
#include <vector>
using namespace std;

// Áàçîâûé êëàññ Tank (òàíê)
class Tank {
private:
    int armor;      // Óðîâåíü áðîíè
    double speed;   // Ñêîðîñòü
    string weapon;  // Òèï îðóæèÿ

protected:
    bool isOperational; // Ñîñòîÿíèå òàíêà (èñïðàâåí/íåèñïðàâåí)

public:
    Tank(int armor, double speed, string weapon);
    virtual ~Tank();

    int GetArmor() const { return armor; }
    double GetSpeed() const { return speed; }
    string GetWeapon() const { return weapon; }
    bool IsOperational() const { return isOperational; }

    virtual void StartEngine() = 0;
    virtual void Move() = 0;
    virtual void Attack() = 0;
};

// Êîíêðåòíûå êëàññû òàíêîâ
class LightTank : public Tank {
public:
    LightTank();
    ~LightTank();
    void StartEngine() override;
    void Move() override;
    void Attack() override;
};

class MediumTank : public Tank {
public:
    MediumTank();
    ~MediumTank();
    void StartEngine() override;
    void Move() override;
    void Attack() override;
};

class HeavyTank : public Tank {
public:
    HeavyTank();
    ~HeavyTank();
    void StartEngine() override;
    void Move() override;
    void Attack() override;
};

// Òèïû òàíêîâ äëÿ ôàáðèêè
enum class TankType {
    Light,
    Medium,
    Heavy
};

// Ôàáðèêà äëÿ ñîçäàíèÿ òàíêîâ
Tank* CreateTank(TankType type);

// Áàçîâûé èíòåðôåéñ èòåðàòîðà
template<typename T>
class Iterator {
public:
    virtual ~Iterator() {}
    virtual void First() = 0;        // Ïåðåõîä ê ïåðâîìó ýëåìåíòó
    virtual void Next() = 0;         // Ïåðåõîä ê ñëåäóþùåìó ýëåìåíòó
    virtual bool IsDone() const = 0; // Ïðîâåðêà çàâåðøåíèÿ îáõîäà
    virtual T GetCurrent() const = 0; // Ïîëó÷åíèå òåêóùåãî ýëåìåíòà
};

// Áàçîâûé èíòåðôåéñ êîíòåéíåðà
template<typename T>
class TankContainer {
public:
    virtual ~TankContainer() {}
    virtual Iterator<T*>* GetIterator() const = 0; // Âèðòóàëüíûé ìåòîä ïîëó÷åíèÿ èòåðàòîðà
};

// Øàáëîííûé êëàññ ìàññèâà òàíêîâ
template<typename T, size_t N = 30>
class TankArray : public TankContainer<T> {
private:
    T* items[N];
    size_t size;

public:
    TankArray();
    void Add(T* item);
    T* Get(size_t index) const;
    size_t Size() const;

    // Âëîæåííûé êëàññ èòåðàòîðà äëÿ ìàññèâà
    class ArrayIterator;
    Iterator<T*>* GetIterator() const override;
};

// Øàáëîííûé êëàññ ñïèñêà òàíêîâ
template<typename T>
class TankList : public TankContainer<T> {
private:
    list<T*> items;

public:
    void Add(T* item);
    size_t Size() const;

    // Âëîæåííûé êëàññ èòåðàòîðà äëÿ ñïèñêà
    class ListIterator;
    Iterator<T*>* GetIterator() const override;
};

// Áàçîâûé êëàññ äåêîðàòîðà èòåðàòîðà
template<typename T>
class IteratorDecorator : public Iterator<T> {
protected:
    Iterator<T>* It; // Îáåðíóòûé èòåðàòîð

public:
    IteratorDecorator(Iterator<T>* it) : It(it) {}
    virtual ~IteratorDecorator() { delete It; }

    // Ñòàíäàðòíîå ïîâåäåíèå - äåëåãèðîâàíèå îáåðíóòîìó èòåðàòîðó
    virtual void First() { It->First(); }
    virtual void Next() { It->Next(); }
    virtual bool IsDone() const { return It->IsDone(); }
    virtual T GetCurrent() const { return It->GetCurrent(); }
};

// Äåêîðàòîð äëÿ ôèëüòðàöèè ïî ñîñòîÿíèþ òàíêà
class OperationalTankDecorator : public IteratorDecorator<Tank*> {
public:
    OperationalTankDecorator(Iterator<Tank*>* it) : IteratorDecorator<Tank*>(it) {}

    void First() override {
        It->First();
        SkipNonOperational();
    }

    void Next() override {
        It->Next();
        SkipNonOperational();
    }

private:
    void SkipNonOperational() {
        while (!It->IsDone() && !It->GetCurrent()->IsOperational()) {
            It->Next();
        }
    }
};

// Äåêîðàòîð äëÿ ôèëüòðàöèè ïî ìèíèìàëüíîé áðîíå
class ArmorThresholdDecorator : public IteratorDecorator<Tank*> {
private:
    int minArmor;

public:
    ArmorThresholdDecorator(Iterator<Tank*>* it, int armor)
        : IteratorDecorator<Tank*>(it), minArmor(armor) {}

    void First() override {
        It->First();
        SkipWeakArmor();
    }

    void Next() override {
        It->Next();
        SkipWeakArmor();
    }

private:
    void SkipWeakArmor() {
        while (!It->IsDone() && It->GetCurrent()->GetArmor() < minArmor) {
            It->Next();
        }
    }
};

// Äåêîðàòîð äëÿ ôèëüòðàöèè ïî òèïó îðóæèÿ
class WeaponTypeDecorator : public IteratorDecorator<Tank*> {
private:
    string weaponType;

public:
    WeaponTypeDecorator(Iterator<Tank*>* it, const string& weapon)
        : IteratorDecorator<Tank*>(it), weaponType(weapon) {}

    void First() override {
        It->First();
        SkipOtherWeapons();
    }

    void Next() override {
        It->Next();
        SkipOtherWeapons();
    }

private:
    void SkipOtherWeapons() {
        while (!It->IsDone() && It->GetCurrent()->GetWeapon() != weaponType) {
            It->Next();
        }
    }
};

// Àäàïòåð äëÿ STL-êîíòåéíåðîâ
template<typename ContainerType, typename ItemType>
class STLIteratorAdapter : public Iterator<ItemType> {
protected:
    ContainerType* Container;
    typename ContainerType::const_iterator It;

public:
    STLIteratorAdapter(ContainerType* container) : Container(container) {
        It = Container->begin();
    }

    virtual ~STLIteratorAdapter() {}
    virtual void First() { It = Container->begin(); }
    virtual void Next() { It++; }
    virtual bool IsDone() const { return (It == Container->end()); }
    virtual ItemType GetCurrent() const { return *It; }
};

// Ôóíêöèÿ äëÿ äåìîíñòðàöèè ðàáîòû òàíêîâ ÷åðåç èòåðàòîð
void DemonstrateTank(Iterator<Tank*>* iterator);

// Ñòðàòåãèÿ àòàêè (ïàòòåðí "Ñòðàòåãèÿ")
class IAttackStrategy {
public:
    virtual ~IAttackStrategy() {}
    virtual void Attack() const = 0;
};
class MachineGunAttack : public IAttackStrategy {
public:
    void Attack() const override {
        cout << "Àòàêà èç ïóëåìåòà!" << endl;
    }
};
class CannonAttack : public IAttackStrategy {
public:
    void Attack() const override {
        cout << "Âûñòðåë èç ïóøêè!" << endl;
    }
};
class MissileAttack : public IAttackStrategy {
public:
    void Attack() const override {
        cout << "Çàïóñê ðàêåòû!" << endl;
    }
};

// Øàáëîííûé ìåòîä (Template Method) äëÿ ìèññèé òàíêîâ
class TankMission {
public:
    virtual ~TankMission() {}
    void StartMission() {
        Prepare();
        StartEngine();
        Move();
        Attack();
        Finish();
    }

protected:
    virtual void Prepare() {
        cout << "Ïîäãîòîâêà ê ìèññèè..." << endl;
    }

    virtual void StartEngine() = 0;
    virtual void Move() = 0;
    virtual void Attack() = 0;

    virtual void Finish() {
        cout << "Ìèññèÿ çàâåðøåíà!" << endl;
    }
};

// Êîíêðåòíàÿ ìèññèÿ — ðàçâåäêà
class ScoutMission : public TankMission {
public:
    void StartEngine() override {
        cout << "Çàïóñê äâèãàòåëÿ äëÿ ðàçâåäêè." << endl;
    }
    void Move() override {
        cout << "Òàíê äâèæåòñÿ ñ ìàêñèìàëüíîé ñêîðîñòüþ." << endl;
    }
    void Attack() override {
        cout << "Ðàçâåäêà: àòàêà íå òðåáóåòñÿ." << endl;
    }
};

// Êîíêðåòíàÿ ìèññèÿ — áîé
class BattleMission : public TankMission {
public:
    void StartEngine() override {
        cout << "Áîåâîé çàïóñê äâèãàòåëÿ." << endl;
    }
    void Move() override {
        cout << "Òàíê çàíèìàåò áîåâóþ ïîçèöèþ." << endl;
    }
    void Attack() override {
        cout << "Âûïîëíÿåòñÿ àòàêà ïî ïðîòèâíèêó!" << endl;
    }
};
#endif // P5_H_INCLUDED