public override SpawnList <MobSpawn> GetPossibleSpawns()
{
SpawnList <MobSpawn> spawnerList = new SpawnList <MobSpawn>();
for (int ii = 0; ii < Spawns.Count; ii++)
{
spawnerList.Add(Spawns.GetSpawn(ii).Spawn, Spawns.GetSpawnRate(ii));
}
return(spawnerList);
}
public void RoomSpawnStepSpawnRandInCandRoomsChangeChance()
{
// proves that the probability diminishes with each success
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
// choose freetile count
testRand.SetupSequence(p => p.Next(12)).Returns(0);
testRand.SetupSequence(p => p.Next(10)).Returns(2);
testRand.SetupSequence(p => p.Next(8)).Returns(0);
testRand.SetupSequence(p => p.Next(7)).Returns(0);
Mock <IPlaceableRoomTestContext> mockMap = new Mock <IPlaceableRoomTestContext>(MockBehavior.Strict);
mockMap.SetupGet(p => p.Rand).Returns(testRand.Object);
SpawnList <RoomHallIndex> spawningRooms = new SpawnList <RoomHallIndex>
{
{ new RoomHallIndex(0, false), 4 },
{ new RoomHallIndex(1, false), 4 },
{ new RoomHallIndex(2, false), 4 },
};
// get a list of spawns
List <SpawnableChar> spawns = new List <SpawnableChar>();
for (int ii = 0; ii < 5; ii++)
{
spawns.Add(new SpawnableChar('a'));
}
var roomSpawner = new Mock <RandomRoomSpawnStep <IPlaceableRoomTestContext, SpawnableChar> >(null, false)
{
CallBase = true
};
roomSpawner.Setup(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(0, false), new SpawnableChar('a'))).Returns(true);
roomSpawner.Setup(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(1, false), new SpawnableChar('a'))).Returns(true);
roomSpawner.Setup(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(2, false), new SpawnableChar('a'))).Returns(true);
roomSpawner.Object.SpawnRandInCandRooms(mockMap.Object, spawningRooms, spawns, 50);
roomSpawner.Verify(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(0, false), new SpawnableChar('a')), Times.Exactly(4));
roomSpawner.Verify(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(1, false), new SpawnableChar('a')), Times.Exactly(1));
roomSpawner.Verify(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(2, false), new SpawnableChar('a')), Times.Exactly(0));
Assert.That(spawningRooms.Count, Is.EqualTo(3));
Assert.That(spawningRooms.GetSpawnRate(0), Is.EqualTo(1));
Assert.That(spawningRooms.GetSpawnRate(1), Is.EqualTo(2));
Assert.That(spawningRooms.GetSpawnRate(2), Is.EqualTo(4));
Assert.That(spawns.Count, Is.EqualTo(0));
}
public override void Apply(T map)
{
for (int ii = 0; ii < Spawns.Count; ii++)
{
map.ItemSpawns.Add(new InvItem(Spawns.GetSpawn(ii)), Spawns.GetSpawnRate(ii));
}
}
public override void Apply(T map)
{
for (int ii = 0; ii < Spawns.Count; ii++)
{
map.TeamSpawns.Add(Spawns.GetSpawn(ii).Clone(), Spawns.GetSpawnRate(ii));//Clone Use Case; convert to Instantiate?
}
}
private void addToQueue(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue)
{
int id = zoneContext.CurrentID;
IMonsterHouseBaseStep monsterHouseStep = HouseStepSpawns.Pick(context.Rand).CreateNew();
SpawnList <MapItem> itemListSlice = Items.GetSpawnList(id);
for (int jj = 0; jj < itemListSlice.Count; jj++)
{
monsterHouseStep.Items.Add(new MapItem(itemListSlice.GetSpawn(jj)), itemListSlice.GetSpawnRate(jj));
}
SpawnList <ItemTheme> itemThemeListSlice = ItemThemes.GetSpawnList(id);
for (int jj = 0; jj < itemThemeListSlice.Count; jj++)
{
monsterHouseStep.ItemThemes.Add(itemThemeListSlice.GetSpawn(jj).Copy(), itemThemeListSlice.GetSpawnRate(jj));
}
SpawnList <MobSpawn> mobListSlice = Mobs.GetSpawnList(id);
for (int jj = 0; jj < mobListSlice.Count; jj++)
{
MobSpawn newSpawn = mobListSlice.GetSpawn(jj).Copy();
monsterHouseStep.Mobs.Add(newSpawn, mobListSlice.GetSpawnRate(jj));
}
SpawnList <MobTheme> mobThemeListSlice = MobThemes.GetSpawnList(id);
for (int jj = 0; jj < mobThemeListSlice.Count; jj++)
{
monsterHouseStep.MobThemes.Add(mobThemeListSlice.GetSpawn(jj).Copy(), mobThemeListSlice.GetSpawnRate(jj));
}
queue.Enqueue(Priority, monsterHouseStep);
}
public override void Apply(T map)
{
for (int ii = 0; ii < Spawns.Count; ii++)
{
map.TileSpawns.Add(Spawns.GetSpawn(ii), Spawns.GetSpawnRate(ii));
}
}
public void SpawnRangeListSpawnList(int level, int count, int index, string result, int rate)
{
SpawnList <string> spawnList = this.spawnRangeList.GetSpawnList(level);
Assert.That(spawnList.Count, Is.EqualTo(count));
if (count > 0)
{
Assert.That(spawnList.GetSpawn(index), Is.EqualTo(result));
Assert.That(spawnList.GetSpawnRate(index), Is.EqualTo(rate));
}
}
public override List <MapItem> GenerateItems(BaseMapGenContext map, SpawnList <MapItem> specialItems)
{
int itemCount = Amount.Pick(map.Rand);
List <MapItem> spawners = new List <MapItem>();
SpawnList <MapItem> subList = new SpawnList <MapItem>();
if (UseSpecialItems)
{
for (int ii = 0; ii < specialItems.Count; ii++)
{
MapItem spawn = specialItems.GetSpawn(ii);
if (!spawn.IsMoney)
{
ItemEntrySummary itemEntry = DataManager.Instance.DataIndices[DataManager.DataType.Item].Entries[spawn.Value] as ItemEntrySummary;
if (itemEntry.UsageType == UseType)
{
subList.Add(spawn, specialItems.GetSpawnRate(ii));
}
}
}
}
if (UseMapItems)
{
foreach (string key in map.ItemSpawns.Spawns.GetKeys())
{
SpawnList <InvItem> spawns = map.ItemSpawns.Spawns.GetSpawn(key);
for (int ii = 0; ii < spawns.Count; ii++)
{
//TODO: spawn rate is somewhat distorted here
InvItem spawn = spawns.GetSpawn(ii);
ItemEntrySummary itemEntry = DataManager.Instance.DataIndices[DataManager.DataType.Item].Entries[spawn.ID] as ItemEntrySummary;
if (itemEntry.UsageType == UseType)
{
subList.Add(new MapItem(spawn), spawns.GetSpawnRate(ii));
}
}
}
}
if (subList.Count == 0)
{
return(spawners);
}
for (int ii = 0; ii < itemCount; ii++)
{
spawners.Add(subList.Pick(map.Rand));
}
return(spawners);
}
public override List <MapItem> GenerateItems(BaseMapGenContext map, SpawnList <MapItem> specialItems)
{
int itemCount = Amount.Pick(map.Rand);
List <MapItem> spawners = new List <MapItem>();
SpawnList <MapItem> subList = new SpawnList <MapItem>();
if (UseSpecialItems)
{
for (int ii = 0; ii < specialItems.Count; ii++)
{
MapItem spawn = specialItems.GetSpawn(ii);
if (!spawn.IsMoney)
{
if (Range.Min <= spawn.Value && spawn.Value < Range.Max)
{
subList.Add(spawn, specialItems.GetSpawnRate(ii));
}
}
}
}
if (UseMapItems)
{
foreach (string key in map.ItemSpawns.Spawns.GetKeys())
{
SpawnList <InvItem> spawns = map.ItemSpawns.Spawns.GetSpawn(key);
for (int ii = 0; ii < spawns.Count; ii++)
{
//TODO: spawn rate is somewhat distorted here
InvItem spawn = spawns.GetSpawn(ii);
//ItemData data = DataManager.Instance.GetItem(spawn.ID);
if (Range.Min <= spawn.ID && spawn.ID < Range.Max)
{
subList.Add(new MapItem(spawn), spawns.GetSpawnRate(ii));
}
}
}
}
if (subList.Count == 0)
{
return(spawners);
}
for (int ii = 0; ii < itemCount; ii++)
{
spawners.Add(subList.Pick(map.Rand));
}
return(spawners);
}
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue)
{
TileSpawnStep <BaseMapGenContext> spawnStep = new TileSpawnStep <BaseMapGenContext>();
SpawnList <EffectTile> spawner = Spawns.GetSpawnList(zoneContext.CurrentID);
for (int ii = 0; ii < spawner.Count; ii++)
{
spawnStep.Spawns.Add(spawner.GetSpawn(ii), spawner.GetSpawnRate(ii));
}
queue.Enqueue(Priority, spawnStep);
}
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue)
{
MobSpawnStep <BaseMapGenContext> spawnStep = new MobSpawnStep <BaseMapGenContext>();
PoolTeamSpawner spawner = new PoolTeamSpawner();
spawner.Spawns = Spawns.GetSpawnList(zoneContext.CurrentID);
spawner.TeamSizes = TeamSizes.GetSpawnList(zoneContext.CurrentID);
spawnStep.Spawns.Add(spawner, spawner.Spawns.SpawnTotal);
SpawnList <SpecificTeamSpawner> specificSpawner = SpecificSpawns.GetSpawnList(zoneContext.CurrentID);
for (int ii = 0; ii < specificSpawner.Count; ii++)
{
spawnStep.Spawns.Add(specificSpawner.GetSpawn(ii), specificSpawner.GetSpawnRate(ii));
}
queue.Enqueue(Priority, spawnStep);
}
public override void Apply(T map)
{
foreach (string key in Spawns.GetKeys())
{
SpawnList <InvItem> itemList = Spawns.GetSpawn(key);
if (itemList.CanPick)
{
if (!map.ItemSpawns.Spawns.ContainsKey(key))
{
map.ItemSpawns.Spawns.Add(key, new SpawnList <InvItem>(), Spawns.GetSpawnRate(key));
}
SpawnList <InvItem> destList = map.ItemSpawns.Spawns.GetSpawn(key);
for (int ii = 0; ii < itemList.Count; ii++)
{
destList.Add(new InvItem(itemList.GetSpawn(ii)), itemList.GetSpawnRate(ii));
}
}
}
}
public override List <MobSpawn> GenerateMobs(BaseMapGenContext map, SpawnList <MobSpawn> specialMobs)
{
int mobCount = Amount.Pick(map.Rand);
List <MobSpawn> spawners = new List <MobSpawn>();
IEnumerable <int> species = GetSpecies(map, specialMobs);
SpawnList <MobSpawn> subList = new SpawnList <MobSpawn>();
for (int ii = 0; ii < specialMobs.Count; ii++)
{
MobSpawn spawn = specialMobs.GetSpawn(ii);
if (CheckIfAllowed(map, spawn, species))
{
subList.Add(spawn, specialMobs.GetSpawnRate(ii));
}
}
for (int ii = 0; ii < map.TeamSpawns.Count; ii++)
{
SpawnList <MobSpawn> memberSpawns = map.TeamSpawns.GetSpawn(ii).GetPossibleSpawns();
for (int jj = 0; ii < memberSpawns.Count; jj++)
{
MobSpawn spawn = memberSpawns.GetSpawn(jj);
if (CheckIfAllowed(map, spawn, species))
{
subList.Add(spawn, memberSpawns.GetSpawnRate(jj));
}
}
}
if (subList.Count > 0)
{
for (int ii = 0; ii < mobCount; ii++)
{
spawners.Add(subList.Pick(map.Rand));
}
}
return(spawners);
}
public override SpawnList <MobSpawn> GetPossibleSpawns()
{
SpawnList <MobSpawn> spawnerList = new SpawnList <MobSpawn>();
for (int ii = 0; ii < NormalSpawns.Count; ii++)
{
spawnerList.Add(NormalSpawns.GetSpawn(ii), NormalSpawns.GetSpawnRate(ii));
}
for (int ii = 0; ii < LeaderSpawns.Count; ii++)
{
spawnerList.Add(LeaderSpawns.GetSpawn(ii), LeaderSpawns.GetSpawnRate(ii));
}
for (int ii = 0; ii < LonerSpawns.Count; ii++)
{
spawnerList.Add(LonerSpawns.GetSpawn(ii), LonerSpawns.GetSpawnRate(ii));
}
for (int ii = 0; ii < SupportSpawns.Count; ii++)
{
spawnerList.Add(SupportSpawns.GetSpawn(ii), SupportSpawns.GetSpawnRate(ii));
}
return(spawnerList);
}
public override void Apply(T map)
{
int chosenAmount = Amount.Pick(map.Rand);
if (chosenAmount > 0)
{
SpawnList <int> spawningRooms = new SpawnList <int>();
//get all places that spawnings are eligible
for (int ii = 0; ii < map.RoomPlan.RoomCount; ii++)
{
IRoomGen room = map.RoomPlan.GetRoom(ii);
if (!BaseRoomFilter.PassesAllFilters(map.RoomPlan.GetRoomPlan(ii), this.Filters))
{
continue;
}
spawningRooms.Add(ii, 10000);
}
int trials = 10 * chosenAmount;
for (int ii = 0; ii < trials && chosenAmount > 0; ii++)
{
if (spawningRooms.SpawnTotal == 0)//check to make sure there's still spawn choices left
{
break;
}
int spawnIndex = spawningRooms.PickIndex(map.Rand);
int roomNum = spawningRooms.GetSpawn(spawnIndex);
Team newTeam = Spawn.GetSpawn(map);
if (newTeam == null)
{
continue;
}
List <Loc> freeTiles = Grid.FindTilesInBox(map.RoomPlan.GetRoom(roomNum).Draw.Start, map.RoomPlan.GetRoom(roomNum).Draw.Size,
(Loc testLoc) =>
{
return(((IGroupPlaceableGenContext <Team>)map).CanPlaceItem(testLoc));
});
//this actually places the members of the team in random scattered locations, leaving them to group together via wandering
if (freeTiles.Count >= newTeam.Players.Count)
{
Loc[] locs = new Loc[newTeam.Players.Count];
for (int jj = 0; jj < newTeam.Players.Count; jj++)
{
int randIndex = map.Rand.Next(freeTiles.Count);
locs[jj] = freeTiles[randIndex];
freeTiles.RemoveAt(randIndex);
}
((IGroupPlaceableGenContext <Team>)map).PlaceItems(newTeam, locs);
chosenAmount--;
}
if (freeTiles.Count == 0)//if spawningRooms is now impossible there, remove the room entirely
{
spawningRooms.RemoveAt(spawnIndex);
}
else //otherwise decrease spawn rate for room
{
spawningRooms.SetSpawnRate(spawnIndex, Math.Max(spawningRooms.GetSpawnRate(spawnIndex) * ClumpFactor / 100, 1));
}
}
}
}
