1 #pragma once
 2 
 3 using std::string;
 4 using std::cout;
 5 using std::endl;
 6 
 7 class MachinePets {
 8 public:
 9     MachinePets(const string& nickname0);
10 
11     string get_nickname() const;
12 
13     virtual string talk() const = 0;
14 
15 private:
16     string nickname;
17 };
18 
19 MachinePets::MachinePets(const string& nickname0) : nickname{ nickname0 } {
20 }
21 
22 string MachinePets::get_nickname() const {
23     return nickname;
24 }
25 
26 
27 class PetCats : public MachinePets {
28 public:
29     PetCats(const string& nickname0);
30 
31     string talk() const override;
32 };
33 
34 PetCats::PetCats(const string& nickname0) : MachinePets{ nickname0 } {
35 }
36 
37 string PetCats::talk() const {
38     return "Nyaa~";
39 }
40 
41 
42 class PetDogs : public MachinePets {
43 public:
44     PetDogs(const string& nickname0);
45 
46     string talk() const override;
47 };
48 
49 PetDogs::PetDogs(const string& nickname0) : MachinePets{ nickname0 } {
50 }
51 
52 string PetDogs::talk() const {
53     return "Wan~";
54 }

 1 #include <iostream>
 2 #include <vector>
 3 #include "pets.hpp"
 4 
 5 void test() {
 6     using namespace std;
 7 
 8     vector<MachinePets*> pets;
 9 
10     pets.push_back(new PetCats("miku"));
11     pets.push_back(new PetDogs("da huang"));
12 
13     for (auto& ptr : pets)
14         cout << ptr->get_nickname() << " says " << ptr->talk() << endl;
15 }
16 int main() {
17     test();
18 }

 1 #pragma once
 2 
 3 #include <iostream>
 4 #include <iomanip>
 5 
 6 using std::string;
 7 using std::istream;
 8 using std::ostream;
 9 using std::left;
10 using std::setw;
11 using std::endl;
12 using std::cout;
13 
14 class Film {
15 public:
16     Film(const string& name0 = "null", const string& director0 = "null",
17         const string& region0 = "null", const string& year0 = "null");
18 
19     friend istream& operator>>(istream& in, Film& film);
20     friend ostream& operator<<(ostream& out, const Film& film);
21 
22     string get_year() const;
23 
24 private:
25     string name, director, region, year;
26 };
27 
28 Film::Film(const string& name0, const string& director0, const string& region0, const string& year0)
29     :name{ name0 }, director{ director0 }, region{ region0 }, year{ year0 } {
30 }
31 
32 istream& operator>>(istream& in, Film& film) {
33     cout << "錄入片名: "; in >> film.name;
34     cout << "錄入導演: "; in >> film.director;
35     cout << "錄入制片國家/地區: "; in >> film.region;
36     cout << "錄入上映年份: "; in >> film.year;
37 
38     return in;
39 }
40 
41 ostream& operator<<(ostream& out, const Film& film) {
42     out << left;
43     out << setw(20) << film.name
44         << setw(20) << film.director
45         << setw(20) << film.region
46         << setw(20) << film.year << endl;
47 
48     return out;
49 }
50 
51 string Film::get_year() const {
52     return year;
53 }
54 
55 bool compare_by_year(const Film& f1, const Film& f2) {
56     return f1.get_year() < f2.get_year();
57 }

 1 #include "film.hpp"
 2 #include <iostream>
 3 #include <string>
 4 #include <vector>
 5 #include <algorithm>
 6 
 7 void test() {
 8     using namespace std;
 9 
10     int n;
11     cout << "輸入電影數目: ";
12     cin >> n;
13 
14     cout << "錄入" << n << "部影片信息" << endl;
15     vector<Film> film_lst;
16     for (int i = 0; i < n; ++i) {
17         Film f;
18         cout << string(20, '-') << "第" << i + 1 << "部影片錄入" << string(20, '-') << endl;
19         cin >> f;
20         film_lst.push_back(f);
21     }
22 
23     // 按發行年份升序排序
24     sort(film_lst.begin(), film_lst.end(), compare_by_year);
25 
26     cout << string(20, '=') + "電影信息(按發行年份)" + string(20, '=') << endl;
27     for (auto& f : film_lst)
28         cout << f << endl;
29 }
30 
31 int main() {
32     test();
33 }

 1 #pragma once
 2 
 3 #include <iostream>
 4 
 5 using std::istream;
 6 using std::ostream;
 7 using std::abs;
 8 
 9 template<typename T>
