public void ReturnsAppropriateTeam_MultipleEnemies([Values(1, 2, 3)] int numberOfExtraEnemies)
{
_menuInput.Push("yes", "goblin", "1");
for (var i = 0; i < numberOfExtraEnemies; ++i)
{
_menuInput.Push("yes", "fairy", "1");
}
_menuInput.Push("no");
BattleConfigurationSpecialFlag battleFlag;
Team returnedTeam = _menuManager.GetTeam(TestMenuManager.GetTestMenuManager(), _menuInput, _menuOutput, out battleFlag);
Assert.AreEqual(numberOfExtraEnemies + 1, returnedTeam.Fighters.Count);
HumanControlledEnemyFighter humanControlledFighter = returnedTeam.Fighters[0] as HumanControlledEnemyFighter;
Assert.NotNull(humanControlledFighter);
Assert.IsTrue(humanControlledFighter.Fighter is Goblin);
Assert.AreEqual(1, humanControlledFighter.Fighter.Level);
for (var i = 0; i < numberOfExtraEnemies; ++i)
{
humanControlledFighter = returnedTeam.Fighters[i + 1] as HumanControlledEnemyFighter;
Assert.NotNull(humanControlledFighter);
Assert.IsTrue(humanControlledFighter.Fighter is Fairy);
Assert.AreEqual(1, humanControlledFighter.Fighter.Level);
}
}
public void ReturnsAppropriateTeam_MaximumNumberOfEnemies()
{
_menuInput.Push("yes", "goblin", "3");
for (var i = 0; i < 4; ++i)
{
_menuInput.Push("yes", "warrior", "3");
}
BattleConfigurationSpecialFlag battleFlag;
Team returnedTeam = _menuManager.GetTeam(TestMenuManager.GetTestMenuManager(), _menuInput, _menuOutput, out battleFlag);
Assert.AreEqual(5, returnedTeam.Fighters.Count);
for (var i = 0; i < 5; ++i)
{
HumanControlledEnemyFighter humanControlledFighter = returnedTeam.Fighters[i] as HumanControlledEnemyFighter;
Assert.NotNull(humanControlledFighter);
if (i == 0)
{
Assert.IsTrue(humanControlledFighter.Fighter is Goblin);
}
else
{
Assert.IsTrue(humanControlledFighter.Fighter is Warrior);
}
Assert.AreEqual(3, humanControlledFighter.Fighter.Level);
}
}
public void ReturnsAppropriateTeam_HandlesInitialPromptForHumanControlledOrComputerControlledTeam([Values("yes", "no")] string firstPrompt)
{
_menuInput.Push(firstPrompt, "goblin", "1", "yes", "fairy", "1", "no");
BattleConfigurationSpecialFlag battleFlag;
Team returnedTeam = _menuManager.GetTeam(TestMenuManager.GetTestMenuManager(), _menuInput, _menuOutput, out battleFlag);
IFighter firstFighter, secondFighter;
if (firstPrompt == "yes")
{
Assert.IsTrue(returnedTeam.Fighters.TrueForAll(f => f is HumanControlledEnemyFighter));
HumanControlledEnemyFighter humanControlledFirstFighter = returnedTeam.Fighters[0] as HumanControlledEnemyFighter;
HumanControlledEnemyFighter humanControlledSecondFighter = returnedTeam.Fighters[1] as HumanControlledEnemyFighter;
firstFighter = humanControlledFirstFighter.Fighter;
secondFighter = humanControlledSecondFighter.Fighter;
}
else
{
Assert.IsNull(returnedTeam.Fighters.FirstOrDefault(f => f is HumanControlledEnemyFighter));
firstFighter = returnedTeam.Fighters[0];
secondFighter = returnedTeam.Fighters[1];
}
Assert.IsInstanceOf <Goblin>(firstFighter);
Assert.IsInstanceOf <Fairy>(secondFighter);
}
public void Setup()
{
_input = new MockInput();
_output = new MockOutput();
_menuManager = new TestMenuManager(_input, _output);
_mockChanceService = new MockChanceService();
TestFighterFactory.SetChanceService(_mockChanceService);
FighterFactory.SetInput(_input);
FighterFactory.SetOutput(_output);
_fighter = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1, "hero");
_enemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "enemy");
}
public void ReturnsAppropriateTeam_SingleEnemy()
{
_menuInput.Push("yes", "goblin", "1", "no");
BattleConfigurationSpecialFlag battleFlag;
Team returnedTeam = _menuManager.GetTeam(TestMenuManager.GetTestMenuManager(), _menuInput, _menuOutput, out battleFlag);
Assert.AreEqual(1, returnedTeam.Fighters.Count);
HumanControlledEnemyFighter humanControlledFighter = returnedTeam.Fighters[0] as HumanControlledEnemyFighter;
Assert.NotNull(humanControlledFighter);
Assert.IsTrue(humanControlledFighter.Fighter is Goblin);
}
public void ReturnsAppropriateTeam_CorrectlyHandlesBackOption()
{
_menuInput.Push("yes", "goblin", "1", "yes", "back", "shieldGuy", "2", "no");
BattleConfigurationSpecialFlag battleFlag;
Team returnedTeam = _menuManager.GetTeam(TestMenuManager.GetTestMenuManager(), _menuInput, _menuOutput, out battleFlag);
Assert.AreEqual(1, returnedTeam.Fighters.Count);
HumanControlledEnemyFighter humanControlledFighter = returnedTeam.Fighters[0] as HumanControlledEnemyFighter;
Assert.NotNull(humanControlledFighter);
Assert.IsTrue(humanControlledFighter.Fighter is ShieldGuy);
Assert.AreEqual(2, humanControlledFighter.Fighter.Level);
}
public void Constructor_CorrectlySetsDisplayNames_TeamEntirelyComprisedOfHumanControlledEnemies()
{
HumanControlledEnemyFighter humanControlledEnemy1 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy1 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Goblin, 1);
humanControlledEnemy1.SetEnemy(enemy1);
HumanControlledEnemyFighter humanControlledEnemy2 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy2 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Goblin, 1);
humanControlledEnemy2.SetEnemy(enemy2);
HumanControlledEnemyFighter humanControlledEnemy3 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy3 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Fairy, 1);
humanControlledEnemy3.SetEnemy(enemy3);
HumanControlledEnemyFighter humanControlledEnemy4 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy4 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Fairy, 1);
humanControlledEnemy4.SetEnemy(enemy4);
List <IFighter> fighters = new List <IFighter>
{
humanControlledEnemy1,
humanControlledEnemy2,
humanControlledEnemy3,
humanControlledEnemy4,
};
Team team = new Team(_menuManager, fighters);
for (var i = 0; i < 4; ++i)
{
IFighter fighter = team.Fighters[i];
char expectedChar = (char)('A' + (i % 2));
Assert.AreEqual($"{expectedChar}", fighter.AppendText);
}
}
public void Build(HumanControlledEnemyFighter owner, Team ownTeam, Team enemyTeam, List <TerrainInteractable> terrainInteractables)
{
Owner = owner;
_ownTeam = ownTeam;
_enemyTeam = enemyTeam;
_hasBeenBuilt = true;
EnemyFighter ownerAsEnemyFighter = owner.Fighter;
if (ownerAsEnemyFighter == null)
{
throw new ArgumentException("HumanControlledEnemyMenu should only be built with an instance of Enemy Fighter", nameof(owner));
}
MenuActions = ownerAsEnemyFighter.AvailableMoves.Select(
move => new MenuAction(move.Description, subMenu: _menuFactory.GetMenu(MenuType.ChooseTargetMenu, _input, _output), move: move))
.ToList();
foreach (var menuAction in MenuActions)
{
menuAction.SubMenu?.Build(owner, ownTeam, enemyTeam, terrainInteractables);
}
}
public static IFighter GetFighter(FighterType type,
int level,
string name = null,
MagicType magicType = MagicType.None,
FighterClass fighterClass = FighterClass.None,
IMenuFactory menuFactory = null)
{
IFighter ret;
switch (type)
{
case FighterType.Goblin:
ret = new Goblin(level, ChanceService);
break;
case FighterType.Golem: //high defense, low attack, low speed, low health
ret = new Golem(level, ChanceService);
break;
case FighterType.Ogre: //high attack, low speed, low defense
ret = new Ogre(level, ChanceService);
break;
case FighterType.Fairy: //high speed, high evade, low attack, low defense
ret = new Fairy(level, ChanceService);
break;
case FighterType.HumanControlledPlayer:
ret = new HumanFighter(name ?? "Player", level);
GodRelationshipManager?.InitializeForFighter((HumanFighter)ret);
break;
case FighterType.HumanControlledEnemy:
ret = new HumanControlledEnemyFighter(name ?? "Player", Input, Output, menuFactory ?? Globals.MenuFactory);
break;
case FighterType.MegaChicken:
ret = new MegaChicken(level, ChanceService);
break;
case FighterType.Egg:
if (magicType == MagicType.None)
{
int magicIndex = ChanceService.WhichEventOccurs(Globals.EggMagicTypes.Length);
magicType = Globals.EggMagicTypes[magicIndex];
}
ret = new Egg(magicType);
break;
case FighterType.DancerBoss:
ret = new DancerBoss(fighterClass, level, ChanceService);
break;
case FighterType.Zombie:
ret = new Zombie(level, ChanceService);
break;
case FighterType.Warrior:
ret = new Warrior(level, ChanceService);
break;
case FighterType.ShieldGuy:
ret = new ShieldGuy(level, ChanceService);
break;
case FighterType.Barbarian:
ret = new Barbarian(level, ChanceService);
break;
case FighterType.Shade:
ret = GetShade(level, name);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type,
"The specified type is invalid for FighterFactory to initialize!");
}
return(ret);
}
public void Constructor_CorrectlySetsDisplayNames_TeamComprisedOfMixOfNormalEnemiesAndHumanControlledEnemies()
{
HumanControlledEnemyFighter humanControlledEnemy1 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy1 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Goblin, 1);
humanControlledEnemy1.SetEnemy(enemy1);
HumanControlledEnemyFighter humanControlledEnemy2 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy2 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Goblin, 1);
humanControlledEnemy2.SetEnemy(enemy2);
HumanControlledEnemyFighter humanControlledEnemy3 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy3 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Fairy, 1);
humanControlledEnemy3.SetEnemy(enemy3);
HumanControlledEnemyFighter humanControlledEnemy4 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy4 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Fairy, 1);
humanControlledEnemy4.SetEnemy(enemy4);
HumanControlledEnemyFighter humanControlledEnemy5 = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
EnemyFighter enemy9 = (EnemyFighter)FighterFactory.GetFighter(FighterType.Warrior, 1);
humanControlledEnemy5.SetEnemy(enemy9);
IFighter enemy5 = FighterFactory.GetFighter(FighterType.Goblin, 1);
IFighter enemy6 = FighterFactory.GetFighter(FighterType.Goblin, 1);
IFighter enemy7 = FighterFactory.GetFighter(FighterType.Fairy, 1);
IFighter enemy8 = FighterFactory.GetFighter(FighterType.Fairy, 1);
IFighter enemy10 = FighterFactory.GetFighter(FighterType.Golem, 1);
List <IFighter> fighters = new List <IFighter>
{
humanControlledEnemy1,
humanControlledEnemy2,
enemy5,
enemy6,
humanControlledEnemy3,
humanControlledEnemy4,
enemy7,
enemy8,
humanControlledEnemy5,
enemy10
};
Team team = new Team(_menuManager, fighters);
IFighter fighter;
for (var i = 0; i < 8; ++i)
{
fighter = team.Fighters[i];
char expectedChar = (char)('A' + (i % 4));
Assert.AreEqual($"{expectedChar}", fighter.AppendText, $"i: {i}");
}
fighter = team.Fighters[8];
Assert.AreEqual("", fighter.AppendText);
fighter = team.Fighters[9];
Assert.AreEqual("", fighter.AppendText);
}
public Team GetTeam(MenuManager menuManager, IInput input, IOutput output, out BattleConfigurationSpecialFlag battleFlag)
{
List <IFighter> fighters = new List <IFighter>
{
null,
null,
null,
null,
null
};
bool continuer = true;
battleFlag = BattleConfigurationSpecialFlag.None;
ConfirmationMenu humanControlledTeamConfirmationMenu = new ConfirmationMenu(false, "Do you want this team to be human controlled?", input, output);
MenuSelection confirmationInput = humanControlledTeamConfirmationMenu.GetInput();
bool isHumanControlledTeam = confirmationInput.Description == "yes";
for (var i = 0; i < 5 && continuer;)
{
SelectEnemyFighterMenu menu = Menus[i];
MenuSelection menuSelection = menu.GetInput();
if (i > 0 && menuSelection.Description == "back")
{
--i;
}
else
{
SelectEnemyFighterMenuSelection selectEnemyMenuSelection =
menuSelection as SelectEnemyFighterMenuSelection;
if (selectEnemyMenuSelection == null)
{
throw new InvalidOperationException(
"SelectEnemyFighterMenu.GetInput() didn't return a SelectEnemyFighterMenuSelection");
}
FighterFactory.SetInput(input);
FighterFactory.SetOutput(output);
IFighter returnedEnemy = FighterFactory.GetFighter(selectEnemyMenuSelection.FighterType, selectEnemyMenuSelection.FighterLevel);
if (!(returnedEnemy is EnemyFighter))
{
throw new InvalidOperationException(
$"The selected FighterType {selectEnemyMenuSelection.FighterType} cannot be cast to an EnemyFighter");
}
EnemyFighter enemy = (EnemyFighter)returnedEnemy;
IFighter fighterToAdd;
if (isHumanControlledTeam)
{
HumanControlledEnemyFighter humanControlledEnemy = (HumanControlledEnemyFighter)FighterFactory.GetFighter(FighterType.HumanControlledEnemy, 1);
humanControlledEnemy.SetEnemy(enemy);
fighterToAdd = humanControlledEnemy;
}
else
{
fighterToAdd = enemy;
}
fighters[i] = fighterToAdd;
if (selectEnemyMenuSelection.SpecialFlag != BattleConfigurationSpecialFlag.None &&
battleFlag == BattleConfigurationSpecialFlag.None)
{
battleFlag = selectEnemyMenuSelection.SpecialFlag;
}
if (i < 4)
{
ConfirmationMenu addAnotherFighrerConfirmationMenu = new ConfirmationMenu(false, "Do you want to add another fighter?", input, output);
confirmationInput = addAnotherFighrerConfirmationMenu.GetInput();
if (confirmationInput.Description == "no")
{
continuer = false;
}
}
++i;
}
}
fighters = fighters.Where(f => f != null).ToList();
Team ret = new Team(menuManager, fighters);
return(ret);
}
/// <summary>
/// A helper method to be called to ensure all Enemy
/// </summary>
public void SetupDisplayNames()
{
//TODO: have some way to check if an enemy has the "default" name. If there's a goblin named Eurdar the Wise, we don't want them to become Eurdar the Wise A
List <EnemyFighter> enemies = GetEnemyFighters().ToList();
//List<HumanControlledEnemyFighter> humanControlledEnemies = enemies.OfType<HumanControlledEnemyFighter>().ToList();
//
//IEnumerable<IGrouping<Type, EnemyFighter>> groupedEnemies = humanControlledEnemies.GroupBy(e => e.Fighter.GetType());
//
//enemies = enemies.Except(humanControlledEnemies).ToList();
//
////names only need to be set for enemies for which there are multiple types
//groupedEnemies = groupedEnemies.Concat(enemies.GroupBy(e => e.GetType()));
//
//groupedEnemies = groupedEnemies.Where(g => g.Count() > 1);
//IEnumerable<IGrouping<Type, EnemyFighter>> groupedEnemies = enemies.GroupBy(e =>
IEnumerable <IGrouping <Tuple <Type, MagicType>, EnemyFighter> > groupedEnemies = enemies.GroupBy(e =>
{
Type type;
MagicType magicType;
HumanControlledEnemyFighter humanControlled = e as HumanControlledEnemyFighter;
if (humanControlled != null)
{
EnemyFighter fighter = humanControlled.Fighter;
magicType = GetFighterMagicType(fighter);
type = fighter.GetType();
}
else
{
type = e.GetType();
magicType = GetFighterMagicType(e);
}
return(new Tuple <Type, MagicType>(type, magicType));
}).Where(g => g.Count() > 1);
foreach (IGrouping <Tuple <Type, MagicType>, EnemyFighter> group in groupedEnemies)
{
int i = 0;
foreach (EnemyFighter enemy in group)
{
string appendText;
if (i < 26)
{
appendText = $"{(char)('A' + i)}";
}
else
{
int firstIndex = (i / 26) - 1;
int secondIndex = i % 26;
char firstChar = (char)('A' + firstIndex);
char secondChar = (char)('A' + secondIndex);
appendText = $"{firstChar}{secondChar}";
}
enemy.SetAppendText(appendText);
++i;
}
}
}
