~~~~~~~~~~~~~~
**./main.cpp**

~~~~~~~~~~~~~~ { .c }
#include <iostream>
#include <vector>
#include <time.h>
#include "Fighters.h"
#include "mage.h"
#include "ninja.h"
#include "warrior.h"
#include "alien.h"
#include "FightClup.h"


using namespace std;

int main()
{
    vector < Fighters * > Fightclub;
    string fighter1, fighter2;
    bool   exit = false;

    cout <<
    "-----------------------------------------------------------------------------------------"
         << endl;
    cout <<
    "----------------------------------- WELCOME TO ------------------------------------------"
         << endl;
    cout <<
    "--------------------------------- THE  FIGHTCLUB ----------------------------------------"
         << endl;
    cout <<
    "-----------------------------------------------------------------------------------------"
         << endl;

    while (!exit)
    {
        int menu = 0;
        cout << "Waaas wiillst du tuun?!" << endl;
        cout << "1 = Neuen Kaempfer anlegen!" << endl <<
        "2 = Zwei Kaempfer in den Ring schicken!" << endl <<
            "3 = Kaempfer anzeigen lassen!" << endl <<
        "4 = Einen Kaempfer loeschen!" << endl <<
            "5 = Last Man Standing " << endl << "Beliebige Nummer = EXIT!" <<
        endl;
        cin >> menu;

        switch (menu)
        {
        case 1:
           {
               string nickname;
               int    type;
               cout << "Welchen Typ Fighter wollen sie auswaehlen?" << endl <<
                "1 = Krieger"
                    << endl << "2 = Magier" << endl << "3 = Ninja" << endl <<
                "4 = Alien" << endl;
               cin >> type;
               cout << "Waehlen Sie einen Nicknamen fuer Ihren Kaempfer!" <<
                endl;
               cin >> nickname;

               ///speicher f__r neuen Fighter wird reserviert
               switch (type)
               {
               case 1:
                  {
                      Fightclub.push_back(new warrior(nickname));
                      break;
                  }

               case 2:
                  {
                      Fightclub.push_back(new mage(nickname));
                      break;
                  }

               case 3:
                  {
                      Fightclub.push_back(new ninja(nickname));
                      break;
                  }

               case 4:
                  {
                      Fightclub.push_back(new alien(nickname));
                      break;
                  }

               default:
                  {
                      cout << "Falsche Eingabe! wtf! Kaunst ned zoehn!?" <<
                        endl;
                      break;
                  }
               }
               break;
           }

        case 2:
           {
               Fighters *Fighter1;
               Fighters *Fighter2;
               int      index_Fighter1, index_Fighter2;
               int      check_win;
               check_win = 0;
               cout << "Welchen Kaempfer willst du in den Ring schicken?!" <<
                endl;
               cin >> fighter1;
               cout << "Wer soll gegen den gewaehlten Kaempfer antreten?!" <<
                endl;
               cin >> fighter2;

               ///suche nach eingegebenen K__mpfern und den Index in einen int gespeichert
               index_Fighter1 = findFighter(fighter1, Fightclub);
               index_Fighter2 = findFighter(fighter2, Fightclub);

               ///Hole mir die richtigen Instanzen in eine Variable
               Fighter1 = Fightclub[index_Fighter1];
               Fighter2 = Fightclub[index_Fighter2];

               ///solange der Kampf nicht vor__ber ist und einer der K__mpfer 0 Lebenspunkte hat, wird die Schleife
               ///fortgesetzt
               while (check_win == 0)
               {
                   check_win = fight(Fighter1, Fighter2);
               }
               ///Speicher vom Verlierer wird freigegeben und der Fighter wird aus den Vektor gel__scht beziehungsweise
               ///eine Gewinnmeldung wird ausgegeben
               if (check_win == 1)
               {
                   delete Fighter2;
                   Fightclub.erase(Fightclub.begin() + (index_Fighter2));
                   cout << fighter1 << " gewinnt gegen " << fighter2 << "!! " <<
                    endl << endl;
               }
               else if (check_win == 2)
               {
                   delete Fighter1;
                   Fightclub.erase(Fightclub.begin() + (index_Fighter1));
                   cout << fighter2 << " gewinnt gegen " << fighter1 << "!! " <<
                    endl << endl;
               }
               break;
           }

        case 3:
           {
               int    lifepoints, offensePoints, defensePoints;
               string nickname;

               ///Mein Vektor wird durchgegangen und alle gespeicherten K__mpfer werden in einer Liste ausgegegeben
               for (unsigned int i = 0; i < Fightclub.size(); ++i)
               {
                   nickname      = Fightclub[i]->getNickname();
                   lifepoints    = Fightclub[i]->getLifePoints();
                   offensePoints = Fightclub[i]->getOffensePoints();
                   defensePoints = Fightclub[i]->getDefensePoints();

                   cout << nickname << " ist registriert und verfuegt ueber " <<
                    lifepoints << " Lebenspunkte, "
                        << offensePoints << " Angriffspunkte und " <<
                    defensePoints << " Verteidigungspunkte" << endl;
               }
               cout << endl;
               break;
           }

        case 4:
           {
               ///Fighter soll gel__scht werden.
               string nickname;
               int    index_Fighter_for_delete;

               cout <<
                "Welcher Krieger soll aus den Fightclub entfernt werden?!" <<
                endl;
               cin >> nickname;

               index_Fighter_for_delete = findFighter(nickname, Fightclub);

               if (index_Fighter_for_delete >= 0)
               {
                   delete Fightclub[index_Fighter_for_delete];
                   Fightclub.erase(
                       Fightclub.begin() + (index_Fighter_for_delete));
               }
               break;
           }

        case 5:
           {
               int      random_index_Fighter1, random_index_Fighter2;
               int      count_fighters = 2;
               int      check_win      = 0;
               bool     lastManStanding;
               Fighters *Fighter1;
               Fighters *Fighter2;
               string   winner, Fighter1_tmp, Fighter2_tmp;
               lastManStanding = false;

               ///Solange bool f__r einen LastManStanding nicht gesetzt is soll immer weiter gek__mpft werden.
               while (!lastManStanding)
               {
                   ///Ich hole mir random Indizes f__r die zuf__llig aufeinandertreffende Gegner
                   random_index_Fighter1 = rand() % Fightclub.size();
                   random_index_Fighter2 = rand() % Fightclub.size();

                   ///Hole mir die Nicknamen der aufeinandertreffenden Gegner f__r die Siegesmeldung und Kampfverlauf
                   Fighter1_tmp =
                       Fightclub[random_index_Fighter1]->getNickname();
                   Fighter2_tmp =
                       Fightclub[random_index_Fighter2]->getNickname();

                   ///Speichere meine K__mpfer f__r den Kampf ab
                   Fighter1 = Fightclub[random_index_Fighter1];
                   Fighter2 = Fightclub[random_index_Fighter2];

                   ///Solange mehr als 1 K__mpfer im Vektor ist, soll weitergek__mpft werden
                   if (count_fighters > 1)
                   {
                       ///__berpr__fe ob die K__mpfer gleich sind und ob die K__mpfer aufh nicht schon besiegt wurden.
                       if ((random_index_Fighter1 != random_index_Fighter2) &&
                           (Fightclub[random_index_Fighter1] != NULL) &&
                           (Fightclub[random_index_Fighter2] != NULL))
                       {
                           while (check_win == 0)
                           {
                               check_win = fight(Fighter1, Fighter2);
                           }
                           if (check_win == 1)
                           {
                               delete Fighter2;
                               Fightclub.erase(Fightclub.begin() +
                                               (random_index_Fighter2));
                               cout << Fighter1_tmp << " gewinnt gegen " <<
                                Fighter2_tmp << "!! " << endl << endl;
                           }
                           else if (check_win == 2)
                           {
                               delete Fighter1;
                               Fightclub.erase(Fightclub.begin() +
                                               (random_index_Fighter1));
                               cout << Fighter2_tmp << " gewinnt gegen " <<
                                Fighter1_tmp << "!! " << endl << endl;
                           }
                           check_win = 0;
                       }
                       ///__berpr__fe wieviel Eintr__ge in der Liste der K__mpfer noch eingetragen sind.
                       count_fighters = 0;
                       for (unsigned int i = 0; i < Fightclub.size(); ++i)
                       {
                           if (Fightclub[i] != NULL)
                           {
                               count_fighters++;
                           }
                       }
                   }
                   else
                   {
                       lastManStanding = true;
                   }
               }

               for (unsigned int j = 0; j < Fightclub.size(); ++j)
               {
                   if (Fightclub[j] != NULL)
                   {
                       winner = Fightclub[j]->getNickname();
                   }
               }

               cout << endl << winner <<
                " ist unser Gewinner im Last-Man-Standing Kampf!!!" << endl;

               break;
           }

        default:
            exit = true;
        }
    }

    ///Gebe den gesamten restlichen Speicher frei
    for (unsigned int k = 0; k < Fightclub.size(); ++k)
    {
        delete Fightclub.at(k);
    }
    return EXIT_SUCCESS;
}