10 class Complex {
11 public:
12     Complex(const T & = T{}, const T& i = T{});
13     Complex(const Complex& c);
14 
15     T get_real() const;
16     T get_imag() const;
17 
18     Complex<T> operator+=(const Complex<T>& c);
19     bool operator==(const Complex<T>& other) const;
20 
21     template<typename U>
22     friend istream& operator>>(istream& in, Complex<U>& c);
23 
24     template<typename U>
25     friend ostream& operator<<(ostream& out, const Complex<U>& c);
26     
27     template<typename U>
28     friend Complex<U> operator+(const Complex<U>& c1, const Complex<U>& c2);
29 
30 private:
31     T real, imag;
32 };
33 
34 template<typename T>
35 Complex<T>::Complex(const T& r, const T& i) : real{ r }, imag{ i } {
36 }
37 
38 template<typename T>
39 Complex<T>::Complex(const Complex& c) : real{ c.real }, imag{ c.imag } {
40 }
41 
42 template<typename T>
43 T Complex<T>::get_real() const {
44     return real;
45 }
46 
47 template<typename T>
48 T Complex<T>::get_imag() const {
49     return imag;
50 }
51 
52 template<typename T>
53 Complex<T> Complex<T>::operator+=(const Complex<T>& c) {
54     real += c.real;
55     imag += c.imag;
56 
57     return *this;
58 }
59 
60 template<typename T>
61 bool Complex<T>::operator==(const Complex<T>& other) const {
62     return real == other.real && imag == other.imag;
63 }
64 
65 template<typename T>
66 istream& operator>>(istream& in, Complex<T>& c) {
67     in >> c.real >> c.imag;
68 
69     return in;
70 }
71 
72 template<typename T>
73 ostream& operator<<(ostream& out, const Complex<T>& c) {
74     if (c.imag >= 0)
75         out << c.real << " + " << c.imag << "i";
76     else
77         out << c.real << " - " << -c.imag << "i";
78 
79     return out;
80 }
81 
82 template<typename T>
83 Complex<T> operator+(const Complex<T>& c1, const Complex<T>& c2) {
84     return Complex<T>(c1.real + c2.real, c1.imag + c2.imag);
85 }

 1 //=======================
 2 //        player.h
 3 //=======================
 4 
 5 // The base class of player
 6 // including the general properties and methods related to a character
 7 
 8 #ifndef _PLAYER
 9 #define _PLAYER
