Scribd
Upload
11 views15 pages

Code

The document defines a Hero class and subclasses that represent different hero types in a game. The Hero class tracks attributes like name, level, experience and stats. The subclasses override methods like LevelUp to increase stats differently. The document also includes a Tester class and Main method to test hero object creation and attribute values.

Uploaded by

Janze Moubis
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
11 views15 pages

Code

The document defines a Hero class and subclasses that represent different hero types in a game. The Hero class tracks attributes like name, level, experience and stats. The subclasses override methods like LevelUp to increase stats differently. The document also includes a Tester class and Main method to test hero object creation and attribute values.

Uploaded by

Janze Moubis
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 15

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");
}
}
}
}
}

You might also like