public void GetGroupingMethod_ReturnsSingleton()
{
//arrange
List <Region> regions = _regionFactory.GetRegions(EnumHelperMethods.GetAllValuesForEnum <WorldRegion>()).ToList();
_mapManager.GetRegionalMap(regions.ToArray());
Region desertRegion = regions.First(r => r.AreaId == WorldRegion.Desert);
_mapManager.GetSubRegionalMap(WorldRegion.Desert, desertRegion.SubRegions);
int regionalGroupingId = Globals.GroupingKeys.MainRegionalMapGroupingId;
int groupingId = Globals.GroupingKeys.FirstDesertGroupingId;
MapGrouping <SubRegion, WorldSubRegion> originalSubRegionalGrouping = _mapManager.GetGrouping <SubRegion, WorldSubRegion>(groupingId);
originalSubRegionalGrouping.Lock(sr => sr.AreaId != WorldSubRegion.Oasis);
MapGrouping <Region, WorldRegion> originalRegionalGrouping = _mapManager.GetGrouping <Region, WorldRegion>(regionalGroupingId);
originalRegionalGrouping.Lock(sr => sr.AreaId != WorldRegion.Casino);
//act
MapGrouping <SubRegion, WorldSubRegion> secondSubRegionalGrouping = _mapManager.GetGrouping <SubRegion, WorldSubRegion>(groupingId);
MapGrouping <Region, WorldRegion> secondRegionalGrouping = _mapManager.GetGrouping <Region, WorldRegion>(regionalGroupingId);
//Assert
Assert.AreEqual(1, secondSubRegionalGrouping.GetAvaialableAreas().Count());
Assert.AreEqual(1, secondRegionalGrouping.GetAvaialableAreas().Count());
}
/// <summary>
/// Sets up the Region maps and groupings for the PickNextArea tests
/// </summary>
/// <param name="firstGrouping"></param>
/// <param name="secondGrouping"></param>
private void PickNextArea_GroupingSetup_DesertGroupings(out MapGrouping <SubRegion, WorldSubRegion> firstGrouping,
out MapGrouping <SubRegion, WorldSubRegion> secondGrouping)
{
Region desertRegion;
PickNextArea_GroupingSetup_DesertGroupings(out firstGrouping, out secondGrouping, out desertRegion);
}
public TArea PickNextArea <TArea, TAreaId>(MapGrouping <TArea, TAreaId> grouping, Team advancingTeam) where TArea : Area <TAreaId>
{
TArea ret = _groupingChoiceIndex == -1
? _realDecisionManager.PickNextArea <TArea, TAreaId>(grouping, advancingTeam)
: grouping.GetAvaialableAreas().ToList()[_groupingChoiceIndex];
return(ret);
}
/// <summary>
/// Sets up the Region maps and groupings for the PickNextArea tests
/// </summary>
/// <param name="firstGrouping"></param>
/// <param name="secondGrouping"></param>
/// <param name="desertRegion"></param>
private void PickNextArea_GroupingSetup_DesertGroupings(out MapGrouping <SubRegion, WorldSubRegion> firstGrouping,
out MapGrouping <SubRegion, WorldSubRegion> secondGrouping, out Region desertRegion)
{
IRegionFactory regionFactory = new RegionFactory(_decisionManager);
desertRegion = regionFactory.GetRegion(WorldRegion.Desert);
MapManager mapManager = new MapManager(Globals.GroupingKeys);
AreaMap <SubRegion, WorldSubRegion> desertMap = mapManager.GetSubRegionalMap(WorldRegion.Desert, desertRegion.SubRegions);
firstGrouping = desertMap.MapPaths.First(p => p.From.AreaId == WorldSubRegion.DesertIntro).To;
secondGrouping = desertMap.MapPaths.First(p => p.From.AreaId == WorldSubRegion.DesertCrypt).To;
}
private void PickNextArea_GroupingSetup_RegionalGroupings(out MapGrouping <Region, WorldRegion> grouping, bool castleUnlocked = false)
{
IRegionFactory regionFactory = new RegionFactory(_decisionManager);
IEnumerable <Region> regions = regionFactory.GetRegions(EnumHelperMethods.GetAllValuesForEnum <WorldRegion>());
MapManager mapManager = new MapManager(Globals.GroupingKeys);
AreaMap <Region, WorldRegion> regionalMap = mapManager.GetRegionalMap(regions.ToArray());
grouping = regionalMap.MapPaths.First(p => p.From.AreaId == WorldRegion.Fields).To;
if (castleUnlocked)
{
grouping.Unlock(r => r.AreaId == WorldRegion.DarkCastle);
}
}
public void UnlockRegionMethod_CorrectlyUnlocksArea()
{
IEnumerable <WorldRegion> allRegionEnums = EnumHelperMethods.GetAllValuesForEnum <WorldRegion>();
IEnumerable <Region> allRegions = _regionFactory.GetRegions(allRegionEnums);
AreaMap <Region, WorldRegion> regionalMap = _mapManager.GetRegionalMap(allRegions.ToArray());
MapGrouping <Region, WorldRegion> destinationGrouping =
regionalMap.MapPaths.First(mp => mp.From.AreaId == WorldRegion.Fields).To;
MapGroupingItem <Region, WorldRegion> darkCastleGroupingItem =
destinationGrouping.Values.Single(gi => gi.Item.AreaId == WorldRegion.DarkCastle);
Assert.True(darkCastleGroupingItem.IsLocked);
_mapManager.UnlockRegion(destinationGrouping.GroupingId, WorldRegion.DarkCastle);
Assert.False(darkCastleGroupingItem.IsLocked);
}
private Region ChooseNextRegion(MapGrouping <Region, WorldRegion> grouping)
{
IEnumerable <MenuAction> menuActions =
grouping.GetAvaialableAreas().Select(r => new TypedMenuAction <WorldRegion>(r.AreaId, r.AreaId.ToString(), isHidden: r.AreaId == WorldRegion.Casino || r.AreaId == WorldRegion.CrystalCaves)).ToList();
IMenu menu = _menuFactory.GetMenu(MenuType.NonSpecificMenu, _input, _output, allowHelp: false, allowBack: false, allowStatus: false,
prompt: "Which region would you like to visit next?", errorText: Globals.GenericErrorMessage,
menuActions: menuActions.ToList());
menu.Build(null, null, null, null);
TypedMenuSelection <WorldRegion> menuSelection = menu.GetInput() as TypedMenuSelection <WorldRegion>;
if (menuSelection == null)
{
throw new InvalidCastException("DecisionManager.ChooseNextRegion() should have generated menus that would return a TypedMenuSeleciton<WorldRegion> but it did not!");
}
return(grouping.GetAvaialableAreas().First(sr => sr.AreaId == menuSelection.Item));
}
public T PickNextArea <T, TAreaId>(MapGrouping <T, TAreaId> grouping, Team advancingTeam) where T : Area <TAreaId>
{
T ret;
if (grouping.GroupingId == Globals.GroupingKeys.FirstDesertGroupingId)
{
ret = ChooseDesertSubRegions(advancingTeam, grouping as MapGrouping <SubRegion, WorldSubRegion>) as T;
}
else if (grouping.GroupingId == Globals.GroupingKeys.MainRegionalMapGroupingId)
{
ret = ChooseNextRegion(grouping as MapGrouping <Region, WorldRegion>) as T;
}
else
{
ret = _chanceService.WhichEventOccurs(grouping.GetAvaialableAreas());
}
return(ret);
}
public void UnlockSubRegionMethod_CorrectlyUnlocksArea([Range(0, 3)] int regionToUnlockIndex)
{
Region desertRegion = _regionFactory.GetRegion(WorldRegion.Desert);
AreaMap <SubRegion, WorldSubRegion> subregionalMap = _mapManager.GetSubRegionalMap(WorldRegion.Desert, desertRegion.SubRegions);
MapPath <SubRegion, WorldSubRegion> pathFromDesertIntro = subregionalMap.MapPaths.First(path => path.From.AreaId == WorldSubRegion.DesertIntro);
MapGrouping <SubRegion, WorldSubRegion> destinationGrouping = pathFromDesertIntro.To;
Assert.True(destinationGrouping.Values.TrueForAll(groupingItem => !groupingItem.IsLocked));
MapGroupingItem <SubRegion, WorldSubRegion> regionToUnlockGroupingItem = destinationGrouping.Values[regionToUnlockIndex];
WorldSubRegion unlockedRegionEnum = regionToUnlockGroupingItem.Item.AreaId;
_mapManager.UnlockSubRegion(destinationGrouping.GroupingId, unlockedRegionEnum);
Assert.False(regionToUnlockGroupingItem.IsLocked);
List <MapGroupingItem <SubRegion, WorldSubRegion> > stillLockedRegions =
destinationGrouping.Values.Where(dgi => dgi.Item.AreaId != unlockedRegionEnum).ToList();
Assert.True(stillLockedRegions.TrueForAll(groupingItem => !groupingItem.IsLocked));
}
private SubRegion ChooseDesertSubRegions(Team advancingTeam, MapGrouping <SubRegion, WorldSubRegion> grouping)
{
SubRegion ret;
if (_groupingChoicesDictionary.ContainsKey(Globals.GroupingKeys.FirstDesertGroupingId))
{
WorldSubRegion selectedRegion = _groupingChoicesDictionary[Globals.GroupingKeys.FirstDesertGroupingId];
ret = grouping.GetAvaialableAreas().First(sr => sr.AreaId == selectedRegion);
}
else
{
HumanFighter mazeSolver =
advancingTeam.Fighters.OfType <HumanFighter>()
.First(f => f.PersonalityFlags.Contains(PersonalityFlag.MazeSolver));
HumanFighter notMazeSolver =
advancingTeam.Fighters.OfType <HumanFighter>()
.First(f => !f.PersonalityFlags.Contains(PersonalityFlag.MazeSolver));
IEnumerable <WorldSubRegion> firstGroupingSubRegions =
WorldSubRegions.GetSubRegionsByGroupingId(Globals.GroupingKeys.FirstDesertGroupingId);
IEnumerable <MenuAction> firstGroupingMenuActions =
firstGroupingSubRegions.Select(
sr => new TypedMenuAction <WorldSubRegion>(sr, GetDisplayTextForMenu(sr), GetCommandTextForMenu(sr), isHidden: sr == WorldSubRegion.Oasis));
IMenu firstGroupingMenu = _menuFactory.GetMenu(MenuType.NonSpecificMenu, _input, _output,
allowHelp: false, allowBack: false, allowStatus: false,
prompt:
$"{Globals.OwnerReplaceText}: We should focus on forming a strategy for our next battle, we should...",
errorText: Globals.GenericErrorMessage,
menuActions: firstGroupingMenuActions.ToList(), chanceService: _chanceService, shuffleOptions: true);
firstGroupingMenu.Build(mazeSolver, null, null, null);
TypedMenuSelection <WorldSubRegion> firstMenuSelection =
firstGroupingMenu.GetInput() as TypedMenuSelection <WorldSubRegion>;
if (firstMenuSelection == null)
{
throw new InvalidCastException(
"DecisionManager.ChooseDesertSubRegions() should have generated menus that would return a TypedMenuSeleciton<WorldSubRegion> but it did not!");
}
WorldSubRegion firstSelectedSubRegionEnum = firstMenuSelection.Item;
grouping.Lock(sr => sr.AreaId != firstSelectedSubRegionEnum);
_relationshipManager.UpdateRelationship(mazeSolver,
WorldSubRegions.GetGodEnumBySubRegion(firstSelectedSubRegionEnum), 1);
_groupingChoicesDictionary.Add(Globals.GroupingKeys.FirstDesertGroupingId, firstSelectedSubRegionEnum);
IEnumerable <WorldSubRegion> secondGroupingSubRegions =
WorldSubRegions.GetSubRegionsByGroupingId(Globals.GroupingKeys.SecondDesertGroupingId);
IEnumerable <MenuAction> secondGroupingMenuActions =
secondGroupingSubRegions.Select(
sr => new TypedMenuAction <WorldSubRegion>(sr, GetDisplayTextForMenu(sr), GetCommandTextForMenu(sr), isHidden: sr == WorldSubRegion.BeastTemple));
IMenu secondGroupingMenu = _menuFactory.GetMenu(MenuType.NonSpecificMenu, _input, _output,
allowHelp: false, allowBack: false, allowStatus: false,
prompt: $"{Globals.OwnerReplaceText}: I was thinking about how we could improve, what if we...",
errorText: Globals.GenericErrorMessage, menuActions: secondGroupingMenuActions.ToList(),
chanceService: _chanceService, shuffleOptions: true);
secondGroupingMenu.Build(notMazeSolver, null, null, null);
TypedMenuSelection <WorldSubRegion> secondMenuSelection =
secondGroupingMenu.GetInput() as TypedMenuSelection <WorldSubRegion>;
if (secondMenuSelection == null)
{
throw new InvalidCastException(
"DecisionManager.ChooseDesertSubRegions() should have generated menus that would return a TypedMenuSeleciton<WorldSubRegion> but it did not!");
}
WorldSubRegion secondSelectedSubRegionEnum = secondMenuSelection.Item;
grouping.Parent.MapPaths.First(path => path.To.GroupingId == Globals.GroupingKeys.SecondDesertGroupingId)
.To.Lock(sr => sr.AreaId != secondSelectedSubRegionEnum);
_relationshipManager.UpdateRelationship(notMazeSolver,
WorldSubRegions.GetGodEnumBySubRegion(secondSelectedSubRegionEnum), 1);
_groupingChoicesDictionary.Add(Globals.GroupingKeys.SecondDesertGroupingId, secondSelectedSubRegionEnum);
ret = grouping.GetAvaialableAreas().First(sr => sr.AreaId == firstSelectedSubRegionEnum);
}
return(ret);
}
public MapPath(TArea from)
{
From = from;
//TODO: how to get correct groupingID?
To = new MapGrouping <TArea, TAreaId>(0);
}
public MapPath(TArea from, MapGrouping <TArea, TAreaId> to)
{
From = from;
To = to;
}
public void CorrectlyMovesToNextSubRegion_MultipleNextSubRegions([Values(1, 2)] int selectedArea)
{
const int groupingId = 10;
_decisionManager.SetGroupingChoice(selectedArea - 1);
TeamConfiguration firstBossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, MagicType.Fire));
SubRegion firstSubRegion = new SubRegion(WorldSubRegion.Fields, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(firstBossConfiguration));
FighterType bossA = FighterType.Barbarian;
WorldSubRegion regionA = WorldSubRegion.DesertCrypt;
TeamConfiguration secondBossConfiguration = new TeamConfiguration(new EnemyConfiguration(bossA, 1));
SubRegion subRegionA = new SubRegion(regionA, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(secondBossConfiguration));
FighterType bossB = FighterType.MegaChicken;
WorldSubRegion regionB = WorldSubRegion.Oasis;
TeamConfiguration thirdBossConfiguration = new TeamConfiguration(new EnemyConfiguration(bossB, 1));
SubRegion subRegionB = new SubRegion(regionB, 0, new ChanceEvent <int> [0], new FighterType[0], new BattlefieldConfiguration(thirdBossConfiguration));
SubRegion[] subRegions = { firstSubRegion, subRegionA, subRegionB };
Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);
_regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);
AreaMap <Region, WorldRegion> regionMap = new AreaMap <Region, WorldRegion>(fakeFieldsRegion, new MapPath <Region, WorldRegion>(fakeFieldsRegion));
MapGrouping <SubRegion, WorldSubRegion> grouping = new MapGrouping <SubRegion, WorldSubRegion>(groupingId, subRegionA, subRegionB);
AreaMap <SubRegion, WorldSubRegion> subRegionMap = new AreaMap <SubRegion, WorldSubRegion>(firstSubRegion, new MapPath <SubRegion, WorldSubRegion>(firstSubRegion, grouping));
_mapManager.SetRegionalMap(regionMap);
_mapManager.SetSubRegionalMap(WorldRegion.Fields, subRegionMap);
_regionManager = GetRegionManager();
TestEnemyFighter target = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);
target.SetHealth(1, 0);
_humanFighter1.SetMove(_basicAttackMove, 1);
_humanFighter1.SetMove(_runawayMove, 1);
_humanFighter1.SetMoveTarget(target);
_humanFighter2.SetMove(_doNothingMove);
_chanceService.PushAttackHitsNotCrit();
_regionManager.Battle(_battleManager, _humanTeam);
List <Team> enemyTeams = _battleManager.GetAllEnemyTeams();
Assert.AreEqual(2, enemyTeams.Count);
IFighter secondBoss = enemyTeams[1].Fighters[0];
FighterType selectedBossType = selectedArea == 1 ? bossA : bossB;
WorldSubRegion selectedBossRegion = selectedArea == 1 ? regionA : regionB;
Assert.NotNull(secondBoss);
Assert.True(selectedBossType.IsCorrectType(secondBoss));
Assert.AreEqual(selectedBossRegion, subRegionMap.CurrentArea.AreaId);
}
public void CorrectlyMovesToNextSubRegion_TwoNextSubRegionsButOneIsLocked()
{
const MagicType firstBossEggType = MagicType.Fire;
const MagicType secondBossEggType = MagicType.Ice;
TeamConfiguration firstBossConfiguration =
new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, firstBossEggType));
SubRegion subRegionA = new SubRegion(WorldSubRegion.Fields, 0, new ChanceEvent <int> [0], new FighterType[0],
new BattlefieldConfiguration(firstBossConfiguration));
const string secondRegionIntro = "Who wants donuts?!?";
TeamConfiguration secondBossConfiguration =
new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1, secondBossEggType));
SubRegion subRegionB = new SubRegion(WorldSubRegion.DesertCrypt, 0, new ChanceEvent <int> [0],
new FighterType[0], new BattlefieldConfiguration(secondBossConfiguration), regionIntro: secondRegionIntro);
const string lockedRegionIntro = "watch me do a flip!";
TeamConfiguration lockedRegionConfiguration =
new TeamConfiguration(new EnemyConfiguration(FighterType.Goblin, 1));
SubRegion lockedSubRegion = new SubRegion(WorldSubRegion.AncientLibrary, 0, new ChanceEvent <int> [0],
new FighterType[0], new BattlefieldConfiguration(lockedRegionConfiguration), regionIntro: lockedRegionIntro);
SubRegion[] subRegions = { subRegionA, subRegionB, lockedSubRegion };
Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);
_regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);
AreaMap <Region, WorldRegion> regionMap = new AreaMap <Region, WorldRegion>(fakeFieldsRegion, new MapPath <Region, WorldRegion>(fakeFieldsRegion));
MapGrouping <SubRegion, WorldSubRegion> grouping = new MapGrouping <SubRegion, WorldSubRegion>(0, subRegionB, lockedSubRegion);
grouping.Lock(sr => sr.AreaId == WorldSubRegion.AncientLibrary);
AreaMap <SubRegion, WorldSubRegion> subRegionMap = new AreaMap <SubRegion, WorldSubRegion>(subRegionA, new MapPath <SubRegion, WorldSubRegion>(subRegionA, grouping));
_mapManager.SetRegionalMap(regionMap);
_mapManager.SetSubRegionalMap(WorldRegion.Fields, subRegionMap);
_regionManager = GetRegionManager();
TestEnemyFighter target = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);
target.SetHealth(1, 0);
_humanFighter1.SetMove(_basicAttackMove, 1);
_humanFighter1.SetMove(_runawayMove, 1);
_humanFighter1.SetMoveTarget(target);
_humanFighter2.SetMove(_doNothingMove);
_chanceService.PushAttackHitsNotCrit();
_regionManager.Battle(_battleManager, _humanTeam);
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.Null(outputs.FirstOrDefault(o => o.Message == lockedRegionIntro + "\n"));
List <Team> enemyTeams = _battleManager.GetAllEnemyTeams();
Assert.AreEqual(2, enemyTeams.Count);
Goblin lockedBoss = enemyTeams[1].Fighters[0] as Goblin;
Assert.Null(lockedBoss);
}