10 
11 #include <iomanip> // use for setting field width
12 #include <time.h>  // use for generating random factor
13 #include "container.h"
14 
15 using std::string;
16 
17 enum job
18 {
19     sw,
20     ar,
21     mg
22 }; /* define 3 jobs by enumerate type
23           sword man, archer, mage */
24 class player
25 {
26     friend void showinfo(player &p1, player &p2);
27     friend class swordsman;
28 
29 protected:
30     int HP, HPmax, MP, MPmax, AP, DP, speed, EXP, LV;
31     // General properties of all characters
32     string name;   // character name
33     job role;       /* character's job, one of swordman, archer(射手) and mage(魔法使い),
34                       as defined by the enumerate type */
35     container bag; // character's inventory
36 
37 public:
38     virtual bool attack(player &p) = 0;        // normal attack
39     virtual bool specialatt(player &p) = 0; // special attack
40     virtual void isLevelUp() = 0;            // level up judgement
41     /* Attention!
42     These three methods are called "Pure virtual functions".
43     They have only declaration, but no definition.
44     The class with pure virtual functions are called "Abstract class", which can only be used to inherited, but not to constructor objects.
45     The detailed definition of these pure virtual functions will be given in subclasses. */
46 
47     void reFill();              // character's HP and MP resume
48     bool death();              // report whether character is dead
49     void isDead();              // check whether character is dead
50     bool useHeal();              // consume heal, irrelevant to job
51     bool useMW();              // consume magic water, irrelevant to job
52     void transfer(player &p); // possess opponent's items after victory
53     void showRole();          // display character's job
54 
55 private:
56     bool playerdeath; // whether character is dead, doesn't need to be accessed or inherited
57 };
58 
59 #endif

  1 //=======================
  2 //        player.cpp
  3 //=======================
  4 
  5 #include "player.h"
  6 #include <iostream>
  7 
  8 using std::cout;
  9 using std::endl;
 10 using std::setw;
 11 
 12 // character's HP and MP resume
 13 void player::reFill()
 14 {
 15     HP = HPmax; // HP and MP fully recovered
 16     MP = MPmax;
 17 }
 18 
 19 // report whether character is dead
 20 bool player::death()
 21 {
 22     return playerdeath;
 23 }
 24 
 25 // check whether character is dead
 26 void player::isDead()
 27 {
 28     if (HP <= 0) // HP less than 0, character is dead
 29     {
 30         cout << name << " is Dead." << endl;
 31         system("pause");
 32         playerdeath = 1; // give the label of death value 1
 33     }
 34 }
 35 
 36 // consume heal, irrelevant to job
 37 bool player::useHeal()
 38 {
 39     if (bag.nOfHeal() > 0)
 40     {
 41         HP = HP + 100;
 42         if (HP > HPmax) // HP cannot be larger than maximum value
 43             HP = HPmax; // so assign it to HPmax, if necessary
 44         cout << name << " used Heal, HP increased by 100." << endl;
 45         bag.useHeal(); // use heal
 46         system("pause");
 47         return 1; // usage of heal succeed
 48     }
 49     else // If no more heal in bag, cannot use
 50     {
 51         cout << "Sorry, you don't have heal to use." << endl;
 52         system("pause");
 53         return 0; // usage of heal failed
 54     }
 55 }
 56 
 57 // consume magic water, irrelevant to job
 58 bool player::useMW()
 59 {
 60     if (bag.nOfMW() > 0)
 61     {
 62         MP = MP + 100;
 63         if (MP > MPmax)
 64             MP = MPmax;
 65         cout << name << " used Magic Water, MP increased by 100." << endl;
 66         bag.useMW();
 67         system("pause");
 68         return 1; // usage of magic water succeed
 69     }
 70     else
 71     {
 72         cout << "Sorry, you don't have magic water to use." << endl;
 73         system("pause");
 74         return 0; // usage of magic water failed
 75     }
 76 }
 77 
 78 // possess opponent's items after victory
 79 void player::transfer(player &p)
 80 {
 81     cout << name << " got" << p.bag.nOfHeal() << " Heal, and " << p.bag.nOfMW() << " Magic Water." << endl;
 82     system("pause");
 83     // set the character's bag, get opponent's items
 84     HP += p.bag.nOfHeal();
 85     MP += p.bag.nOfMW();
 86 
 87     
 88 }
 89 
 90 // display character's job
 91 void player::showRole()
 92 {
 93     switch (role)
 94     {
 95     case sw:
 96         cout << "Swordsman";
 97         break;
 98     case ar:
 99         cout << "Archer";
100         break;
101     case mg:
102         cout << "Mage";
103         break;
104     default:
105         break;
106     }
107 }
108 
109 // display character's job
110 void showinfo(player &p1, player &p2)
111 {
112     system("cls");
113     cout << "##############################################################" << endl;
114     cout << "# Player" << setw(10) << p1.name << "   LV. " << setw(3) << p1.LV
115          << "  # Opponent" << setw(10) << p2.name << "   LV. " << setw(3) << p2.LV << " #" << endl;
116     cout << "# HP " << setw(3) << (p1.HP <= 999 ? p1.HP : 999) << '/' << setw(3) << (p1.HPmax <= 999 ? p1.HPmax : 999)
117          << " | MP " << setw(3) << (p1.MP <= 999 ? p1.MP : 999) << '/' << setw(3) << (p1.MPmax <= 999 ? p1.MPmax : 999)
118          << "     # HP " << setw(3) << (p2.HP <= 999 ? p2.HP : 999) << '/' << setw(3) << (p2.HPmax <= 999 ? p2.HPmax : 999)
119          << " | MP " << setw(3) << (p2.MP <= 999 ? p2.MP : 999) << '/' << setw(3) << (p2.MPmax <= 999 ? p2.MPmax : 999) << "      #" << endl;
120     cout << "# AP " << setw(3) << (p1.AP <= 999 ? p1.AP : 999)
121          << " | DP " << setw(3) << (p1.DP <= 999 ? p1.DP : 999)
122          << " | speed " << setw(3) << (p1.speed <= 999 ? p1.speed : 999)
123          << " # AP " << setw(3) << (p2.AP <= 999 ? p2.AP : 999)
124          << " | DP " << setw(3) << (p2.DP <= 999 ? p2.DP : 999)
125          << " | speed " << setw(3) << (p2.speed <= 999 ? p2.speed : 999) << "  #" << endl;
126     cout << "# EXP" << setw(7) << p1.EXP << " Job: " << setw(7);
127     p1.showRole();
128     cout << "   # EXP" << setw(7) << p2.EXP << " Job: " << setw(7);
129     p2.showRole();
130     cout << "    #" << endl;
131     cout << "--------------------------------------------------------------" << endl;
132     p1.bag.display();
133     cout << "##############################################################" << endl;
134 }

 1 //=======================
 2 //        container.h
 3 //=======================
 4 
 5 // The so-called inventory(在庫) of a player in RPG games
 6 // contains two items, heal and magic water
 7 
 8 #ifndef _CONTAINER// Conditional compilation(編集)
 9 #define _CONTAINER
