// ===========================================================================
// Week 14: Polymorphism
// ===========================================================================
#include <iostream>
#include <string>
#include <cmath>
using namespace std;

class Character
{
protected:
  string name;
  int level;
  int exp;
  int power;
  int knowledge;
  int luck;
  static const int expForLevel = 100;
  void levelUp(int pInc, int kInc, int lInc);
public:
  Character(string n, int lv, int po, int kn, int lu);
  virtual void beatMonster(int exp) = 0;
  virtual void print();
  string getName();
};

Character::Character(string n, int lv, int po, int kn, int lu) 
  : name(n), level(lv), exp(pow(lv - 1, 2) * expForLevel), power(po), knowledge(kn), luck(lu) 
{
}

void Character::print()
{
  cout << this->name 
       << ": Level " << this->level << " (" << this->exp << "/" << pow(this->level, 2) * expForLevel
       << "), " << this->power << "-" << this->knowledge << "-" << this->luck << "\n";
}

void Character::levelUp(int pInc, int kInc, int lInc)
{
  this->level++;
  this->power += pInc;
  this->knowledge += kInc;
  this->luck += lInc;    
}

string Character::getName()
{
  return this->name;
}










class Warrior : public Character
{
private:
  static const int powerPerLevel = 10;
  static const int knowledgePerLevel = 5;
  static const int luckPerLevel = 5;
public:
  Warrior(string n) : Character(n, 1, powerPerLevel, knowledgePerLevel, luckPerLevel) {}
  Warrior(string n, int lv) : Character(n, lv, lv * powerPerLevel, lv * knowledgePerLevel, lv * luckPerLevel) {}
  void print()
  {
    cout << "Warrior ";
    Character::print();
  }  
  void beatMonster(int exp)
  {
  	this->exp += exp;
  	if(this->exp >= pow(this->level, 2) * expForLevel)
  	  this->levelUp(powerPerLevel, knowledgePerLevel, luckPerLevel);
  }
};

class Wizard : public Character
{
private:
  static const int powerPerLevel = 4;
  static const int knowledgePerLevel = 9;
  static const int luckPerLevel = 7;
public:
  Wizard(string n) : Character(n, 1, powerPerLevel, knowledgePerLevel, luckPerLevel) {}
  Wizard(string n, int lv) : Character(n, lv, lv * powerPerLevel, lv * knowledgePerLevel, lv * luckPerLevel) {}
  void print()
  {
    cout << "Wizard ";
    Character::print();
  }  
  void beatMonster(int exp)
  {
  	this->exp += exp;
  	if(this->exp >= pow(this->level, 2) * expForLevel)
  	  this->levelUp(powerPerLevel, knowledgePerLevel, luckPerLevel);
  }
};


















class Team
{
private:
  int memberCount;
  Character* member[10];
public:
  Team();
  ~Team();
  void addMember(string name, int lv, char occupation);
  void memberBeatMonster(string name, int exp);
  void printMember(string name);
};

Team::Team()
{
  this->memberCount = 0;
  for(int i = 0; i < 10; i++)
    member[i] = NULL;
}

Team::~Team()
{
  for(int i = 0; i < this->memberCount; i++)
    delete this->member[i];
}

void Team::addMember(string name, int lv, char occupation)
{
  if(this->memberCount < 10)
  {
    if(occupation == 'R')
      this->member[this->memberCount] = new Warrior(name, lv);
    else if(occupation == 'D')
      this->member[this->memberCount] = new Wizard(name, lv);
    this->memberCount++;
  }
}

void Team::memberBeatMonster(string name, int exp)
{
  for(int i = 0; i < this->memberCount; i++)
  {
    if(this->member[i]->getName() == name)
    {
      this->member[i]->beatMonster(exp);
      break;
    }
  }  
}

void Team::printMember(string name)
{
  for(int i = 0; i < this->memberCount; i++)
  {
    if(this->member[i]->getName() == name)
    {
      this->member[i]->print();
      break;
    }
  }
}









class A
{
public:
  void a() { cout << "a\n"; } 
  void f() { cout << "af\n"; } 
};

class B : public A
{
public:
  void b() { cout << "b\n"; }
  void f() { cout << "bf\n"; }
};











int main()
{
  Character* c[3]; 
  c[0] = new Warrior("Alice", 10); 
  c[1] = new Wizard("Sophie", 8); 
  c[2] = new Warrior("Amy", 12); 
  for(int i = 0; i < 3; i++)
    c[i]->print(); 
  c[0]->beatMonster(10000);
  for(int i = 0; i < 3; i++)
    c[i]->print(); 
  for(int i = 0; i < 3; i++)
    delete c[i]; 

  B b1;
  A a1 = b1;
  a1.a();
  a1.f();
  // a1.b();

  B b2;
  A* a2 = &b2;
  a2->a();
  a2->f();
  // a2->b();


}