~~~~~~~~~~~~~~
**./FightClup.h**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 07.05.2017.
//

#ifndef FIGHT_CLUB_FIGHTCLUP_H
#define FIGHT_CLUB_FIGHTCLUP_H
#include <iostream>
#include <vector>
#include <cstring>
#include "FightClup.h"
#include "Fighters.h"


using namespace std;

int findFighter(string nickname, vector < Fighters * > FightClub);


int fight(Fighters *fighter1, Fighters *fighter2);
#endif //FIGHT_CLUB_FIGHTCLUP_H

~~~~~~~~~~~~~~
**./FightClub.cpp**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 07.05.2017.
//
#include <iostream>
#include <vector>
#include <cstring>
#include "FightClup.h"
#include "Fighters.h"

using namespace std;
///Findet den korrekten index f__r den angegebenen K__mpfer.
int findFighter(string nickname, vector < Fighters * > FightClub)
{
    string f_nickname;

    for (unsigned int i = 0; i < FightClub.size(); ++i)
    {
        f_nickname = FightClub[i]->getNickname();
        if (nickname.compare(f_nickname) == 0)
        {
            return i;
        }
    }
    return -1;
}


///Die Fight funktion f__hrt jeweils 1 Runde vom Kampf aus
int fight(Fighters *fighter1, Fighters *fighter2)
{
    int conter, damageDone, lifepoints_fighter1, lifepoints_fighter2;


    ///Fighter 2 attackiert Fighter 1
    damageDone = fighter2->damageDone();
    conter     = fighter1->damageTaken(damageDone);

    if (fighter1->getLifePoints() > 0)
    {
        fighter2->damageTaken(conter);
        cout << fighter2->getNickname() << " attackiert " <<
        fighter1->getNickname() << " und macht " <<
            damageDone << " Schaden, " << fighter1->getNickname() <<
        " kontert mit " << conter << " Schaden!" << endl;
    }
    else
    {
        cout << fighter2->getNickname() << " attackiert " <<
        fighter1->getNickname() << " und macht " <<
            damageDone << " Schaden, " << fighter1->getNickname() <<
        " stirbt." << endl;
    }

    ///hole mir die Lifepoints von beiden K__mpfern um zu __berpr__fen ob schon jemand gestorben ist
    lifepoints_fighter1 = fighter1->getLifePoints();
    lifepoints_fighter2 = fighter2->getLifePoints();

    ///Wenn jemand gewonnen hat, gebe den richtigen K__mpfer an den aufrufenden Parameter zur__ck
    if ((lifepoints_fighter2 > 0) && (lifepoints_fighter1 <= 0))
    {
        return 2;
    }
    else if ((lifepoints_fighter1 > 0) && (lifepoints_fighter2 <= 0))
    {
        return 1;
    }

    ///Fighter 1 attackiert Fighter 2
    damageDone = fighter1->damageDone();
    conter     = fighter2->damageTaken(damageDone);

    if (fighter2->getLifePoints() > 0)
    {
        fighter1->damageTaken(conter);
        cout << fighter1->getNickname() << " attackiert " <<
        fighter2->getNickname() << " und macht " <<
            damageDone << " Schaden, " << fighter2->getNickname() <<
        " kontert mit " << conter << " Schaden!" << endl;
    }
    else
    {
        cout << fighter1->getNickname() << " attackiert " <<
        fighter2->getNickname() << " und macht " <<
            damageDone << " Schaden, " << fighter2->getNickname() <<
        " stirbt." << endl;
    }

    ///hole mir die Lifepoints von beiden K__mpfern um zu __berpr__fen ob schon jemand gestorben ist
    lifepoints_fighter1 = fighter1->getLifePoints();
    lifepoints_fighter2 = fighter2->getLifePoints();


    ///Wenn jemand gewonnen hat, gebe den richtigen K__mpfer an den aufrufenden Parameter zur__ck, falls jeder noch leben
    ///hat, gebe 0 zur__ck und lass weiterk__mpfen
    if ((lifepoints_fighter1 > 0) && (lifepoints_fighter2 <= 0))
    {
        return 1;
    }
    else if ((lifepoints_fighter2 > 0) && (lifepoints_fighter1 <= 0))
    {
        return 2;
    }
    else
    {
        return 0;
    }
}