10 
11 class container // Inventory
12 {
13 protected:
14     int numOfHeal; // number of heal
15     int numOfMW;   // number of magic water
16 public:
17     container();                    // constuctor
18     void set(int heal_n, int mw_n); // set the items numbers
19     int nOfHeal();                    // get the number of heal
20     int nOfMW();                    // get the number of magic water
21     void display();                    // display the items;
22     bool useHeal();                    // use heal
23     bool useMW();                    // use magic water
24 };
25 
26 #endif

 1 //=======================
 2 //        container.cpp
 3 //=======================
 4 
 5 // default constructor initialise the inventory as empty
 6 
 7 #include "container.h"
 8 #include <iostream>
 9 
10 using std::cout;
11 using std::endl;
12 
13 container::container()
14 {
15     set(0, 0);
16 }
17 
18 // set the item numbers
19 void container::set(int heal_n, int mw_n)
20 {
21     numOfHeal = heal_n;
22     numOfMW = mw_n;
23 }
24 
25 // get the number of heal
26 int container::nOfHeal()
27 {
28     return numOfHeal;
29 }
30 
31 // get the number of magic water
32 int container::nOfMW()
33 {
34     return numOfMW;
35 }
36 
37 // display the items;
38 void container::display()
39 {
40     cout << "Your bag contains: " << endl;
41     cout << "Heal(HP+100): " << numOfHeal << endl;
42     cout << "Magic Water (MP+80): " << numOfMW << endl;
43 }
44 
45 // use heal
46 bool container::useHeal()
47 {
48     numOfHeal--;
49     return 1; // use heal successfully
50 }
51 
52 // use magic water
53 bool container::useMW()
54 {
55     numOfMW--;
56     return 1; // use magic water successfully
57 }

 1 //=======================
 2 //        swordsman.h
 3 //=======================
 4 
 5 // Derived from base class player
 6 // For the job Swordsman
 7 
 8 #include "player.h"
 9 class swordsman :public player // subclass swordsman publicly inherited from base player
