main.cpp

#include "P5.h"
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

// Ðåàëèçàöèÿ ìåòîäîâ Tank
Tank::Tank(int armor, double speed, string weapon)
    : armor(armor), speed(speed), weapon(weapon), isOperational(true) {}

Tank::~Tank() {}

// Ðåàëèçàöèÿ LightTank
LightTank::LightTank() : Tank(50, 60.0, "Ïóëåìåò") {
    cout << "Ñîçäàíèå ëåãêîãî òàíêà.." << endl;
}

LightTank::~LightTank() {
    cout << "Óäàëåíèå ëåãêîãî òàíêà..." << endl;
}

void LightTank::StartEngine() {
    cout << "Äâèãàòåëü ëåãêîãî òàíêà çàïóùåí." << endl;
}

void LightTank::Move() {
    cout << "Ëåãêèé òàíê äâèæåòñÿ áûñòðî." << endl;
}

void LightTank::Attack() {
    cout << "Ëåãêèé òàíê àòàêóåò ïóëåìåòàìè!" << endl;
}

// Ðåàëèçàöèÿ MediumTank
MediumTank::MediumTank() : Tank(100, 40.0, "Ñðåäíÿÿ ïóøêà") {
    cout << "Ñîçäàíèå ñðåäíåãî òàíêà..." << endl;
}

MediumTank::~MediumTank() {
    cout << "Óäàëåíèå ñðåäíåãî òàíêà..." << endl;
}

void MediumTank::StartEngine() {
    cout << "Äâèãàòåëü ñðåäíåãî òàíêà çàïóùåí." << endl;
}

void MediumTank::Move() {
    cout << "Ñðåäíèé òàíê äâèæåòñÿ ñ óìåðåííîé ñêîðîñòüþ." << endl;
}

void MediumTank::Attack() {
    cout << "Ñðåäíèé òàíê àòàêóåò ñðåäíèì îðóäèåì." << endl;
}

// Ðåàëèçàöèÿ HeavyTank
HeavyTank::HeavyTank() : Tank(150, 20.0, "Äëèííîñòâîëüíàÿ ïóøêà") {
    cout << "Ñîçäàíèå òÿæåëîãî òàíêà..." << endl;
}

HeavyTank::~HeavyTank() {
    cout << "Óäàëåíèå òÿæåëîãî òàíêà..." << endl;
}

void HeavyTank::StartEngine() {
    cout << "Äâèãàòåëü òÿæåëîãî òàíêà çàïóùåí." << endl;
}

void HeavyTank::Move() {
    cout << "Òÿæåëûé òàíê äâèæåòñÿ ìåäëåííî, íî óâåðåííî." << endl;
}

void HeavyTank::Attack() {
    cout << "Òÿæåëûé òàíê àòàêóåò ìîùíûì îðóäèåì!" << endl;
}

// Ðåàëèçàöèÿ ôàáðèêè òàíêîâ
Tank* CreateTank(TankType type) {
    switch(type) {
        case TankType::Light: return new LightTank();
        case TankType::Medium: return new MediumTank();
        case TankType::Heavy: return new HeavyTank();
        default: return nullptr;
    }
}

// Ðåàëèçàöèÿ ìåòîäîâ TankArray
template<typename T, size_t N>
TankArray<T, N>::TankArray() : size(0) {}

template<typename T, size_t N>
void TankArray<T, N>::Add(T* item) {
    if (size < N) {
        items[size++] = item;
    }
}

template<typename T, size_t N>
T* TankArray<T, N>::Get(size_t index) const {
    return (index < size) ? items[index] : nullptr;
}

template<typename T, size_t N>
size_t TankArray<T, N>::Size() const { return size; }

// Ðåàëèçàöèÿ èòåðàòîðà äëÿ TankArray
template<typename T, size_t N>
class TankArray<T, N>::ArrayIterator : public Iterator<T*> {
    const TankArray<T, N>* array;
    size_t current;

public:
    ArrayIterator(const TankArray<T, N>* arr) : array(arr), current(0) {}

    void First() override { current = 0; }
    void Next() override { current++; }
    bool IsDone() const override { return current >= array->Size(); }
    T* GetCurrent() const override { return array->Get(current); }
};

template<typename T, size_t N>
Iterator<T*>* TankArray<T, N>::GetIterator() const {
    return new ArrayIterator(this);
}

// Ðåàëèçàöèÿ ìåòîäîâ TankList
template<typename T>
void TankList<T>::Add(T* item) {
    items.push_back(item);
}

template<typename T>
size_t TankList<T>::Size() const { return items.size(); }

// Ðåàëèçàöèÿ èòåðàòîðà äëÿ TankList
template<typename T>
class TankList<T>::ListIterator : public Iterator<T*> {
    typename list<T*>::const_iterator it;
    const list<T*>* lst;

public:
    ListIterator(const list<T*>* l) : lst(l), it(l->begin()) {}

    void First() override { it = lst->begin(); }
    void Next() override { it++; }
    bool IsDone() const override { return it == lst->end(); }
    T* GetCurrent() const override { return *it; }
};

template<typename T>
Iterator<T*>* TankList<T>::GetIterator() const {
    return new ListIterator(&items);
}

