using System;

using System.Reflection;
using System.Collections.Generic;
public class Hero
{
private string name;
private int level;
private int experience;
private double vitalityPoints;
private double evasivenessPoints;
private double spellPoints;
private double attackDamage;

public Hero(string name, double vitalityPoints, double evasivenessPoints,

double spellPoints)
{
this.name = name;
this.level = 1;
this.experience = 0;
this.vitalityPoints = vitalityPoints;
this.evasivenessPoints = evasivenessPoints;
this.spellPoints = spellPoints;
}

public virtual void LevelUp()

{
this.level += 1;
this.vitalityPoints += 1;
this.evasivenessPoints += 1;
this.spellPoints += 1;
}

public int Attack(int healthPoints)

{
int attackNeeded = (int)(healthPoints / this.attackDamage);
this.experience += healthPoints;

if (this.experience > this.level * 1000)

{
int extraExp = this.experience - this.level * 1000;
this.LevelUp();
this.experience = extraExp;
}
return attackNeeded;
}

public string GetName()

{
return name;
}
public void SetName(string name)
{
this.name = name;
}

public int GetLevel()

{
return level;
 }

public void SetLevel(int level)

{
this.level = level;
}

public int GetExperience()

{
return experience;
}

public void SetExperience(int experience)

{
this.experience = experience;
}

public double GetVitalityPoints()

{
return vitalityPoints;
}

public void SetVitalityPoints(double vitalityPoints)

{
this.vitalityPoints = vitalityPoints;
}

public double GetEvasivenessPoints()

{
return evasivenessPoints;
}

public void SetEvasivenessPoints(double evasivenessPoints)

{
this.evasivenessPoints = evasivenessPoints;
}

public double GetSpellPoints()

{
return spellPoints;
}
public void SetSpellPoints(double spellPoints)
{
this.spellPoints = spellPoints;
}

public double GetAttackDamage()

{
return attackDamage;
}
public void SetAttackDamage(double attackDamage)
{
this.attackDamage = attackDamage;
}

public class Brute : Hero

{
public Brute(double vitalityPoints, double evasivenessPoints, double
spellPoints) : base("Brute", vitalityPoints, evasivenessPoints, spellPoints)
 {
SetAttackDamage(GetLevel() * GetVitalityPoints() + 500);
}

public override void LevelUp()

{
SetLevel(GetLevel() + 1);
SetVitalityPoints(GetVitalityPoints() + 5);
SetEvasivenessPoints(GetEvasivenessPoints() + 0.5);
SetSpellPoints(GetSpellPoints() + 0.5);
SetAttackDamage(GetLevel() * GetVitalityPoints() + 500);
}
}

public class Champion : Hero

{
public Champion(double vitalityPoints, double evasivenessPoints, double
spellPoints) : base("Champion", vitalityPoints, evasivenessPoints, spellPoints)
{
SetAttackDamage(GetLevel() * GetEvasivenessPoints() * 2 *
(GetSpellPoints() + GetVitalityPoints()));
}

public override void LevelUp()

{
SetLevel(GetLevel() + 1);
SetVitalityPoints(GetVitalityPoints() + 2);
SetEvasivenessPoints(GetEvasivenessPoints() + 3.5);
SetSpellPoints(GetSpellPoints() + 1);
SetAttackDamage(GetLevel() * GetEvasivenessPoints() * 2 *
(GetSpellPoints() + GetVitalityPoints()));
}
}

public class Magus : Hero

{
public Magus(double vitalityPoints, double evasivenessPoints, double
spellPoints) : base("Magus", vitalityPoints, evasivenessPoints, spellPoints)
{
SetAttackDamage(GetLevel() * Math.Pow(2, Math.Floor(GetSpellPoints() /
2)) + 5 * (GetEvasivenessPoints()));
}

public override void LevelUp()

{
SetLevel(GetLevel() + 1);
SetVitalityPoints(GetVitalityPoints() + 1);
SetEvasivenessPoints(GetEvasivenessPoints() + 3);
SetSpellPoints(GetSpellPoints() + 4);
SetAttackDamage(GetLevel() * Math.Pow(2, Math.Floor(GetSpellPoints() /
2)) + 5 * (GetEvasivenessPoints()));
}
}

public class Mainclass

{
public static void Main(string[] args)
{
Console.Write("Enter Hero Class (1 - Brute, 2 - Champion, 3 - Magus):
");
int heroClass = Convert.ToInt32(Console.ReadLine());
Console.Write("Enter Vitality: ");
double vitality = Convert.ToDouble(Console.ReadLine());
Console.Write("Enter Evasiveness: ");
double evasiveness = Convert.ToDouble(Console.ReadLine());
Console.Write("Enter Spell: ");
double spell = Convert.ToDouble(Console.ReadLine());

Hero someHero;
switch (heroClass)
{
case 1:
someHero = new Brute(vitality, evasiveness, spell);
break;
case 2:
someHero = new Champion(vitality, evasiveness, spell);
break;
case 3:
someHero = new Magus(vitality, evasiveness, spell);
break;
default:
return;

}
Tester.Test(someHero);
}
}

class Tester
{
private static List<FieldInfo> GetAllFields(List<FieldInfo> fields, Type type)
{
fields.AddRange(type.GetFields(BindingFlags.NonPublic |
BindingFlags.Instance | BindingFlags.Public));

if (type.BaseType != null)
{
GetAllFields(fields, type.BaseType);
}

return fields;
}

private static FieldInfo GetField(object obj, string fieldName)

{
List<FieldInfo> fields = GetAllFields(new List<FieldInfo>(),
obj.GetType());
foreach (FieldInfo f in fields)
{
if (f.Name.Equals(fieldName))
{
return f;
}
}

return null;
}
 private static MethodInfo GetMethod(object obj, string methodName)
{
MethodInfo[] methods = obj.GetType().GetMethods();
foreach (MethodInfo m in methods)
{
if (m.Name.Equals(methodName))
{
return m;
}
}
return null;
}

public static void Test(Hero someHero)

{
Console.Write("Enter code: ");
int code = Convert.ToInt32(Console.ReadLine());

if (code == 1)
{
FieldInfo name = Tester.GetField(someHero, "name");
FieldInfo level = Tester.GetField(someHero, "level");
FieldInfo experience = Tester.GetField(someHero, "experience");
FieldInfo vitalityPoints = Tester.GetField(someHero, "vitalityPoints");
FieldInfo evasivenessPoints = Tester.GetField(someHero,
"evasivenessPoints");
FieldInfo spellPoints = Tester.GetField(someHero, "spellPoints");
FieldInfo attackDamage = Tester.GetField(someHero, "attackDamage");

if (
(name != null && name.IsPrivate) &&
(level != null && level.IsPrivate) &&
(experience != null && experience.IsPrivate) &&
(vitalityPoints != null && vitalityPoints.IsPrivate) &&
(evasivenessPoints != null && evasivenessPoints.IsPrivate) &&
(spellPoints != null && spellPoints.IsPrivate) &&
(attackDamage != null && attackDamage.IsPrivate)
)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}

else if (code == 2)
{
string testName = "Test";
int testLevel = 1;
int testExperience = 0;
double testVitalityPoints = 3;
double testEvasivenessPoints = 4;
double testSpellPoints = 5;
double testAttackDamage = 0;

Hero newHero = new Hero(testName, testVitalityPoints,

testEvasivenessPoints, testSpellPoints);

FieldInfo name = Tester.GetField(newHero, "name");

FieldInfo level = Tester.GetField(newHero, "level");
FieldInfo experience = Tester.GetField(newHero, "experience");
FieldInfo vitalityPoints = Tester.GetField(newHero, "vitalityPoints");
FieldInfo evasivenessPoints = Tester.GetField(newHero,
"evasivenessPoints");
FieldInfo spellPoints = Tester.GetField(newHero, "spellPoints");
FieldInfo attackDamage = Tester.GetField(newHero, "attackDamage");

try
{
string valueName = name.GetValue(newHero).ToString();
int valueLevel = int.Parse(level.GetValue(newHero).ToString());
int valueExperience =
int.Parse(experience.GetValue(newHero).ToString());
double valueVitalityPoints =
double.Parse(vitalityPoints.GetValue(newHero).ToString());
double valueEvasivenessPoints =
double.Parse(evasivenessPoints.GetValue(newHero).ToString());
double valueSpellPoints =
double.Parse(spellPoints.GetValue(newHero).ToString());
double valueAttackDamage =
double.Parse(attackDamage.GetValue(newHero).ToString());

if (
(valueName.Equals(testName)) &&
(valueLevel == testLevel) &&
(valueExperience == testExperience) &&
(valueVitalityPoints == testVitalityPoints) &&
(valueEvasivenessPoints == testEvasivenessPoints) &&
(valueSpellPoints == testSpellPoints) &&
(valueAttackDamage == testAttackDamage)
)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}
else if (code == 3)
{
MethodInfo GetLevel = Tester.GetMethod(someHero, "GetLevel");
MethodInfo GetExperience = Tester.GetMethod(someHero, "GetExperience");
MethodInfo GetVitalityPoints = Tester.GetMethod(someHero,
"GetVitalityPoints");
MethodInfo GetEvasivenessPoints = Tester.GetMethod(someHero,
"GetEvasivenessPoints");
MethodInfo GetSpellPoints = Tester.GetMethod(someHero,
"GetSpellPoints");
MethodInfo GetAttackDamage = Tester.GetMethod(someHero,
"GetAttackDamage");

try
{
Console.WriteLine(GetLevel.Invoke(someHero, null));
Console.WriteLine(GetExperience.Invoke(someHero, null));
Console.WriteLine(GetVitalityPoints.Invoke(someHero, null));
Console.WriteLine(GetEvasivenessPoints.Invoke(someHero, null));
Console.WriteLine(GetSpellPoints.Invoke(someHero, null));
Console.WriteLine(GetAttackDamage.Invoke(someHero, null));
Console.WriteLine("SUCCESS");
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}

else if (code == 4)
{
MethodInfo SetLevel = Tester.GetMethod(someHero, "SetLevel");
MethodInfo SetExperience = Tester.GetMethod(someHero, "SetExperience");
MethodInfo SetVitalityPoints = Tester.GetMethod(someHero,
"SetVitalityPoints");
MethodInfo SetEvasivenessPoints = Tester.GetMethod(someHero,
"SetEvasivenessPoints");
MethodInfo SetSpellPoints = Tester.GetMethod(someHero,
"SetSpellPoints");
MethodInfo SetAttackDamage = Tester.GetMethod(someHero,
"SetAttackDamage");

try
{
SetLevel.Invoke(someHero, new object[] { 1 });
SetExperience.Invoke(someHero, new object[] { 2 });
SetVitalityPoints.Invoke(someHero, new object[] { 3 });
SetEvasivenessPoints.Invoke(someHero, new object[] { 4 });
SetSpellPoints.Invoke(someHero, new object[] { 5 });
SetAttackDamage.Invoke(someHero, new object[] { 7 });

Console.WriteLine("SUCCESS");
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}

else if (code == 5)
{
Hero newHero = new Hero("Test", 1, 3, 5);

FieldInfo level = Tester.GetField(newHero, "level");

FieldInfo vitalityPoints = Tester.GetField(newHero, "vitalityPoints");
FieldInfo evasivenessPoints = Tester.GetField(newHero,
"evasivenessPoints");
FieldInfo spellPoints = Tester.GetField(newHero, "spellPoints");

MethodInfo LevelUp = Tester.GetMethod(newHero, "LevelUp");

 try
{
int testLevel = 2;
double testVitalityPoints = 2;
double testEvasivenessPoints = 4;
double testSpellPoints = 6;

LevelUp.Invoke(newHero, null);

int valueLevel = int.Parse(level.GetValue(newHero).ToString());

double valueVitalityPoints =
double.Parse(vitalityPoints.GetValue(newHero).ToString());
double valueEvasivenessPoints =
double.Parse(evasivenessPoints.GetValue(newHero).ToString());
double valueSpellPoints =
double.Parse(spellPoints.GetValue(newHero).ToString());

if (
valueLevel == testLevel &&
valueVitalityPoints == testVitalityPoints &&
valueEvasivenessPoints == testEvasivenessPoints &&
valueSpellPoints == testSpellPoints
)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}

else if (code == 6)
{
Hero newHero = new Hero("Test", 1, 3, 5);

MethodInfo Attack = Tester.GetMethod(newHero, "Attack");

MethodInfo SetAttackDamage = Tester.GetMethod(newHero,
"SetAttackDamage");

try
{
SetAttackDamage.Invoke(newHero, new object[] { 200 });
int testHealthPoints = 1000;
int testAttacksNeeded = 5;

int result = (int)Attack.Invoke(newHero, new object[]

{ testHealthPoints });

if (result == testAttacksNeeded)
{
Console.WriteLine("SUCCESS");
}
 else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}

else if (code == 7)
{
Magus newMagus = new Magus(10, 10, 10);

FieldInfo name = Tester.GetField(newMagus, "name");

FieldInfo attackDamage = Tester.GetField(newMagus, "attackDamage");

if (newMagus is Hero)
{
if (name == null)
{
Console.WriteLine("FAILED");
return;
}

try
{
String valueName = name.GetValue(newMagus).ToString();
String testName = "Magus";

double valueAttackDamage =
double.Parse(attackDamage.GetValue(newMagus).ToString());
double testAttackDamage = 82;

if (valueName.Equals(testName) && valueAttackDamage ==

testAttackDamage)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}

}
else
{
Console.WriteLine("FAILED");
}
}

else if (code == 8)
{
 Brute newBrute = new Brute(10, 10, 10);

FieldInfo name = Tester.GetField(newBrute, "name");

FieldInfo attackDamage = Tester.GetField(newBrute, "attackDamage");

if (newBrute is Hero)
{
if (name == null)
{
Console.WriteLine("FAILED");
return;
}

try
{
String valueName = name.GetValue(newBrute).ToString();
String testName = "Brute";

double valueAttackDamage =
double.Parse(attackDamage.GetValue(newBrute).ToString());
double testAttackDamage = 510;

if (valueName.Equals(testName) && valueAttackDamage ==

testAttackDamage)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}

}
else
{
Console.WriteLine("FAILED");
}
}

else if (code == 9)
{
Champion newChampion = new Champion(10, 10, 10);

FieldInfo name = Tester.GetField(newChampion, "name");

FieldInfo attackDamage = Tester.GetField(newChampion, "attackDamage");

if (newChampion is Hero)
{
if (name == null)
{
Console.WriteLine("FAILED");
return;
}
 try
{
String valueName = name.GetValue(newChampion).ToString();
String testName = "Champion";

double valueAttackDamage =
double.Parse(attackDamage.GetValue(newChampion).ToString());
double testAttackDamage = 400;

if (valueName.Equals(testName) && valueAttackDamage ==

testAttackDamage)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}

}
else
{
Console.WriteLine("FAILED");
}
}

else if (code == 10)

{
Brute newBrute = new Brute(10, 10, 10);

MethodInfo LevelUp = Tester.GetMethod(newBrute, "LevelUp");

MethodInfo GetLevel = Tester.GetMethod(newBrute, "GetLevel");
MethodInfo GetVitalityPoints = Tester.GetMethod(newBrute,
"GetVitalityPoints");
MethodInfo GetEvasivenessPoints = Tester.GetMethod(newBrute,
"GetEvasivenessPoints");
MethodInfo GetSpellPoints = Tester.GetMethod(newBrute,
"GetSpellPoints");
MethodInfo GetAttackDamage = Tester.GetMethod(newBrute,
"GetAttackDamage");

int testLevel = 2;
double testVitalityPoints = 15;
double testEvasivenessPoints = 10.5;
double testSpellPoints = 10.5;
double testAttackDamage = 530;

try
{
LevelUp.Invoke(newBrute, null);

int valueLevel = (int)GetLevel.Invoke(newBrute, null);

double valueVitalityPoints =
(double)GetVitalityPoints.Invoke(newBrute, null);
 double valueEvasivenessPoints =
(double)GetEvasivenessPoints.Invoke(newBrute, null);
double valueSpellPoints = (double)GetSpellPoints.Invoke(newBrute,
null);
double valueAttackDamage = (double)GetAttackDamage.Invoke(newBrute,
null);

if (
valueLevel == testLevel &&
valueVitalityPoints == testVitalityPoints &&
valueEvasivenessPoints == testEvasivenessPoints &&
valueSpellPoints == testSpellPoints &&
valueAttackDamage == testAttackDamage
)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}

else if (code == 11)

{
Magus newMagus = new Magus(10, 10, 10);

MethodInfo LevelUp = Tester.GetMethod(newMagus, "LevelUp");

MethodInfo GetLevel = Tester.GetMethod(newMagus, "GetLevel");
MethodInfo GetVitalityPoints = Tester.GetMethod(newMagus,
"GetVitalityPoints");
MethodInfo GetEvasivenessPoints = Tester.GetMethod(newMagus,
"GetEvasivenessPoints");
MethodInfo GetSpellPoints = Tester.GetMethod(newMagus,
"GetSpellPoints");
MethodInfo GetAttackDamage = Tester.GetMethod(newMagus,
"GetAttackDamage");

int testLevel = 2;
double testVitalityPoints = 11;
double testEvasivenessPoints = 13;
double testSpellPoints = 14;
double testAttackDamage = 321;

try
{
LevelUp.Invoke(newMagus, null);

int valueLevel = (int)GetLevel.Invoke(newMagus, null);

double valueVitalityPoints =
(double)GetVitalityPoints.Invoke(newMagus, null);
double valueEvasivenessPoints =
(double)GetEvasivenessPoints.Invoke(newMagus, null);
double valueSpellPoints = (double)GetSpellPoints.Invoke(newMagus,
null);
double valueAttackDamage = (double)GetAttackDamage.Invoke(newMagus,
null);

if (
valueLevel == testLevel &&
valueVitalityPoints == testVitalityPoints &&
valueEvasivenessPoints == testEvasivenessPoints &&
valueSpellPoints == testSpellPoints &&
valueAttackDamage == testAttackDamage
)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}

else if (code == 12)

{
Champion newChampion = new Champion(10, 10, 10);

MethodInfo LevelUp = Tester.GetMethod(newChampion, "LevelUp");

MethodInfo GetLevel = Tester.GetMethod(newChampion, "GetLevel");
MethodInfo GetVitalityPoints = Tester.GetMethod(newChampion,
"GetVitalityPoints");
MethodInfo GetEvasivenessPoints = Tester.GetMethod(newChampion,
"GetEvasivenessPoints");
MethodInfo GetSpellPoints = Tester.GetMethod(newChampion,
"GetSpellPoints");
MethodInfo GetAttackDamage = Tester.GetMethod(newChampion,
"GetAttackDamage");

int testLevel = 2;
double testVitalityPoints = 12;
double testEvasivenessPoints = 13.5;
double testSpellPoints = 11;
double testAttackDamage = 1242;

try
{
LevelUp.Invoke(newChampion, null);

int valueLevel = (int)GetLevel.Invoke(newChampion, null);

double valueVitalityPoints =
(double)GetVitalityPoints.Invoke(newChampion, null);
double valueEvasivenessPoints =
(double)GetEvasivenessPoints.Invoke(newChampion, null);
double valueSpellPoints =
(double)GetSpellPoints.Invoke(newChampion, null);
double valueAttackDamage =
(double)GetAttackDamage.Invoke(newChampion, null);
 if (
valueLevel == testLevel &&
valueVitalityPoints == testVitalityPoints &&
valueEvasivenessPoints == testEvasivenessPoints &&
valueSpellPoints == testSpellPoints &&
valueAttackDamage == testAttackDamage
)
{
Console.WriteLine("SUCCESS");
}
else
{
Console.WriteLine("FAILED");
}
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}

else if (code == 13)

{
MethodInfo Attack = Tester.GetMethod(someHero, "Attack");
MethodInfo LevelUp = Tester.GetMethod(someHero, "LevelUp");
MethodInfo GetLevel = Tester.GetMethod(someHero, "GetLevel");
MethodInfo GetAttackDamage = Tester.GetMethod(someHero,
"GetAttackDamage");
MethodInfo GetExperience = Tester.GetMethod(someHero, "GetExperience");

try
{

Console.WriteLine("\nInitial level: " + GetLevel.Invoke(someHero,

null));

Console.WriteLine("Current damage: " +

GetAttackDamage.Invoke(someHero, null));

Console.WriteLine("Attacks needed for 1000 Health Points: " +

Attack.Invoke(someHero, new object[] { 1000 }));

Console.WriteLine("Experience after Attack: " +

GetExperience.Invoke(someHero, null));

LevelUp.Invoke(someHero, null);

Console.WriteLine("\nLevel after level up: " +

GetLevel.Invoke(someHero, null));

Console.WriteLine("Current damage: " +

GetAttackDamage.Invoke(someHero, null));

Console.WriteLine("Attacks needed for 2000 Health Points:: " +

Attack.Invoke(someHero, new object[] { 2000 }));

Console.WriteLine("Experience after Attack: " +

GetExperience.Invoke(someHero, null));
 LevelUp.Invoke(someHero, null);

Console.WriteLine("\nLevel after level up: " +

GetLevel.Invoke(someHero, null));

Console.WriteLine("Current damage: " +

GetAttackDamage.Invoke(someHero, null));

Console.WriteLine("Attacks needed for 10000 Health Points: " +

Attack.Invoke(someHero, new object[] { 10000 }));

Console.WriteLine("Experience after Attack: " +

GetExperience.Invoke(someHero, null));
}
catch (Exception)
{
Console.WriteLine("FAILED");
}
}
}
}
}