10 {
11 public:
12     swordsman(int lv_in = 1, string name_in = "Not Given");
13     // constructor with default level of 1 and name of "Not given"
14     void isLevelUp();
15     bool attack(player& p);
16     bool specialatt(player& p);
17     /* These three are derived from the pure virtual functions of base class
18        The definition of them will be given in this subclass. */
19     void AI(player& p); // Computer opponent
20 };

  1 //=======================
  2 //        swordsman.cpp
  3 //=======================
  4 
  5 #include "swordsman.h"
  6 #include <iostream>
  7 
  8 using std::cout;
  9 using std::endl;
 10 
 11 // constructor. default values don't need to be repeated here
 12 swordsman::swordsman(int lv_in, string name_in)
 13 {
 14     role = sw; // enumerate type of job
 15     LV = lv_in;
 16     name = name_in;
 17 
 18     // Initialising the character's properties, based on his level
 19     HPmax = 150 + 8 * (LV - 1); // HP increases 8 point2 per level
 20     HP = HPmax;
 21     MPmax = 75 + 2 * (LV - 1); // MP increases 2 points per level
 22     MP = MPmax;
 23     AP = 25 + 4 * (LV - 1);       // AP increases 4 points per level
 24     DP = 25 + 4 * (LV - 1);       // DP increases 4 points per level
 25     speed = 25 + 2 * (LV - 1); // speed increases 2 points per level
 26 
 27     playerdeath = 0;
 28     EXP = LV * LV * 75;
 29     bag.set(lv_in, lv_in);
 30 }
 31 
 32 void swordsman::isLevelUp()
 33 {
 34     if (EXP >= LV * LV * 75)
 35     {
 36         LV++;
 37         AP += 4;
 38         DP += 4;
 39         HPmax += 8;
 40         MPmax += 2;
 41         speed += 2;
 42         cout << name << " Level UP!" << endl;
 43         cout << "HP improved 8 points to " << HPmax << endl;
 44         cout << "MP improved 2 points to " << MPmax << endl;
 45         cout << "Speed improved 2 points to " << speed << endl;
 46         cout << "AP improved 4 points to " << AP << endl;
 47         cout << "DP improved 5 points to " << DP << endl;
 48         system("pause");
 49         isLevelUp(); // recursively call this function, so the character can level up multiple times if got enough exp
 50     }
 51 }
 52 
 53 bool swordsman::attack(player &p)
 54 {
 55     double HPtemp = 0;             // opponent's HP decrement
 56     double EXPtemp = 0;             // player obtained exp
 57     double hit = 1;                 // attach factor, probably give critical attack
 58     srand((unsigned)time(NULL)); // generating random seed based on system time
 59 
 60     // If speed greater than opponent, you have some possibility to do double attack
 61     if ((speed > p.speed) && (rand() % 100 < (speed - p.speed))) // rand()%100 means generates a number no greater than 100
 62     {
 63         HPtemp = (int)((1.0 * AP / p.DP) * AP * 5 / (rand() % 4 + 10)); // opponent's HP decrement calculated based their AP/DP, and uncertain chance
 64         cout << name << "'s quick strike hit " << p.name << ", " << p.name << "'s HP decreased " << HPtemp << endl;
 65         p.HP = int(p.HP - HPtemp);
 66         EXPtemp = (int)(HPtemp * 1.2);
 67     }
 68 
 69     // If speed smaller than opponent, the opponent has possibility to evade
 70     if ((speed < p.speed) && (rand() % 50 < 1))
 71     {
 72         cout << name << "'s attack has been evaded by " << p.name << endl;
 73         system("pause");
 74         return 1;
 75     }
 76 
 77     // 10% chance give critical attack
 78     if (rand() % 100 <= 10)
 79     {
 80         hit = 1.5;
 81         cout << "Critical attack: ";
 82     }
 83 
 84     // Normal attack
 85     HPtemp = (int)((1.0 * AP / p.DP) * AP * 5 / (rand() % 4 + 10));
 86     cout << name << " uses bash, " << p.name << "'s HP decreases " << HPtemp << endl;
 87     EXPtemp = (int)(EXPtemp + HPtemp * 1.2);
 88     p.HP = (int)(p.HP - HPtemp);
 89     cout << name << " obtained " << EXPtemp << " experience." << endl;
 90     EXP = (int)(EXP + EXPtemp);
 91     system("pause");
 92     return 1; // Attack success
 93 }
 94 
 95 bool swordsman::specialatt(player &p)
 96 {
 97     if (MP < 40)
 98     {
 99         cout << "You don't have enough magic points!" << endl;
100         system("pause");
101         return 0; // Attack failed
102     }
103     else
104     {
105         MP -= 40; // consume 40 MP to do special attack
106 
107         // 10% chance opponent evades
108         if (rand() % 100 <= 10)
109         {
110             cout << name << "'s leap attack has been evaded by " << p.name << endl;
111             system("pause");
112             return 1;
113         }
114 
115         double HPtemp = 0;
116         double EXPtemp = 0;
117         // double hit=1;
118         // srand(time(NULL));
119         HPtemp = (int)(AP * 1.2 + 20); // not related to opponent's DP
120         EXPtemp = (int)(HPtemp * 1.5); // special attack provides more experience
121         cout << name << " uses leap attack, " << p.name << "'s HP decreases " << HPtemp << endl;
122         cout << name << " obtained " << EXPtemp << " experience." << endl;
123         p.HP = (int)(p.HP - HPtemp);
124         EXP = (int)(EXP + EXPtemp);
125         system("pause");
126     }
127     return 1; // special attack succeed
128 }
129 
130 // Computer opponent
131 void swordsman::AI(player &p)
132 {
133     if ((HP < (int)((1.0 * p.AP / DP) * p.AP * 1.5)) && (HP + 100 <= 1.1 * HPmax) && (bag.nOfHeal() > 0) && (HP > (int)((1.0 * p.AP / DP) * p.AP * 0.5)))
134     // AI's HP cannot sustain 3 rounds && not too lavish && still has heal && won't be killed in next round
135     {
136         useHeal();
137     }
138     else
139     {
140         if (MP >= 40 && HP > 0.5 * HPmax && rand() % 100 <= 30)
141         // AI has enough MP, it has 30% to make special attack
142         {
143             specialatt(p);
144             p.isDead(); // check whether player is dead
145         }
146         else
147         {
148             if (MP < 40 && HP > 0.5 * HPmax && bag.nOfMW())
149             // Not enough MP && HP is safe && still has magic water
150             {
151                 useMW();
152             }
153             else
154             {
155                 attack(p); // normal attack
156                 p.isDead();
157             }
158         }
159     }
160 }

  1 //=======================
  2 //        main.cpp
  3 //=======================
  4 
  5 // main function for the RPG style game
  6 
  7 #include <iostream>
  8 #include <string>
  9 using namespace std;
 10 
 11 #include "swordsman.h"
 12 
 13 int main()
 14 {
 15     string tempName;
 16     bool success = 0; // flag for storing whether operation is successful
 17 
 18     cout << "Please input player's name: ";
 19     cin >> tempName; // get player's name from keyboard input
 20 
 21     player* human;     // use pointer of base class, convenience for polymorphism
 22     int tempJob;     // temp choice for job selection
 23 
 24     do
 25     {
 26         cout << "Please choose a job: 1 Swordsman, 2 Archer, 3 Mage" << endl;
 27         cin >> tempJob;
 28         system("cls"); // clear the screen
 29 
 30         switch (tempJob)
 31         {
 32         case 1:
 33             human = new swordsman(1, tempName); // create the character with user inputted name and job
 34             success = 1;                        // operation succeed
 35             break;
 36 
 37         default:
 38             break; // In this case, success=0, character creation failed
 39         }
 40     } while (success != 1); // so the loop will ask user to re-create a character
 41 
 42     int tempCom;                      // temp command inputted by user
 43     int nOpp = 0;                      // the Nth opponent
 44     for (int i = 1; nOpp < 5; i += 2) // i is opponent's level
 45     {
 46         nOpp++;
 47         system("cls");
 48 
 49         cout << "STAGE" << nOpp << endl;
 50         cout << "Your opponent, a Level " << i << " Swordsman." << endl;
 51         system("pause");
 52 
 53         swordsman enemy(i, "Warrior"); // Initialise an opponent, level i, name "Junior"
 54         human->reFill();               // get HP/MP refill before start fight
 55 
 56         while (!human->death() && !enemy.death()) // no died
 57         {
 58             success = 0;
 59             while (success != 1)
 60             {
 61                 showinfo(*human, enemy); // show fighter's information
 62                 cout << "Please give command: " << endl;
 63                 cout << "1 Attack; 2 Special Attack; 3 Use Heal; 4 Use Magic Water; 0 Exit Game" << endl;
 64                 cin >> tempCom;
 65 
 66                 switch (tempCom)
 67                 {
 68                 case 0:
 69                     cout << "Are you sure to exit? Y/N" << endl;
 70                     char temp;
 71                     cin >> temp;
 72 
 73                     if (temp == 'Y' || temp == 'y')
 74                         return 0;
 75                     else
 76                         break;
 77 
 78                 case 1:
 79                     success = human->attack(enemy);
 80                     human->isLevelUp();
 81                     enemy.isDead();
 82                     break;
 83 
 84                 case 2:
 85                     success = human->specialatt(enemy);
 86                     human->isLevelUp();
 87                     enemy.isDead();
 88                     break;
 89 
 90                 case 3:
 91                     success = human->useHeal();
 92                     break;
 93 
 94                 case 4:
 95                     success = human->useMW();
 96                     break;
 97 
 98                 default:
 99                     break;
100                 }
101             }
102 
103             if (!enemy.death()) // If AI still alive
104                 enemy.AI(*human);
105             else // AI died
106             {
107                 cout << "YOU WIN" << endl;
108                 human->transfer(enemy); // player got all AI's items
109             }
110 
111             if (human->death())
112             {
113                 system("cls");
114                 cout << endl
115                     << setw(50) << "GAME OVER" << endl;
116                 delete human;// player is dead, program is getting to its end, what should we do here?
117                 system("pause");
118                 return 0;
119             }
120         }
121     }
122     delete human;// You win, program is getting to its end, what should we do here?
123     system("cls");
124     cout << "Congratulations! You defeated all opponents!!" << endl;
125     system("pause");
126     return 0;
127 }