private DungeonLevel GenRoomWithEnemies(int numEnemies)
{
var generator = Container.GetInstance <Dungeons.IDungeonGenerator>();
var info = new Roguelike.Generators.GenerationInfo();
info.NumberOfRooms = 1;
info.GenerateEnemies = false;
info.MinNodeSize = new Size(8, 8);
info.MaxNodeSize = info.MinNodeSize;
var level = generator.Generate(0, info);
Assert.Greater(level.GetTiles().Where(i => i.IsEmpty).Count(), 0);
int y = 2;
for (int i = 0; i < numEnemies; i++)
{
var en = SpawnEnemy();
var pt = new Point(2, y++);
var set = level.SetTile(en, pt);
Assert.True(set);
//en = SpawnEnemy();
//pt = new Point(2, 3);
//set = level.SetTile(en, pt);
//Assert.True(set);
}
return(level);
}
public void TestCustomInteriorGen()
{
var game = CreateGame(false);
Assert.Null(game.Hero);
Assert.AreEqual(game.Level, null);
game.LevelGenerator.CustomNodeCreator = (int nodeIndex, Dungeons.GenerationInfo gi) =>
{
//TODO typed CreateDungeonNodeInstance
var dungeon = game.LevelGenerator.CreateDungeonNodeInstance() as Roguelike.Generators.TileContainers.DungeonNode;
dungeon.Create(10, 10, gi);
var li = game.LevelGenerator.LevelIndex + 1;
dungeon.SetTileAtRandomPosition <Enemy>(li, Container);
dungeon.SetTileAtRandomPosition <Barrel>(li);
dungeon.SetTileAtRandomPosition <Barrel>(li);
return(dungeon);
};
var info = new Roguelike.Generators.GenerationInfo();
info.NumberOfRooms = 1;
info.MakeEmpty();
info.GenerateOuterWalls = false;
var level = game.LevelGenerator.Generate(0, info);
Assert.AreEqual(level.GetTiles <Wall>().Count, 0);
Assert.AreEqual(level.GetTiles <Enemy>().Count, 1);
Assert.AreEqual(level.GetTiles <Barrel>().Count, 2);
}
public void OneRoomOneSecret(int secretRoomIndex)
{
var game = CreateGame(false);
Assert.Null(game.Hero);
var info = new Roguelike.Generators.GenerationInfo();
info.NumberOfRooms = 2;
info.SecretRoomIndex = secretRoomIndex;
info.ChildIslandAllowed = false;
var level = game.LevelGenerator.Generate(0, info);
Assert.AreEqual(level.Parts.Count, 1);
level.Nodes[0].GetTiles().All(i => i.DungeonNodeIndex == 0);
var doors = level.Nodes[0].GetTiles<Door>();
Assert.AreEqual(doors.Count, 1);
if (secretRoomIndex == 1)
Assert.AreEqual(doors[0].DungeonNodeIndex, 0);
else
Assert.AreEqual(doors[0].DungeonNodeIndex, 1);
Assert.AreEqual(level.Nodes[secretRoomIndex].Secret, true);
level.Nodes[1].GetTiles().All(i => i.DungeonNodeIndex == 1);
doors = level.Nodes[1].GetTiles<Door>();
Assert.AreEqual(doors.Count, 0);
}
public TileContainers.GameLevel GenerateLevel(int levelIndex, Dungeons.GenerationInfo gi = null, bool canSetActive = true)
{
TileContainers.GameLevel level = null;
if (LevelGenerator != null)
{
if (LevelGenerator.MaxLevelIndex > 0 && levelIndex > LevelGenerator.MaxLevelIndex)
{
throw new Exception("levelIndex > LevelGenerator.MaxLevelIndex");
}
LevelGenerator.LevelIndex = levelIndex;
var generInfo = gi;
if (generInfo == null)
{
generInfo = new Generators.GenerationInfo();
//(generInfo as Roguelike.Generators.GenerationInfo).MaxLevelIndex = LevelGenerator.LevelIndex;
}
level = LevelGenerator.Generate(levelIndex, generInfo) as TileContainers.GameLevel;
var merch = this.Container.GetInstance <Merchant>();
level.SetTileAtRandomPosition(merch);
this.levels.Add(level);
}
if (canSetActive && levelIndex == 0)
{
GameManager.SetContext(level, AddHero(level), GameContextSwitchKind.NewGame);
}
return(level);
}
public void TestPowerIncrease()
{
var game = CreateGame();
Enemy lastPlain = null;
Enemy lastChemp = null;
Enemy lastBoss = null;
var hero = game.Level.GetTiles <Hero>().SingleOrDefault();
EntityStatKind[] statKinds = new[] { EntityStatKind.MeleeAttack, EntityStatKind.Defense, EntityStatKind.Magic };
float lastDamageFromPlain = 0;
float lastDamageFromChemp = 0;
float lastDamageFromBoss = 0;
var gi = new Roguelike.Generators.GenerationInfo();
for (var levelIndex = 0; levelIndex < gi.MaxLevelIndex; levelIndex++)
{
var enemies = AllEnemies;
Assert.Greater(enemies.Count, 2);
var boss = enemies.Where(i => i.PowerKind == EnemyPowerKind.Plain).First();
boss.SetBoss();
Assert.AreEqual(boss.PowerKind, EnemyPowerKind.Boss);
var chemp = enemies.Where(i => i.PowerKind == EnemyPowerKind.Champion).First();
var plain = enemies.Where(i => i.PowerKind == EnemyPowerKind.Plain).First();
if (levelIndex > 0)
{
Assert.Greater(plain.Level, lastPlain.Level);
Assert.Greater(chemp.Level, lastChemp.Level);
Assert.Greater(boss.Level, lastBoss.Level);
foreach (var esk in statKinds)
{
Assert.Greater(plain.Stats.GetStat(esk).Value.TotalValue, lastPlain.Stats.GetStat(esk).Value.TotalValue);
Assert.Greater(chemp.Stats.GetStat(esk).Value.TotalValue, lastChemp.Stats.GetStat(esk).Value.TotalValue);
Assert.Greater(boss.Stats.GetStat(esk).Value.TotalValue, lastBoss.Stats.GetStat(esk).Value.TotalValue);
}
}
float diffPlain = CheckHit(hero, lastDamageFromPlain, plain);
float diffChemp = CheckHit(hero, lastDamageFromChemp, chemp);
float diffBoss = CheckHit(hero, lastDamageFromBoss, boss);
lastDamageFromPlain = diffPlain;
lastDamageFromChemp = diffChemp;
lastDamageFromBoss = diffBoss;
lastPlain = plain;
lastChemp = chemp;
lastBoss = boss;
GoDown();
}
}
public void TestOneRoom()
{
var game = CreateGame(false);
Assert.Null(game.Hero);
var info = new Roguelike.Generators.GenerationInfo();
info.NumberOfRooms = 1;
info.ChildIslandAllowed = false;
var level = game.LevelGenerator.Generate(0, info);
Assert.AreEqual(level.Parts.Count, 1);
level.Nodes[0].GetTiles().All(i => i.DungeonNodeIndex == 0);
Assert.AreEqual(level.Nodes[0].GetTiles<Door>().Count, 0);
}
public void TestTwoRoomsOneSecret(int secretRooIndex)
{
var game = CreateGame(false);
Assert.Null(game.Hero);
var info = new Roguelike.Generators.GenerationInfo();
info.NumberOfRooms = 3;
info.SecretRoomIndex = secretRooIndex;
info.ChildIslandAllowed = false;
var level = game.LevelGenerator.Generate(0, info);
Assert.AreEqual(level.Parts.Count, 1);
AssertNodeIndex(level, 0);
for (var i = 0; i < level.Nodes.Count; i++)
{
Assert.AreEqual(level.Nodes[i].Secret, secretRooIndex == i);
}
var doors = level.Nodes[0].GetTiles<Door>();
if (secretRooIndex == 0)
Assert.AreEqual(doors.Count, 1);
else
Assert.Greater(doors.Count, 4);
if (secretRooIndex == 0)
Assert.AreEqual(doors[0].DungeonNodeIndex, 1);
else
Assert.AreEqual(doors[0].DungeonNodeIndex, 0);
AssertNodeIndex(level, 1);
doors = level.Nodes[1].GetTiles<Door>();
if (secretRooIndex == 0)
Assert.Greater(doors.Count, 4);
else if (secretRooIndex == 1)
Assert.AreEqual(doors.Count, 0);
else if (secretRooIndex == 2)
Assert.AreEqual(doors.Count, 1);
AssertNodeIndex(level, 2);
doors = level.Nodes[2].GetTiles<Door>();
Assert.AreEqual(doors.Count, 0);
}
public void FixedRoomSize()
{
//game can have 1-n levels (sub-dungeons)
var game = CreateGame(false);
Assert.Null(game.Hero);
var gi = new Roguelike.Generators.GenerationInfo();
gi.NumberOfRooms = 1;//tmp
gi.MaxNodeSize = new System.Drawing.Size(11, 11);
gi.MinNodeSize = gi.MaxNodeSize;
gi.PreventSecretRoomGeneration = true;
var level0 = game.GenerateLevel(0, gi);
Assert.NotNull(level0);
Assert.AreEqual(level0.GeneratorNodes.Count, 1);
Assert.AreEqual(level0.GeneratorNodes[0].Width, gi.MaxNodeSize.Width);
Assert.AreEqual(level0.GeneratorNodes[0].Height, gi.MaxNodeSize.Height);
}
public void TestLootRevealFlagBasic()
{
Log("TestLootRevealFlagBasic start");
var info = new Roguelike.Generators.GenerationInfo();
info.NumberOfRooms = 1;
info.MinNodeSize = new Size(15, 15);
info.MaxNodeSize = new Size(30, 30);
info.ForceChildIslandInterior = true;
info.PreventSecretRoomGeneration = true;
info.ForcedNumberOfEnemiesInRoom = 10;
var game = CreateGame(gi: info);
var level = game.Level;
Assert.GreaterOrEqual(level.Width, info.MinNodeSize.Width);
Assert.GreaterOrEqual(level.Height, info.MinNodeSize.Height);
Assert.AreEqual(level.Nodes.Count, 1);
var normalRoom = level.Nodes[0];
Assert.AreEqual(normalRoom.ChildIslands.Count, 1);
Assert.True(normalRoom.Revealed);
var island = normalRoom.ChildIslands[0];
Assert.False(island.Revealed);
Assert.Greater(level.GetTiles().Where(i => i.DungeonNodeIndex == island.NodeIndex).Count(), 0);
var en = level.GetTiles().Where(i => i is Enemy).ToList();
//var enNormal = normalRoom.GetTiles<Enemy>();
//var enIsland = normalRoom.GetTiles<Enemy>();
//Assert.AreEqual(en.Count, enNormal.Count + enIsland.Count);
var normalRoomEnemies = en.Where(i => i.DungeonNodeIndex == normalRoom.NodeIndex).ToList();
var islandRoomEnemies = en.Where(i => i.DungeonNodeIndex == island.NodeIndex).ToList();
Assert.AreEqual(en.Count, normalRoomEnemies.Count + islandRoomEnemies.Count);
Assert.Greater(normalRoomEnemies.Count, 0);
Assert.Greater(islandRoomEnemies.Count, 0);
Log("TestLootRevealFlagBasic end");
}
public void TestLootRevealFlagAdv()
{
var info = new Roguelike.Generators.GenerationInfo();
info.NumberOfRooms = 2;
info.MinNodeSize = new Size(15, 15);
info.MaxNodeSize = new Size(30, 30);
info.ForceChildIslandInterior = true;
info.PreventSecretRoomGeneration = true;
var game = CreateGame(gi: info);
var level = game.Level;
Assert.GreaterOrEqual(level.Width, info.MinNodeSize.Width);
Assert.GreaterOrEqual(level.Height, info.MinNodeSize.Height);
Assert.AreEqual(level.Nodes.Count, 2);
Assert.AreEqual(level.Nodes[0].ChildIslands.Count, 1);
Assert.AreEqual(level.Nodes[1].ChildIslands.Count, 1);
Assert.True(level.Nodes[0].Revealed);
Assert.False(level.Nodes[1].Revealed);
var chidIsl1 = level.Nodes[0].ChildIslands[0];
Assert.False(chidIsl1.Revealed);
var chidIsl2 = level.Nodes[1].ChildIslands[0];
Assert.False(chidIsl2.Revealed);
Assert.Greater(level.GetTiles().Where(i => i.DungeonNodeIndex == chidIsl1.NodeIndex).Count(), 1);
Assert.Greater(level.GetTiles().Where(i => i.DungeonNodeIndex == chidIsl2.NodeIndex).Count(), 1);
//Assert.AreEqual(level.Height, info.MaxNodeSize);
//var en = level.GetTiles().Where(i => i is Enemy).ToList();
//var lootGrouped = level.GetTiles().Where(i=> i is Loot).ToList().GroupBy(i=>i.DungeonNodeIndex).ToList();
//var zeroIndexCount = tiles.Where(i => i.DungeonNodeIndex == 0).Count();
//var nonZero = level.GetTiles().Where(i => i.DungeonNodeIndex != 0).ToList();
//Assert.AreEqual(zeroIndexCount, tiles.Count);
}
public void ChempionsCount()
{
//game can have 1-n levels (sub-dungeons)
var game = CreateGame(false);
Assert.Null(game.Hero);
var gi = new Roguelike.Generators.GenerationInfo();
Assert.Greater(gi.NumberOfRooms, 3);
Assert.Greater(gi.ForcedNumberOfEnemiesInRoom, 2);
//gi.NumberOfRooms = 5;
//gi.ForcedNumberOfEnemiesInRoom = 4;
var level_0 = game.GenerateLevel(0, gi);
Assert.AreEqual(level_0.Nodes.Count, 6);
var enemies = level_0.GetTiles <Enemy>();
Assert.Greater(enemies.Count, 5);
var chemps = enemies.Where(i => i.PowerKind == EnemyPowerKind.Champion).Count();
Assert.Greater(chemps, 1);
Assert.Less(chemps, gi.NumberOfRooms);
}
