public static BiomeInfo GenerateForDepth(int depth)
{
var list = new List <BiomeInfo>();
var chances = new List <float>();
var array = Run.Type == RunType.BossRush && depth > 0 ? BossRushDefined : Defined;
foreach (var b in array.Values)
{
if (b.Depths.Contains(depth))
{
list.Add(b);
chances.Add(b.Chances[b.Depths.IndexOf(depth)]);
}
}
var index = Rnd.Chances(chances);
if (index == -1)
{
Log.Error($"Failed to generate a biome for the depth {depth}");
return(array.Values.First());
}
return(list[index]);
}
public static Boss Generate()
{
var current = new List <BossInfo>();
foreach (var info in All)
{
if (info.SpawnsIn(Run.Level.Biome.Id))
{
current.Add(info);
}
}
var chances = new float[current.Count];
for (var i = 0; i < current.Count; i++)
{
chances[i] = current[i].GetChanceFor(Run.Level.Biome.Id).Chance;
}
var index = Rnd.Chances(chances);
if (index == -1)
{
return(null);
}
return((Boss)Activator.CreateInstance(current[index].Type));
}
public virtual T Generate()
{
var I = Rnd.Chances(Chances);
if (I == -1)
{
Log.Error("-1 as pool result!");
return(default(T));
}
return(Classes[I]);
}
public static Mob Generate()
{
var chances = new float[Current.Count];
for (var i = 0; i < Current.Count; i++)
{
if (Current[i].Type == typeof(BeeHive))
{
continue;
}
chances[i] = Current[i].GetChanceFor(Run.Level.Biome.Id).Chance;
}
var types = new List <MobInfo>();
var spawnChances = new List <float>();
for (int i = 0; i < Rnd.Int(2, 6); i++)
{
var type = Current[Rnd.Chances(chances)];
var found = false;
foreach (var t in types)
{
if (t == type)
{
found = true;
break;
}
}
if (found)
{
i--;
}
else
{
types.Add(type);
spawnChances.Add(type.Chance);
}
}
if (types.Count == 0)
{
return(null);
}
return((Mob)Activator.CreateInstance(types[Rnd.Chances(spawnChances)].Type));
}
public BossPatternSet <T> Generate(string biome)
{
var types = new List <BossPatternSet <T> >();
var ch = new List <float>();
for (var i = 0; i < defined.Count; i++)
{
if (Biome.IsPresent(biome, defined[i].Biomes))
{
types.Add(defined[i]);
ch.Add(chances[i]);
}
}
return(types[Rnd.Chances(ch)]);
}
public static Item Create(string id)
{
if (id == null)
{
return(null);
}
if (id == "bk:coin")
{
id = coinIds[Rnd.Chances(coinChances)];
}
if (!Datas.TryGetValue(id, out var data))
{
Log.Error($"Unknown item {id}");
return(null);
}
return(Create(data));
}
public static LevelVariant Generate(string biome)
{
if (Run.Depth == -2)
{
return(new RegularLevelVariant());
}
var variants = new List <LevelVariant>();
var chances = new List <float>();
foreach (var variant in defined)
{
foreach (var b in variant.Biomes)
{
if (b == biome)
{
variants.Add(variant.Variant);
chances.Add(variant.Chance);
break;
}
}
}
if (variants.Count == 0)
{
return(null);
}
var index = Rnd.Chances(chances);
if (index == -1)
{
return(new RegularLevelVariant());
}
return(variants[index]);
}
public override List <RoomDef> Build(List <RoomDef> rooms)
{
SetupRooms(rooms);
if (landmarkRoom == null)
{
landmarkRoom = MultiConnection[Rnd.Int(MultiConnection.Count)];
}
if (MultiConnection.Contains(landmarkRoom))
{
MultiConnection.Remove(landmarkRoom);
}
var startAngle = Rnd.Float(0, 180);
var roomsOnLoop = (int)(MultiConnection.Count * PathLength) + Rnd.Chances(PathLenJitterChances);
roomsOnLoop = Math.Min(roomsOnLoop, MultiConnection.Count);
var roomsOnFirstLoop = roomsOnLoop / 2;
if (roomsOnLoop % 2 == 1)
{
roomsOnFirstLoop += Rnd.Int(2);
}
firstLoop = new List <RoomDef>();
var pathTunnels = ArrayUtils.Clone(PathTunnelChances);
for (var i = 0; i <= roomsOnFirstLoop; i++)
{
if (i == 0)
{
firstLoop.Add(landmarkRoom);
}
else
{
firstLoop.Add(MultiConnection[0]);
MultiConnection.RemoveAt(0);
}
var tunnels = Rnd.Chances(pathTunnels);
if (tunnels == -1)
{
pathTunnels = ArrayUtils.Clone(PathTunnelChances);
tunnels = Rnd.Chances(pathTunnels);
}
pathTunnels[tunnels]--;
for (var j = 0; j < tunnels; j++)
{
firstLoop.Add(RoomRegistry.Generate(RoomType.Connection, LevelSave.BiomeGenerated));
}
}
if (Entrance != null)
{
firstLoop.Insert((firstLoop.Count + 1) / 2, Entrance);
}
var roomsOnSecondLoop = roomsOnLoop - roomsOnFirstLoop;
secondLoop = new List <RoomDef>();
for (var i = 0; i <= roomsOnSecondLoop; i++)
{
if (i == 0)
{
secondLoop.Add(landmarkRoom);
}
else
{
secondLoop.Add(MultiConnection[0]);
MultiConnection.RemoveAt(0);
}
var tunnels = Rnd.Chances(pathTunnels);
if (tunnels == -1)
{
pathTunnels = ArrayUtils.Clone(PathTunnelChances);
tunnels = Rnd.Chances(pathTunnels);
}
pathTunnels[tunnels]--;
for (var j = 0; j < tunnels; j++)
{
secondLoop.Add(RoomRegistry.Generate(RoomType.Connection, LevelSave.BiomeGenerated));
}
}
if (Exit != null)
{
secondLoop.Insert((secondLoop.Count + 1) / 2, Exit);
}
landmarkRoom.SetSize();
landmarkRoom.SetPos(0, 0);
var prev = landmarkRoom;
float targetAngle;
for (var i = 1; i < firstLoop.Count; i++)
{
var r = firstLoop[i];
targetAngle = startAngle + getTargetAngle(i / (float)firstLoop.Count);
if ((int)PlaceRoom(rooms, prev, r, targetAngle) != -1)
{
prev = r;
if (!rooms.Contains(prev))
{
rooms.Add(prev);
}
}
else
{
return(null);
}
}
while (!prev.ConnectWithRoom(landmarkRoom))
{
var c = RoomRegistry.Generate(RoomType.Connection, LevelSave.BiomeGenerated);
if ((int)PlaceRoom(rooms, prev, c, AngleBetweenRooms(prev, landmarkRoom)) == -1)
{
return(null);
}
firstLoop.Add(c);
rooms.Add(c);
prev = c;
}
prev = landmarkRoom;
startAngle += 180f;
/*for (var i = 1; i < secondLoop.Count; i++){
* var r = secondLoop[i];
* targetAngle = startAngle + getTargetAngle(i / (float)secondLoop.Count);
*
* if ((int) PlaceRoom(rooms, prev, r, targetAngle) != -1) {
* prev = r;
*
* if (!rooms.Contains(prev)) {
* rooms.Add(prev);
* }
* } else {
* return null;
* }
* }
*
* while (!prev.ConnectWithRoom(landmarkRoom)) {
* var c = RoomRegistry.Generate(RoomType.Connection, LevelSave.BiomeGenerated);
*
* if ((int) PlaceRoom(rooms, prev, c, AngleBetweenRooms(prev, landmarkRoom)) == -1){
* return null;
* }
*
* secondLoop.Add(c);
* rooms.Add(c);
* prev = c;
* }*/
firstLoopCenter = new Vector2();
foreach (var r in firstLoop)
{
firstLoopCenter.X += (r.Left + r.Right) / 2f;
firstLoopCenter.Y += (r.Top + r.Bottom) / 2f;
}
firstLoopCenter.X /= firstLoop.Count;
firstLoopCenter.Y /= firstLoop.Count;
secondLoopCenter = new Vector2();
foreach (var r in secondLoop)
{
secondLoopCenter.X += (r.Left + r.Right) / 2f;
secondLoopCenter.Y += (r.Top + r.Bottom) / 2f;
}
secondLoopCenter.X /= secondLoop.Count;
secondLoopCenter.Y /= secondLoop.Count;
var branchable = new List <RoomDef>(firstLoop);
branchable.AddRange(secondLoop);
branchable.Remove(landmarkRoom);
var roomsToBranch = new List <RoomDef>();
roomsToBranch.AddRange(MultiConnection);
roomsToBranch.AddRange(SingleConnection);
WeightRooms(branchable);
CreateBranches(rooms, branchable, roomsToBranch, BranchTunnelChances);
FindNeighbours(rooms);
foreach (var r in rooms)
{
foreach (var n in r.Neighbours)
{
if (!n.Connected.ContainsKey(r) && Rnd.Float() < ExtraConnectionChance)
{
r.ConnectWithRoom(n);
}
}
}
return(rooms);
}
protected bool CreateBranches(List <RoomDef> Rooms, List <RoomDef> Branchable, List <RoomDef> RoomsToBranch, float[] ConnChances)
{
var I = 0;
var N = 0;
float Angle;
int Tries;
RoomDef Curr;
var ConnectingRoomsThisBranch = new List <RoomDef>();
var ConnectionChances = ArrayUtils.Clone(ConnChances);
while (I < RoomsToBranch.Count)
{
var R = RoomsToBranch[I];
N++;
ConnectingRoomsThisBranch.Clear();
do
{
Curr = Branchable[Rnd.Int(Branchable.Count)];
} while (Curr is ConnectionRoom);
var ConnectingRooms = Rnd.Chances(ConnectionChances);
if (ConnectingRooms == -1)
{
ConnectionChances = ArrayUtils.Clone(ConnChances);
ConnectingRooms = Rnd.Chances(ConnectionChances);
}
ConnectionChances[ConnectingRooms]--;
for (var J = 0; J < ConnectingRooms; J++)
{
var T = RoomRegistry.Generate(RoomType.Connection, LevelSave.BiomeGenerated);
Tries = 3;
do
{
Angle = PlaceRoom(Rooms, Curr, T, RandomBranchAngle(Curr));
Tries--;
} while (Math.Abs(Angle - (-1)) < 0.01f && Tries > 0);
if (Math.Abs(Angle - (-1)) < 0.01f)
{
foreach (var C in ConnectingRoomsThisBranch)
{
C.ClearConnections();
Rooms.Remove(C);
}
ConnectingRoomsThisBranch.Clear();
break;
}
ConnectingRoomsThisBranch.Add(T);
Rooms.Add(T);
Curr = T;
}
if (ConnectingRoomsThisBranch.Count != ConnectingRooms)
{
if (N > 30)
{
return(false);
}
continue;
}
Tries = 10;
do
{
Angle = PlaceRoom(Rooms, Curr, R, RandomBranchAngle(Curr));
Tries--;
} while (Math.Abs(Angle - (-1)) < 0.01f && Tries > 0);
if (Math.Abs(Angle - (-1)) < 0.01f)
{
foreach (var T in ConnectingRoomsThisBranch)
{
T.ClearConnections();
Rooms.Remove(T);
}
ConnectingRoomsThisBranch.Clear();
if (N > 30)
{
return(false);
}
continue;
}
foreach (var AConnectingRoomsThisBranch in ConnectingRoomsThisBranch)
{
if (Rnd.Int(3) <= 1)
{
Branchable.Add(AConnectingRoomsThisBranch);
}
}
if (R.GetMaxConnections(RoomDef.Connection.All) > 1 && Rnd.Int(3) == 0)
{
if (R is RegularRoom room)
{
/*for (var J = 0; J < room.GetSize().GetConnectionWeight(); J++) {
* Branchable.Add(room);
* }*/
Branchable.Add(room);
}
else
{
Branchable.Add(R);
}
}
I++;
}
return(true);
}
public override List <RoomDef> Build(List <RoomDef> Init)
{
SetupRooms(Init);
if (Entrance == null)
{
Log.Error("No entrance!");
return(null);
}
var Branchable = new List <RoomDef>();
Entrance.SetSize();
Entrance.SetPos(0, 0);
Branchable.Add(Entrance);
if (MultiConnection.Count == 0)
{
PlaceRoom(Init, Entrance, Exit, Rnd.Angle());
if (Boss != null && !PlaceBoss(Init, Exit))
{
return(null);
}
return(Init);
}
var RoomsOnPath = (int)(MultiConnection.Count * PathLength) + Rnd.Chances(PathLenJitterChances);
RoomsOnPath = Math.Min(RoomsOnPath, MultiConnection.Count);
RoomDef Curr = Entrance;
var PathTunnels = ArrayUtils.Clone(PathTunnelChances);
for (var I = 0; I <= RoomsOnPath; I++)
{
if (I == RoomsOnPath && Exit == null)
{
continue;
}
var Tunnels = Rnd.Chances(PathTunnels);
if (Tunnels == -1)
{
PathTunnels = ArrayUtils.Clone(PathTunnelChances);
Tunnels = Rnd.Chances(PathTunnels);
}
PathTunnels[Tunnels]--;
if (I != 0 && Run.Depth != 0)
{
for (var J = 0; J < Tunnels; J++)
{
var T = RoomRegistry.Generate(RoomType.Connection, LevelSave.BiomeGenerated);
if (Math.Abs(PlaceRoom(Init, Curr, T, Direction + Rnd.Float(-PathVariance, PathVariance)) - (-1)) < 0.01f)
{
return(null);
}
Branchable.Add(T);
Init.Add(T);
Curr = T;
}
}
var R = I == RoomsOnPath ? Exit : MultiConnection[I];
if (Math.Abs(PlaceRoom(Init, Curr, R, Direction + Rnd.Float(-PathVariance, PathVariance)) - (-1)) < 0.01f)
{
return(null);
}
if (R == Exit && Boss != null && !PlaceBoss(Init, R))
{
return(null);
}
Branchable.Add(R);
Curr = R;
}
var RoomsToBranch = new List <RoomDef>();
for (var I = RoomsOnPath; I < MultiConnection.Count; I++)
{
RoomsToBranch.Add(MultiConnection[I]);
}
RoomsToBranch.AddRange(SingleConnection);
WeightRooms(Branchable);
if (!CreateBranches(Init, Branchable, RoomsToBranch, BranchTunnelChances))
{
return(null);
}
FindNeighbours(Init);
foreach (var R in Init)
{
foreach (var N in R.Neighbours)
{
if (!N.Connected.ContainsKey(R) && Rnd.Float() < ExtraConnectionChance)
{
R.ConnectWithRoom(N);
}
}
}
return(Init);
}
public override List <RoomDef> Build(List <RoomDef> Init)
{
SetupRooms(Init);
if (Entrance == null)
{
return(null);
}
Entrance.SetPos(0, 0);
Entrance.SetSize();
var StartAngle = Rnd.Angle();
var Loop = new List <RoomDef>();
var RoomsOnLoop = (int)(MultiConnection.Count * PathLength) + Rnd.Chances(PathLenJitterChances);
RoomsOnLoop = Math.Min(RoomsOnLoop, MultiConnection.Count);
RoomsOnLoop++;
var PathTunnels = ArrayUtils.Clone(PathTunnelChances);
for (var i = MultiConnection.Count - 1; i >= 0; i--)
{
var r = MultiConnection[i];
if (r is ConnectionRoom)
{
Loop.Add(r);
MultiConnection.RemoveAt(i);
}
}
for (var I = 0; I < RoomsOnLoop; I++)
{
if (I == 0)
{
Loop.Add(Entrance);
}
else
{
Loop.Add(MultiConnection[0]);
MultiConnection.RemoveAt(0);
}
var Tunnels = Rnd.Chances(PathTunnels);
if (Tunnels == -1)
{
PathTunnels = ArrayUtils.Clone(PathTunnelChances);
Tunnels = Rnd.Chances(PathTunnels);
}
PathTunnels[Tunnels]--;
for (var J = 0; J < Tunnels; J++)
{
Loop.Add(RoomRegistry.Generate(RoomType.Connection, LevelSave.BiomeGenerated));
}
}
if (Exit != null)
{
Loop.Insert((Loop.Count + 1) / 2, Exit);
}
if (LevelSave.BiomeGenerated is LibraryBiome)
{
var c = (Loop.Count + 1);
Loop.Insert(c / 4, new LibraryConnectionRoom());
Loop.Insert(c / 4 * 3, new LibraryConnectionRoom {
BottomHalf = true
});
}
RoomDef Prev = Entrance;
float TargetAngle;
for (var I = 1; I < Loop.Count; I++)
{
var R = Loop[I];
TargetAngle = StartAngle + this.TargetAngle(I / (float)Loop.Count);
if ((int)PlaceRoom(Init, Prev, R, TargetAngle) != -1)
{
Prev = R;
if (!Init.Contains(Prev))
{
Init.Add(Prev);
}
if (R == Exit && Boss != null)
{
var a = TargetAngle - 90;
var i = 0;
while (true)
{
var an = PlaceRoom(Init, R, Boss, a);
if ((int)an != -1)
{
break;
}
i++;
if (i > 36)
{
return(null);
}
a += 10;
}
a = Rnd.Angle();
i = 0;
if (Granny != null)
{
while (true)
{
var an = PlaceRoom(Init, Boss, Granny, a);
if ((int)an != -1)
{
break;
}
i++;
if (i > 72)
{
return(null);
}
a += 5;
}
}
a = Rnd.Angle();
i = 0;
if (OldMan != null)
{
while (true)
{
var an = PlaceRoom(Init, Boss, OldMan, a);
if ((int)an != -1)
{
break;
}
i++;
if (i > 72)
{
return(null);
}
a += 5;
}
}
}
}
else
{
return(null);
}
}
while (!Prev.ConnectTo(Entrance))
{
var C = RoomRegistry.Generate(RoomType.Regular, LevelSave.BiomeGenerated);
if ((int)PlaceRoom(Loop, Prev, C, AngleBetweenRooms(Prev, Entrance)) == -1)
{
return(null);
}
Loop.Add(C);
Init.Add(C);
Prev = C;
}
LoopCenter = new Vector2();
foreach (var R in Loop)
{
LoopCenter.X += (R.Left + R.Right) / 2f;
LoopCenter.Y += (R.Top + R.Bottom) / 2f;
}
LoopCenter.X /= Loop.Count;
LoopCenter.Y /= Loop.Count;
var Branchable = new List <RoomDef>(Loop);
var RoomsToBranch = new List <RoomDef>();
RoomsToBranch.AddRange(MultiConnection);
RoomsToBranch.AddRange(SingleConnection);
WeightRooms(Branchable);
if (!CreateBranches(Init, Branchable, RoomsToBranch, BranchTunnelChances))
{
return(null);
}
FindNeighbours(Init);
foreach (var R in Init)
{
foreach (var N in R.Neighbours)
{
if (!N.Connected.ContainsKey(R) && Rnd.Float() < ExtraConnectionChance)
{
R.ConnectWithRoom(N);
}
}
}
if (!Prev.Connected.ContainsKey(Entrance))
{
Prev.Neighbours.Add(Entrance);
Entrance.Neighbours.Add(Prev);
Prev.Connected[Entrance] = null;
Entrance.Connected[Prev] = null;
}
return(Init);
}