Rodex_

Fightclub

May 8th, 2017
364
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.89 KB | None | 0 0
  1. ~~~~~~~~~~~~~~
  2. **./main.cpp**
  3.  
  4. ~~~~~~~~~~~~~~ { .c }
  5. #include <iostream>
  6. #include <vector>
  7. #include <time.h>
  8. #include "Fighters.h"
  9. #include "mage.h"
  10. #include "ninja.h"
  11. #include "warrior.h"
  12. #include "alien.h"
  13. #include "FightClup.h"
  14.  
  15.  
  16. using namespace std;
  17.  
  18. int main()
  19. {
  20.     vector < Fighters * > Fightclub;
  21.     string fighter1, fighter2;
  22.     bool   exit = false;
  23.  
  24.     cout <<
  25.     "-----------------------------------------------------------------------------------------"
  26.          << endl;
  27.     cout <<
  28.     "----------------------------------- WELCOME TO ------------------------------------------"
  29.          << endl;
  30.     cout <<
  31.     "--------------------------------- THE  FIGHTCLUB ----------------------------------------"
  32.          << endl;
  33.     cout <<
  34.     "-----------------------------------------------------------------------------------------"
  35.          << endl;
  36.  
  37.     while (!exit)
  38.     {
  39.         int menu = 0;
  40.         cout << "Waaas wiillst du tuun?!" << endl;
  41.         cout << "1 = Neuen Kaempfer anlegen!" << endl <<
  42.         "2 = Zwei Kaempfer in den Ring schicken!" << endl <<
  43.             "3 = Kaempfer anzeigen lassen!" << endl <<
  44.         "4 = Einen Kaempfer loeschen!" << endl <<
  45.             "5 = Last Man Standing " << endl << "Beliebige Nummer = EXIT!" <<
  46.         endl;
  47.         cin >> menu;
  48.  
  49.         switch (menu)
  50.         {
  51.         case 1:
  52.            {
  53.                string nickname;
  54.                int    type;
  55.                cout << "Welchen Typ Fighter wollen sie auswaehlen?" << endl <<
  56.                 "1 = Krieger"
  57.                     << endl << "2 = Magier" << endl << "3 = Ninja" << endl <<
  58.                 "4 = Alien" << endl;
  59.                cin >> type;
  60.                cout << "Waehlen Sie einen Nicknamen fuer Ihren Kaempfer!" <<
  61.                 endl;
  62.                cin >> nickname;
  63.  
  64.                ///speicher f__r neuen Fighter wird reserviert
  65.                switch (type)
  66.                {
  67.                case 1:
  68.                   {
  69.                       Fightclub.push_back(new warrior(nickname));
  70.                       break;
  71.                   }
  72.  
  73.                case 2:
  74.                   {
  75.                       Fightclub.push_back(new mage(nickname));
  76.                       break;
  77.                   }
  78.  
  79.                case 3:
  80.                   {
  81.                       Fightclub.push_back(new ninja(nickname));
  82.                       break;
  83.                   }
  84.  
  85.                case 4:
  86.                   {
  87.                       Fightclub.push_back(new alien(nickname));
  88.                       break;
  89.                   }
  90.  
  91.                default:
  92.                   {
  93.                       cout << "Falsche Eingabe! wtf! Kaunst ned zoehn!?" <<
  94.                         endl;
  95.                       break;
  96.                   }
  97.                }
  98.                break;
  99.            }
  100.  
  101.         case 2:
  102.            {
  103.                Fighters *Fighter1;
  104.                Fighters *Fighter2;
  105.                int      index_Fighter1, index_Fighter2;
  106.                int      check_win;
  107.                check_win = 0;
  108.                cout << "Welchen Kaempfer willst du in den Ring schicken?!" <<
  109.                 endl;
  110.                cin >> fighter1;
  111.                cout << "Wer soll gegen den gewaehlten Kaempfer antreten?!" <<
  112.                 endl;
  113.                cin >> fighter2;
  114.  
  115.                ///suche nach eingegebenen K__mpfern und den Index in einen int gespeichert
  116.                index_Fighter1 = findFighter(fighter1, Fightclub);
  117.                index_Fighter2 = findFighter(fighter2, Fightclub);
  118.  
  119.                ///Hole mir die richtigen Instanzen in eine Variable
  120.                Fighter1 = Fightclub[index_Fighter1];
  121.                Fighter2 = Fightclub[index_Fighter2];
  122.  
  123.                ///solange der Kampf nicht vor__ber ist und einer der K__mpfer 0 Lebenspunkte hat, wird die Schleife
  124.                ///fortgesetzt
  125.                while (check_win == 0)
  126.                {
  127.                    check_win = fight(Fighter1, Fighter2);
  128.                }
  129.                ///Speicher vom Verlierer wird freigegeben und der Fighter wird aus den Vektor gel__scht beziehungsweise
  130.                ///eine Gewinnmeldung wird ausgegeben
  131.                if (check_win == 1)
  132.                {
  133.                    delete Fighter2;
  134.                    Fightclub.erase(Fightclub.begin() + (index_Fighter2));
  135.                    cout << fighter1 << " gewinnt gegen " << fighter2 << "!! " <<
  136.                     endl << endl;
  137.                }
  138.                else if (check_win == 2)
  139.                {
  140.                    delete Fighter1;
  141.                    Fightclub.erase(Fightclub.begin() + (index_Fighter1));
  142.                    cout << fighter2 << " gewinnt gegen " << fighter1 << "!! " <<
  143.                     endl << endl;
  144.                }
  145.                break;
  146.            }
  147.  
  148.         case 3:
  149.            {
  150.                int    lifepoints, offensePoints, defensePoints;
  151.                string nickname;
  152.  
  153.                ///Mein Vektor wird durchgegangen und alle gespeicherten K__mpfer werden in einer Liste ausgegegeben
  154.                for (unsigned int i = 0; i < Fightclub.size(); ++i)
  155.                {
  156.                    nickname      = Fightclub[i]->getNickname();
  157.                    lifepoints    = Fightclub[i]->getLifePoints();
  158.                    offensePoints = Fightclub[i]->getOffensePoints();
  159.                    defensePoints = Fightclub[i]->getDefensePoints();
  160.  
  161.                    cout << nickname << " ist registriert und verfuegt ueber " <<
  162.                     lifepoints << " Lebenspunkte, "
  163.                         << offensePoints << " Angriffspunkte und " <<
  164.                     defensePoints << " Verteidigungspunkte" << endl;
  165.                }
  166.                cout << endl;
  167.                break;
  168.            }
  169.  
  170.         case 4:
  171.            {
  172.                ///Fighter soll gel__scht werden.
  173.                string nickname;
  174.                int    index_Fighter_for_delete;
  175.  
  176.                cout <<
  177.                 "Welcher Krieger soll aus den Fightclub entfernt werden?!" <<
  178.                 endl;
  179.                cin >> nickname;
  180.  
  181.                index_Fighter_for_delete = findFighter(nickname, Fightclub);
  182.  
  183.                if (index_Fighter_for_delete >= 0)
  184.                {
  185.                    delete Fightclub[index_Fighter_for_delete];
  186.                    Fightclub.erase(
  187.                        Fightclub.begin() + (index_Fighter_for_delete));
  188.                }
  189.                break;
  190.            }
  191.  
  192.         case 5:
  193.            {
  194.                int      random_index_Fighter1, random_index_Fighter2;
  195.                int      count_fighters = 2;
  196.                int      check_win      = 0;
  197.                bool     lastManStanding;
  198.                Fighters *Fighter1;
  199.                Fighters *Fighter2;
  200.                string   winner, Fighter1_tmp, Fighter2_tmp;
  201.                lastManStanding = false;
  202.  
  203.                ///Solange bool f__r einen LastManStanding nicht gesetzt is soll immer weiter gek__mpft werden.
  204.                while (!lastManStanding)
  205.                {
  206.                    ///Ich hole mir random Indizes f__r die zuf__llig aufeinandertreffende Gegner
  207.                    random_index_Fighter1 = rand() % Fightclub.size();
  208.                    random_index_Fighter2 = rand() % Fightclub.size();
  209.  
  210.                    ///Hole mir die Nicknamen der aufeinandertreffenden Gegner f__r die Siegesmeldung und Kampfverlauf
  211.                    Fighter1_tmp =
  212.                        Fightclub[random_index_Fighter1]->getNickname();
  213.                    Fighter2_tmp =
  214.                        Fightclub[random_index_Fighter2]->getNickname();
  215.  
  216.                    ///Speichere meine K__mpfer f__r den Kampf ab
  217.                    Fighter1 = Fightclub[random_index_Fighter1];
  218.                    Fighter2 = Fightclub[random_index_Fighter2];
  219.  
  220.                    ///Solange mehr als 1 K__mpfer im Vektor ist, soll weitergek__mpft werden
  221.                    if (count_fighters > 1)
  222.                    {
  223.                        ///__berpr__fe ob die K__mpfer gleich sind und ob die K__mpfer aufh nicht schon besiegt wurden.
  224.                        if ((random_index_Fighter1 != random_index_Fighter2) &&
  225.                            (Fightclub[random_index_Fighter1] != NULL) &&
  226.                            (Fightclub[random_index_Fighter2] != NULL))
  227.                        {
  228.                            while (check_win == 0)
  229.                            {
  230.                                check_win = fight(Fighter1, Fighter2);
  231.                            }
  232.                            if (check_win == 1)
  233.                            {
  234.                                delete Fighter2;
  235.                                Fightclub.erase(Fightclub.begin() +
  236.                                                (random_index_Fighter2));
  237.                                cout << Fighter1_tmp << " gewinnt gegen " <<
  238.                                 Fighter2_tmp << "!! " << endl << endl;
  239.                            }
  240.                            else if (check_win == 2)
  241.                            {
  242.                                delete Fighter1;
  243.                                Fightclub.erase(Fightclub.begin() +
  244.                                                (random_index_Fighter1));
  245.                                cout << Fighter2_tmp << " gewinnt gegen " <<
  246.                                 Fighter1_tmp << "!! " << endl << endl;
  247.                            }
  248.                            check_win = 0;
  249.                        }
  250.                        ///__berpr__fe wieviel Eintr__ge in der Liste der K__mpfer noch eingetragen sind.
  251.                        count_fighters = 0;
  252.                        for (unsigned int i = 0; i < Fightclub.size(); ++i)
  253.                        {
  254.                            if (Fightclub[i] != NULL)
  255.                            {
  256.                                count_fighters++;
  257.                            }
  258.                        }
  259.                    }
  260.                    else
  261.                    {
  262.                        lastManStanding = true;
  263.                    }
  264.                }
  265.  
  266.                for (unsigned int j = 0; j < Fightclub.size(); ++j)
  267.                {
  268.                    if (Fightclub[j] != NULL)
  269.                    {
  270.                        winner = Fightclub[j]->getNickname();
  271.                    }
  272.                }
  273.  
  274.                cout << endl << winner <<
  275.                 " ist unser Gewinner im Last-Man-Standing Kampf!!!" << endl;
  276.  
  277.                break;
  278.            }
  279.  
  280.         default:
  281.             exit = true;
  282.         }
  283.     }
  284.  
  285.     ///Gebe den gesamten restlichen Speicher frei
  286.     for (unsigned int k = 0; k < Fightclub.size(); ++k)
  287.     {
  288.         delete Fightclub.at(k);
  289.     }
  290.     return EXIT_SUCCESS;
  291. }
  292.  
  293. ~~~~~~~~~~~~~~
  294. **./FightClup.h**
  295.  
  296. ~~~~~~~~~~~~~~ { .c }
  297. //
  298. // Created by Alexander Dietrich on 07.05.2017.
  299. //
  300.  
  301. #ifndef FIGHT_CLUB_FIGHTCLUP_H
  302. #define FIGHT_CLUB_FIGHTCLUP_H
  303. #include <iostream>
  304. #include <vector>
  305. #include <cstring>
  306. #include "FightClup.h"
  307. #include "Fighters.h"
  308.  
  309.  
  310. using namespace std;
  311.  
  312. int findFighter(string nickname, vector < Fighters * > FightClub);
  313.  
  314.  
  315. int fight(Fighters *fighter1, Fighters *fighter2);
  316. #endif //FIGHT_CLUB_FIGHTCLUP_H
  317.  
  318. ~~~~~~~~~~~~~~
  319. **./FightClub.cpp**
  320.  
  321. ~~~~~~~~~~~~~~ { .c }
  322. //
  323. // Created by Alexander Dietrich on 07.05.2017.
  324. //
  325. #include <iostream>
  326. #include <vector>
  327. #include <cstring>
  328. #include "FightClup.h"
  329. #include "Fighters.h"
  330.  
  331. using namespace std;
  332. ///Findet den korrekten index f__r den angegebenen K__mpfer.
  333. int findFighter(string nickname, vector < Fighters * > FightClub)
  334. {
  335.     string f_nickname;
  336.  
  337.     for (unsigned int i = 0; i < FightClub.size(); ++i)
  338.     {
  339.         f_nickname = FightClub[i]->getNickname();
  340.         if (nickname.compare(f_nickname) == 0)
  341.         {
  342.             return i;
  343.         }
  344.     }
  345.     return -1;
  346. }
  347.  
  348.  
  349. ///Die Fight funktion f__hrt jeweils 1 Runde vom Kampf aus
  350. int fight(Fighters *fighter1, Fighters *fighter2)
  351. {
  352.     int conter, damageDone, lifepoints_fighter1, lifepoints_fighter2;
  353.  
  354.  
  355.     ///Fighter 2 attackiert Fighter 1
  356.     damageDone = fighter2->damageDone();
  357.     conter     = fighter1->damageTaken(damageDone);
  358.  
  359.     if (fighter1->getLifePoints() > 0)
  360.     {
  361.         fighter2->damageTaken(conter);
  362.         cout << fighter2->getNickname() << " attackiert " <<
  363.         fighter1->getNickname() << " und macht " <<
  364.             damageDone << " Schaden, " << fighter1->getNickname() <<
  365.         " kontert mit " << conter << " Schaden!" << endl;
  366.     }
  367.     else
  368.     {
  369.         cout << fighter2->getNickname() << " attackiert " <<
  370.         fighter1->getNickname() << " und macht " <<
  371.             damageDone << " Schaden, " << fighter1->getNickname() <<
  372.         " stirbt." << endl;
  373.     }
  374.  
  375.     ///hole mir die Lifepoints von beiden K__mpfern um zu __berpr__fen ob schon jemand gestorben ist
  376.     lifepoints_fighter1 = fighter1->getLifePoints();
  377.     lifepoints_fighter2 = fighter2->getLifePoints();
  378.  
  379.     ///Wenn jemand gewonnen hat, gebe den richtigen K__mpfer an den aufrufenden Parameter zur__ck
  380.     if ((lifepoints_fighter2 > 0) && (lifepoints_fighter1 <= 0))
  381.     {
  382.         return 2;
  383.     }
  384.     else if ((lifepoints_fighter1 > 0) && (lifepoints_fighter2 <= 0))
  385.     {
  386.         return 1;
  387.     }
  388.  
  389.     ///Fighter 1 attackiert Fighter 2
  390.     damageDone = fighter1->damageDone();
  391.     conter     = fighter2->damageTaken(damageDone);
  392.  
  393.     if (fighter2->getLifePoints() > 0)
  394.     {
  395.         fighter1->damageTaken(conter);
  396.         cout << fighter1->getNickname() << " attackiert " <<
  397.         fighter2->getNickname() << " und macht " <<
  398.             damageDone << " Schaden, " << fighter2->getNickname() <<
  399.         " kontert mit " << conter << " Schaden!" << endl;
  400.     }
  401.     else
  402.     {
  403.         cout << fighter1->getNickname() << " attackiert " <<
  404.         fighter2->getNickname() << " und macht " <<
  405.             damageDone << " Schaden, " << fighter2->getNickname() <<
  406.         " stirbt." << endl;
  407.     }
  408.  
  409.     ///hole mir die Lifepoints von beiden K__mpfern um zu __berpr__fen ob schon jemand gestorben ist
  410.     lifepoints_fighter1 = fighter1->getLifePoints();
  411.     lifepoints_fighter2 = fighter2->getLifePoints();
  412.  
  413.  
  414.     ///Wenn jemand gewonnen hat, gebe den richtigen K__mpfer an den aufrufenden Parameter zur__ck, falls jeder noch leben
  415.     ///hat, gebe 0 zur__ck und lass weiterk__mpfen
  416.     if ((lifepoints_fighter1 > 0) && (lifepoints_fighter2 <= 0))
  417.     {
  418.         return 1;
  419.     }
  420.     else if ((lifepoints_fighter2 > 0) && (lifepoints_fighter1 <= 0))
  421.     {
  422.         return 2;
  423.     }
  424.     else
  425.     {
  426.         return 0;
  427.     }
  428. }
  429.  
  430.  
  431.  
  432. ~~~~~~~~~~~~~~
  433. **./Fighters.h**
  434.  
  435. ~~~~~~~~~~~~~~ { .c }
  436. //
  437. // Created by Alexander Dietrich on 27.04.2017.
  438. //
  439.  
  440. #ifndef FIGHT_CLUB_FIGHTERS_H
  441. #define FIGHT_CLUB_FIGHTERS_H
  442. #include <string>
  443.  
  444. class Fighters {
  445. protected:
  446.     std::string nickName;
  447.     const int   offensePoints;
  448.     const int   defensePoints;
  449.     int         lifepoints;
  450.  
  451. public:
  452.     Fighters(std::string nichn);
  453.     virtual ~Fighters()
  454.     {
  455.     }
  456.     virtual int damageTaken(int attack)
  457.     {
  458.         return -1;
  459.     }
  460.  
  461.  
  462.     virtual int damageDone()
  463.     {
  464.         return -1;
  465.     }
  466.  
  467.  
  468.     std::string getNickname();
  469.     int getLifePoints();
  470.     int getOffensePoints();
  471.     int getDefensePoints();
  472. };
  473. #endif //FIGHT_CLUB_FIGHTERS_H
  474.  
  475. ~~~~~~~~~~~~~~
  476. **./Fighters.cpp**
  477.  
  478. ~~~~~~~~~~~~~~ { .c }
  479. //
  480. // Created by Alexander Dietrich on 27.04.2017.
  481. //
  482.  
  483. #include <cstdlib>
  484. #include "Fighters.h"
  485.  
  486. Fighters::Fighters(std::string nickname) : nickName(nickname), offensePoints(
  487.         rand() % 26 + 25), defensePoints(rand() % 26 + 25), lifepoints(100)
  488. {
  489. }
  490.  
  491.  
  492. std::string Fighters::getNickname()
  493. {
  494.     return nickName;
  495. }
  496.  
  497.  
  498. int Fighters::getLifePoints()
  499. {
  500.     return lifepoints;
  501. }
  502.  
  503.  
  504. int Fighters::getOffensePoints()
  505. {
  506.     return offensePoints;
  507. }
  508.  
  509.  
  510. int Fighters::getDefensePoints()
  511. {
  512.     return defensePoints;
  513. }
  514.  
  515.  
  516. ~~~~~~~~~~~~~~
  517. **./ninja.h**
  518.  
  519. ~~~~~~~~~~~~~~ { .c }
  520. //
  521. // Created by Alexander Dietrich on 27.04.2017.
  522. //
  523. #ifndef FIGHT_CLUB_NINJA_H
  524. #define FIGHT_CLUB_NINJA_H
  525.  
  526. #include "Fighters.h"
  527. #include <cstdlib>
  528.  
  529. class ninja : public Fighters {
  530. public:
  531.     ~ninja()
  532.     {
  533.     };
  534.     ninja(std::string nickname);
  535.     int damageTaken(int attack);
  536.     int damageDone();
  537. };
  538. #endif //FIGHT_CLUB_NINJA_H
  539.  
  540. ~~~~~~~~~~~~~~
  541. **./ninja.cpp**
  542.  
  543. ~~~~~~~~~~~~~~ { .c }
  544. //
  545. // Created by Alexander Dietrich on 27.04.2017.
  546. //
  547.  
  548. #include "ninja.h"
  549.  
  550. ninja::ninja(std::string nickname) : Fighters(nickname)
  551. {
  552. }
  553.  
  554.  
  555. int ninja::damageTaken(int attack)
  556. {
  557.     int conter;
  558.  
  559.     conter = rand() % (defensePoints + 1);
  560.     if (rand() % 6 != 0)
  561.     {
  562.         lifepoints -= attack;
  563.     }
  564.     return conter;
  565. }
  566.  
  567.  
  568. int ninja::damageDone()
  569. {
  570.     int dealDamage;
  571.  
  572.     dealDamage = rand() % (offensePoints + 1);
  573.  
  574.     return dealDamage;
  575. }
  576.  
  577. ~~~~~~~~~~~~~~
  578. **./warrior.h**
  579.  
  580. ~~~~~~~~~~~~~~ { .c }
  581. //
  582. // Created by Alexander Dietrich on 27.04.2017.
  583. //
  584.  
  585. #ifndef FIGHT_CLUB_WARRIOR_H
  586. #define FIGHT_CLUB_WARRIOR_H
  587. #include <cstdlib>
  588. #include "Fighters.h"
  589.  
  590.  
  591. class warrior : public Fighters {
  592. public:
  593.     ~warrior()
  594.     {
  595.     };
  596.     warrior(std::string nickname);
  597.     int damageTaken(int attack);
  598.     int damageDone();
  599. };
  600. #endif //FIGHT_CLUB_WARRIOR_H
  601.  
  602. ~~~~~~~~~~~~~~
  603. **./warrior.cpp**
  604.  
  605. ~~~~~~~~~~~~~~ { .c }
  606. //
  607. // Created by Alexander Dietrich on 27.04.2017.
  608. //
  609. #include "warrior.h"
  610.  
  611.  
  612. warrior::warrior(std::string nickname) : Fighters(nickname)
  613. {
  614. }
  615.  
  616.  
  617. int warrior::damageTaken(int attack)
  618. {
  619.     int conter;
  620.  
  621.     lifepoints -= attack;
  622.     conter      = rand() % (defensePoints + 1);
  623.     return conter;
  624. }
  625.  
  626.  
  627. int warrior::damageDone()
  628. {
  629.     int dealDamage = rand() % (offensePoints + 1);
  630.  
  631.     if (rand() % 6 == 0)
  632.     {
  633.         return dealDamage * 2;
  634.     }
  635.     return dealDamage;
  636. }
  637.  
  638.  
  639. ~~~~~~~~~~~~~~
  640. **./mage.h**
  641.  
  642. ~~~~~~~~~~~~~~ { .c }
  643. //
  644. // Created by Alexander Dietrich on 27.04.2017.
  645. //
  646. #ifndef FIGHT_CLUB_MAGE_H
  647. #define FIGHT_CLUB_MAGE_H
  648. #include <string>
  649. #include "Fighters.h"
  650.  
  651.  
  652. class mage : public Fighters {
  653. private:
  654.     int mana = 100;
  655.  
  656. public:
  657.     ~mage()
  658.     {
  659.     };
  660.     mage(std::string nickname);
  661.     int damageTaken(int attack);
  662.     int damageDone();
  663. };
  664. #endif //FIGHT_CLUB_MAGE_H
  665.  
  666. ~~~~~~~~~~~~~~
  667. **./mage.cpp**
  668.  
  669. ~~~~~~~~~~~~~~ { .c }
  670. //
  671. // Created by Alexander Dietrich on 27.04.2017.
  672. //
  673. #include <cstdlib>
  674. #include "mage.h"
  675.  
  676.  
  677. mage::mage(std::string nickname) : Fighters(nickname)
  678. {
  679. }
  680.  
  681.  
  682. int mage::damageDone()
  683. {
  684.     int dealDamage = rand() % (offensePoints + 1);
  685.  
  686.     if ((rand() % 3 == 0) && (mana > 30))
  687.     {
  688.         mana -= 30;
  689.         return (rand() % 30) + 10;
  690.     }
  691.     return dealDamage;
  692. }
  693.  
  694.  
  695. int mage::damageTaken(int attack)
  696. {
  697.     lifepoints -= attack;
  698.     int conter;
  699.     conter = rand() % (defensePoints + 1);
  700.  
  701.     return conter;
  702. }
  703.  
  704.  
  705. ~~~~~~~~~~~~~~
  706. **./alien.h**
  707.  
  708. ~~~~~~~~~~~~~~ { .c }
  709. //
  710. // Created by Alexander Dietrich on 07.05.2017.
  711. //
  712.  
  713. #ifndef FIGHT_CLUB_ALIEN_H
  714. #define FIGHT_CLUB_ALIEN_H
  715.  
  716. #include "Fighters.h"
  717.  
  718.  
  719. class alien : public Fighters {
  720.     bool bleeding;
  721.  
  722. public:
  723.     ~alien()
  724.     {
  725.     };
  726.     alien(std::string nickname);
  727.     int damageTaken(int attack);
  728.     int damageDone();
  729. };
  730. #endif //FIGHT_CLUB_ALIEN_H
  731.  
  732.  
  733. //
  734. // Created by Alexander Dietrich on 07.05.2017.
  735. //
  736.  
  737. #include <cstdlib>
  738. #include <iostream>
  739. #include "alien.h"
  740.  
  741.  
  742. alien::alien(std::string nickname) : Fighters(nickname), bleeding(false)
  743. {
  744. }
  745.  
  746.  
  747. int alien::damageDone()
  748. {
  749.     int dealDamage;
  750.  
  751.     dealDamage = rand() % (offensePoints + 1);
  752.  
  753.     if (bleeding && (dealDamage > 2))
  754.     {
  755.         return dealDamage - 2;
  756.     }
  757.  
  758.     return dealDamage;
  759. }
  760.  
  761.  
  762. int alien::damageTaken(int attack)
  763. {
  764.     int conter;
  765.  
  766.     conter = rand() % (defensePoints + 1);
  767.  
  768.     lifepoints -= attack * 0.9;
  769.  
  770.     if (rand() % 4 != 0)
  771.     {
  772.         bleeding = true;
  773.         std::cout << nickName <<
  774.         " beginnt zu bluten!! Blut aetzt bei jeden Konter" << std::endl;
  775.     }
  776.     if (bleeding)
  777.     {
  778.         return conter + 3;
  779.     }
  780.     return conter;
  781. }
Advertisement
Add Comment
Please, Sign In to add comment