~~~~~~~~~~~~~~
**./Fighters.h**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//

#ifndef FIGHT_CLUB_FIGHTERS_H
#define FIGHT_CLUB_FIGHTERS_H
#include <string>

class Fighters {
protected:
    std::string nickName;
    const int   offensePoints;
    const int   defensePoints;
    int         lifepoints;

public:
    Fighters(std::string nichn);
    virtual ~Fighters()
    {
    }
    virtual int damageTaken(int attack)
    {
        return -1;
    }


    virtual int damageDone()
    {
        return -1;
    }


    std::string getNickname();
    int getLifePoints();
    int getOffensePoints();
    int getDefensePoints();
};
#endif //FIGHT_CLUB_FIGHTERS_H

~~~~~~~~~~~~~~
**./Fighters.cpp**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//

#include <cstdlib>
#include "Fighters.h"

Fighters::Fighters(std::string nickname) : nickName(nickname), offensePoints(
        rand() % 26 + 25), defensePoints(rand() % 26 + 25), lifepoints(100)
{
}


std::string Fighters::getNickname()
{
    return nickName;
}


int Fighters::getLifePoints()
{
    return lifepoints;
}


int Fighters::getOffensePoints()
{
    return offensePoints;
}


int Fighters::getDefensePoints()
{
    return defensePoints;
}


