public void GetPossiblePlacementsNone()
{
// can't place anywhere, so resort to the middle
// verify all possible positions are checked
Mock <IRoomGen> mockFrom = new Mock <IRoomGen>(MockBehavior.Strict);
mockFrom.SetupGet(p => p.Draw).Returns(new Rect(3, 3, 6, 6));
Mock <IRoomGen> mockTo = new Mock <IRoomGen>(MockBehavior.Strict);
mockTo.SetupGet(p => p.Draw).Returns(new Rect(0, 0, 3, 3));
var adjacentsByDir = new Dictionary <Dir4, List <IRoomGen> >();
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
adjacentsByDir[dir] = new List <IRoomGen>();
}
var mockRooms = new Mock <IRandPicker <RoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
var mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
var pathGen = new Mock <AddSpecialRoomTestStep>(mockRooms.Object, mockHalls.Object)
{
CallBase = true
};
pathGen.Setup(p => p.GetAllBorderMatch(adjacentsByDir, mockTo.Object, mockFrom.Object, It.IsAny <Loc>())).Returns(0);
SpawnList <Loc> spawns = pathGen.Object.GetPossiblePlacements(adjacentsByDir, mockTo.Object, mockFrom.Object);
Assert.That(spawns.Count, Is.EqualTo(4));
Assert.That(spawns.GetSpawn(0), Is.EqualTo(new Loc(4, 4)));
Assert.That(spawns.GetSpawn(1), Is.EqualTo(new Loc(4, 5)));
Assert.That(spawns.GetSpawn(2), Is.EqualTo(new Loc(5, 4)));
Assert.That(spawns.GetSpawn(3), Is.EqualTo(new Loc(5, 5)));
}
public void GetPossiblePlacementsNarrow()
{
// only vertical sliding allowed
Mock <IRoomGen> mockFrom = new Mock <IRoomGen>(MockBehavior.Strict);
mockFrom.SetupGet(p => p.Draw).Returns(new Rect(3, 3, 4, 4));
Mock <IRoomGen> mockTo = new Mock <IRoomGen>(MockBehavior.Strict);
mockTo.SetupGet(p => p.Draw).Returns(new Rect(0, 0, 4, 2));
var adjacentsByDir = new Dictionary <Dir4, List <IRoomGen> >();
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
adjacentsByDir[dir] = new List <IRoomGen>();
}
var mockRooms = new Mock <IRandPicker <RoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
var mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
var pathGen = new Mock <AddSpecialRoomTestStep>(mockRooms.Object, mockHalls.Object)
{
CallBase = true
};
pathGen.Setup(p => p.GetAllBorderMatch(adjacentsByDir, mockTo.Object, mockFrom.Object, It.IsAny <Loc>())).Returns(1);
SpawnList <Loc> spawns = pathGen.Object.GetPossiblePlacements(adjacentsByDir, mockTo.Object, mockFrom.Object);
Assert.That(spawns.Count, Is.EqualTo(3));
Assert.That(spawns.GetSpawn(0), Is.EqualTo(new Loc(3, 3)));
Assert.That(spawns.GetSpawn(1), Is.EqualTo(new Loc(3, 5)));
Assert.That(spawns.GetSpawn(2), Is.EqualTo(new Loc(3, 4)));
}
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);
}
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.TeamSpawns.Add(Spawns.GetSpawn(ii).Clone(), Spawns.GetSpawnRate(ii));//Clone Use Case; convert to Instantiate?
}
}
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.TileSpawns.Add(Spawns.GetSpawn(ii), Spawns.GetSpawnRate(ii));
}
}
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 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)
{
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);
}
protected override List <int> GetTypes(BaseMapGenContext map, SpawnList <MobSpawn> specialMobs)
{
Dictionary <int, int> elementFrequency = new Dictionary <int, int>();
for (int ii = 0; ii < map.TeamSpawns.Count; ii++)
{
SpawnList <MobSpawn> mobSpawns = map.TeamSpawns.GetSpawn(ii).GetPossibleSpawns();
foreach (MobSpawn spawn in mobSpawns.EnumerateOutcomes())
{
MonsterFeatureData featureIndex = DataManager.Instance.UniversalData.Get <MonsterFeatureData>();
FormFeatureSummary baseData = featureIndex.FeatureData[spawn.BaseForm.Species][Math.Max(0, spawn.BaseForm.Form)];
if (baseData.Element1 != 00)
{
MathUtils.AddToDictionary(elementFrequency, baseData.Element1, 1);
}
if (baseData.Element2 != 00)
{
MathUtils.AddToDictionary(elementFrequency, baseData.Element2, 1);
}
}
}
if (elementFrequency.Count == 0)
{
for (int ii = 0; ii < specialMobs.Count; ii++)
{
MobSpawn spawn = specialMobs.GetSpawn(ii);
MonsterFeatureData featureIndex = DataManager.Instance.UniversalData.Get <MonsterFeatureData>();
FormFeatureSummary baseData = featureIndex.FeatureData[spawn.BaseForm.Species][Math.Max(0, spawn.BaseForm.Form)];
if (baseData.Element1 != 00)
{
MathUtils.AddToDictionary(elementFrequency, baseData.Element1, 1);
}
if (baseData.Element2 != 00)
{
MathUtils.AddToDictionary(elementFrequency, baseData.Element2, 1);
}
}
}
List <int> result = new List <int>();
if (elementFrequency.Count > 0)
{
//choose randomly from the top 3 types
List <(int, int)> elements = new List <(int, int)>();
foreach (int key in elementFrequency.Keys)
{
elements.Add((key, elementFrequency[key]));
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));
}
}
}
}
public override string ToString()
{
if (Items.Count != 1)
{
return(string.Format("{0}[{1}]", this.GetType().Name, Items.Count.ToString()));
}
else
{
EntrySummary summary = DataManager.Instance.DataIndices[DataManager.DataType.Item].Entries[Items.GetSpawn(0).ID];
return(string.Format("{0}: {1}", this.GetType().Name, summary.Name.ToLocal()));
}
}