// Ôóíêöèÿ äåìîíñòðàöèè ðàáîòû òàíêîâ ÷åðåç èòåðàòîð
void DemonstrateTank(Iterator<Tank*>* iterator) {
    for (iterator->First(); !iterator->IsDone(); iterator->Next()) {
        Tank* tank = iterator->GetCurrent();
        cout << "--------------------------------" << endl;
        cout << "Òèï îðóæèÿ: " << tank->GetWeapon() << endl;
        cout << "Óðîâåíü áðîíè: " << tank->GetArmor() << endl;
        tank->StartEngine();
        tank->Move();
        tank->Attack();
    }
    cout << "--------------------------------" << endl;
}

int main() {
    setlocale(LC_ALL, "Russian");
    srand(time(0));

    // Ñîçäàåì ìàññèâ è ñïèñîê òàíêîâ
    TankArray<Tank> tankArray;
    TankList<Tank> tankList;

    TankType types[] = {TankType::Light, TankType::Medium, TankType::Heavy};

    // Çàïîëíÿåì êîíòåéíåðû ñëó÷àéíûìè òàíêàìè
    cout << "Ñîçäàåì òàíêè äëÿ ìàññèâà:" << endl;
    for (int i = 0; i < 10; i++) {
        TankType randomType = types[rand() % 3];
        Tank* tank = CreateTank(randomType);
        tankArray.Add(tank);
    }
    cout << endl;

    cout << "Ñîçäàåì òàíêè äëÿ ñïèñêà:" << endl;
    for (int i = 0; i < 10; i++) {
        TankType randomType = types[rand() % 3];
        Tank* tank = CreateTank(randomType);
        tankList.Add(tank);
    }

    // Äåìîíñòðàöèÿ áàçîâûõ èòåðàòîðîâ
    cout << "\nÄåìîíñòðàöèÿ ìàññèâà òàíêîâ:" << endl;
    Iterator<Tank*>* arrayIter = tankArray.GetIterator();
    DemonstrateTank(arrayIter);
    delete arrayIter;

    cout << "\nÄåìîíñòðàöèÿ ñïèñêà òàíêîâ:" << endl;
    Iterator<Tank*>* listIter = tankList.GetIterator();
    DemonstrateTank(listIter);
    delete listIter;

    // Äåìîíñòðàöèÿ äåêîðàòîðîâ
    cout << "\nÄåìîíñòðàöèÿ òîëüêî èñïðàâíûõ òàíêîâ:" << endl;
    Iterator<Tank*>* operationalIter = new OperationalTankDecorator(tankArray.GetIterator());
    DemonstrateTank(operationalIter);
    delete operationalIter;

    cout << "\nÄåìîíñòðàöèÿ òàíêîâ ñ áðîíåé >= 100:" << endl;
    Iterator<Tank*>* armorIter = new ArmorThresholdDecorator(tankArray.GetIterator(), 100);
    DemonstrateTank(armorIter);
    delete armorIter;

    cout << "\nÄåìîíñòðàöèÿ òàíêîâ ñ äëèííîñòâîëüíîé ïóøêîé:" << endl;
    Iterator<Tank*>* weaponIter = new WeaponTypeDecorator(tankList.GetIterator(), "Äëèííîñòâîëüíàÿ ïóøêà");
    DemonstrateTank(weaponIter);
    delete weaponIter;

    // Äåìîíñòðàöèÿ STL àäàïòåðà
    list<Tank*> tankSTLList;
    cout << "\nÑîçäàåì òàíêè äëÿ STL ñïèñêà:" << endl;
    for (int i = 0; i < 5; i++) {
        TankType randomType = types[rand() % 3];
        Tank* tank = CreateTank(randomType);
        tankSTLList.push_back(tank);
    }

    cout << "\nÄåìîíñòðàöèÿ STL àäàïòåðà äëÿ ñïèñêà:" << endl;
    Iterator<Tank*>* stlAdapter = new STLIteratorAdapter<list<Tank*>, Tank*>(&tankSTLList);
    DemonstrateTank(stlAdapter);
    delete stlAdapter;

    // Êîìáèíèðîâàííûé äåêîðàòîð (èñïðàâíûå òàíêè ñ áðîíåé >= 100)
    cout << "\nÄåìîíñòðàöèÿ êîìáèíèðîâàííîãî äåêîðàòîðà (èñïðàâíûå ñ áðîíåé >= 100):" << endl;
    Iterator<Tank*>* combinedIter = new OperationalTankDecorator(
        new ArmorThresholdDecorator(tankArray.GetIterator(), 100));
    DemonstrateTank(combinedIter);
    delete combinedIter;

    cout << "\n=== Äåìîíñòðàöèÿ ïàòòåðíà 'Ñòðàòåãèÿ' ===" << endl;
    Tank* customTank = new LightTank();
    IAttackStrategy* strategy1 = new MachineGunAttack();
    IAttackStrategy* strategy2 = new MissileAttack();

    cout << "Òàíê àòàêóåò ñ ïåðâîé ñòðàòåãèåé:" << endl;
    strategy1->Attack();

    cout << "Òàíê àòàêóåò ñî âòîðîé ñòðàòåãèåé:" << endl;
    strategy2->Attack();

    delete strategy1;
    delete strategy2;
    delete customTank;

    cout << "\n=== Äåìîíñòðàöèÿ ïàòòåðíà 'Øàáëîííûé ìåòîä' ===" << endl;
    TankMission* mission1 = new ScoutMission();
    TankMission* mission2 = new BattleMission();

    cout << "\nÌèññèÿ ðàçâåäêè:" << endl;
    mission1->StartMission();

    cout << "\nÁîåâàÿ ìèññèÿ:" << endl;
    mission2->StartMission();

    delete mission1;
    delete mission2;

    return 0;
}