~~~~~~~~~~~~~~
**./ninja.h**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//
#ifndef FIGHT_CLUB_NINJA_H
#define FIGHT_CLUB_NINJA_H

#include "Fighters.h"
#include <cstdlib>

class ninja : public Fighters {
public:
    ~ninja()
    {
    };
    ninja(std::string nickname);
    int damageTaken(int attack);
    int damageDone();
};
#endif //FIGHT_CLUB_NINJA_H

~~~~~~~~~~~~~~
**./ninja.cpp**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//

#include "ninja.h"

ninja::ninja(std::string nickname) : Fighters(nickname)
{
}


int ninja::damageTaken(int attack)
{
    int conter;

    conter = rand() % (defensePoints + 1);
    if (rand() % 6 != 0)
    {
        lifepoints -= attack;
    }
    return conter;
}


int ninja::damageDone()
{
    int dealDamage;

    dealDamage = rand() % (offensePoints + 1);

    return dealDamage;
}

~~~~~~~~~~~~~~
**./warrior.h**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//

#ifndef FIGHT_CLUB_WARRIOR_H
#define FIGHT_CLUB_WARRIOR_H
#include <cstdlib>
#include "Fighters.h"


class warrior : public Fighters {
public:
    ~warrior()
    {
    };
    warrior(std::string nickname);
    int damageTaken(int attack);
    int damageDone();
};
#endif //FIGHT_CLUB_WARRIOR_H

~~~~~~~~~~~~~~
**./warrior.cpp**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//
#include "warrior.h"


warrior::warrior(std::string nickname) : Fighters(nickname)
{
}


int warrior::damageTaken(int attack)
{
    int conter;

    lifepoints -= attack;
    conter      = rand() % (defensePoints + 1);
    return conter;
}


int warrior::damageDone()
{
    int dealDamage = rand() % (offensePoints + 1);

    if (rand() % 6 == 0)
    {
        return dealDamage * 2;
    }
    return dealDamage;
}


~~~~~~~~~~~~~~
**./mage.h**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//
#ifndef FIGHT_CLUB_MAGE_H
#define FIGHT_CLUB_MAGE_H
#include <string>
#include "Fighters.h"


class mage : public Fighters {
private:
    int mana = 100;

public:
    ~mage()
    {
    };
    mage(std::string nickname);
    int damageTaken(int attack);
    int damageDone();
};
#endif //FIGHT_CLUB_MAGE_H

~~~~~~~~~~~~~~
**./mage.cpp**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 27.04.2017.
//
#include <cstdlib>
#include "mage.h"


mage::mage(std::string nickname) : Fighters(nickname)
{
}


int mage::damageDone()
{
    int dealDamage = rand() % (offensePoints + 1);

    if ((rand() % 3 == 0) && (mana > 30))
    {
        mana -= 30;
        return (rand() % 30) + 10;
    }
    return dealDamage;
}


int mage::damageTaken(int attack)
{
    lifepoints -= attack;
    int conter;
    conter = rand() % (defensePoints + 1);

    return conter;
}


~~~~~~~~~~~~~~
**./alien.h**

~~~~~~~~~~~~~~ { .c }
//
// Created by Alexander Dietrich on 07.05.2017.
//

#ifndef FIGHT_CLUB_ALIEN_H
#define FIGHT_CLUB_ALIEN_H

#include "Fighters.h"


class alien : public Fighters {
    bool bleeding;

public:
    ~alien()
    {
    };
    alien(std::string nickname);
    int damageTaken(int attack);
    int damageDone();
};
#endif //FIGHT_CLUB_ALIEN_H


//
// Created by Alexander Dietrich on 07.05.2017.
//

#include <cstdlib>
#include <iostream>
#include "alien.h"


alien::alien(std::string nickname) : Fighters(nickname), bleeding(false)
{
}


int alien::damageDone()
{
    int dealDamage;

    dealDamage = rand() % (offensePoints + 1);

    if (bleeding && (dealDamage > 2))
    {
        return dealDamage - 2;
    }

    return dealDamage;
}


int alien::damageTaken(int attack)
{
    int conter;

    conter = rand() % (defensePoints + 1);

    lifepoints -= attack * 0.9;

    if (rand() % 4 != 0)
    {
        bleeding = true;
        std::cout << nickName <<
        " beginnt zu bluten!! Blut aetzt bei jeden Konter" << std::endl;
    }
    if (bleeding)
    {
        return conter + 3;
    }
    return conter;
}