public void Generate_BasicTest()
{
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1
});
var roomDescription2 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1, roomTemplate2
});
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0, roomDescription1);
mapDescription.AddRoom(1, roomDescription2);
mapDescription.AddConnection(0, 1);
var configurationSpaces = generator.GetConfigurationSpaces <Configuration <CorridorsData> >(mapDescription);
Assert.That(configurationSpaces.GetShapesForNode(0).Count, Is.EqualTo(1));
Assert.That(configurationSpaces.GetShapesForNode(1).Count, Is.EqualTo(3));
Assert.That(configurationSpaces.GetAllShapes().Count, Is.EqualTo(3));
}
protected virtual IRoomDescription GetBasicRoomDescription()
{
var basicRoomTemplates = MapDescriptionUtils.GetBasicRoomTemplates(Options.Scale);
var basicRoomDescription = new BasicRoomDescription(basicRoomTemplates);
return(basicRoomDescription);
}
public void DifferentTransformationsProperlyHandled()
{
var roomTemplate1 = GetRoomTemplate(RoomTemplateRepeatMode.NoRepeat, TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1
});
var mapDescription = GetMapDescription(roomDescription);
var configurationSpaces = GetConfigurationSpaces(mapDescription);
var roomShapesHandler = new RoomShapesHandler <int, Configuration <CorridorsData> >(
configurationSpaces,
configurationSpaces.GetIntAliasMapping(),
mapDescription
);
var roomShapes = configurationSpaces.GetIntAliasMapping().Values.ToList();
var layout = new Layout <Configuration <CorridorsData> >(mapDescription.GetGraph());
SetConfiguration(layout, 0, roomShapes[0]);
{
var shapes = roomShapesHandler.GetPossibleShapesForNode(layout, 1);
Assert.That(shapes.Count, Is.Zero);
}
}
public void BasicTest()
{
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0));
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0));
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1
});
var roomDescription2 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate2
});
var mapDescription = new MapDescription <string>();
mapDescription.AddRoom("0", roomDescription1);
mapDescription.AddRoom("1", roomDescription2);
mapDescription.AddConnection("0", "1");
var mapDescriptionMapping = new MapDescriptionMapping <string>(mapDescription);
var mapping = mapDescriptionMapping.GetMapping();
Assert.That(mapDescriptionMapping.GetRoomDescription(mapping["0"]), Is.EqualTo(roomDescription1));
Assert.That(mapDescriptionMapping.GetRoomDescription(mapping["1"]), Is.EqualTo(roomDescription2));
Assert.That(mapDescriptionMapping.GetGraph().VerticesCount, Is.EqualTo(2));
Assert.That(mapDescriptionMapping.GetGraph().HasEdge(mapping["0"], mapping["1"]), Is.True);
}
public void AllowRepeat()
{
var roomTemplate1 = GetRoomTemplate(RoomTemplateRepeatMode.AllowRepeat);
var roomTemplate2 = GetRoomTemplate(RoomTemplateRepeatMode.AllowRepeat);
var roomTemplate3 = GetRoomTemplate(RoomTemplateRepeatMode.AllowRepeat);
var roomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1, roomTemplate2, roomTemplate3
});
var mapDescription = GetMapDescription(roomDescription);
var configurationSpaces = GetConfigurationSpaces(mapDescription);
var roomShapesHandler = new RoomShapesHandler <int, Configuration <CorridorsData> >(
configurationSpaces,
configurationSpaces.GetIntAliasMapping(),
mapDescription
);
var roomShapes = configurationSpaces.GetIntAliasMapping().Values.ToList();
var layout = new Layout <Configuration <CorridorsData> >(mapDescription.GetGraph());
SetConfiguration(layout, 0, roomShapes[0]);
SetConfiguration(layout, 1, roomShapes[1]);
SetConfiguration(layout, 2, roomShapes[2]);
foreach (var node in mapDescription.GetGraph().Vertices)
{
var shapes = roomShapesHandler.GetPossibleShapesForNode(layout, node);
var expectedShapes = configurationSpaces.GetShapesForNode(node);
Assert.That(shapes, Is.EquivalentTo(expectedShapes));
}
}
public void ComputeAverageRoomTemplatesEntropy_BasicTest()
{
var transformations = TransformationGrid2DHelper.GetAllTransformationsOld().ToList();
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0), transformations);
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0), transformations);
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1, roomTemplate2
});
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0, roomDescription1);
mapDescription.AddRoom(1, roomDescription1);
mapDescription.AddConnection(0, 1);
var dungeonGenerator = new DungeonGenerator <int>(mapDescription);
dungeonGenerator.InjectRandomGenerator(new Random(0));
var layouts = new List <MapLayout <int> >();
for (int i = 0; i < 10; i++)
{
layouts.Add(dungeonGenerator.GenerateLayout());
}
var entropy = entropyCalculator.ComputeAverageRoomTemplatesEntropy(mapDescription, layouts);
Assert.That(entropy, Is.GreaterThanOrEqualTo(0));
Assert.That(entropy, Is.LessThanOrEqualTo(1));
}
public void SimpleMapDescriptionTest()
{
var roomTemplate1 = new RoomTemplate(PolygonGrid2D.GetSquare(10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomTemplate2 = new RoomTemplate(PolygonGrid2D.GetRectangle(5, 10), new SimpleDoorMode(1, 0), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomDescription1 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1
});
var roomDescription2 = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate2
});
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0, roomDescription1);
mapDescription.AddRoom(1, roomDescription2);
mapDescription.AddConnection(0, 1);
var dungeonGenerator = new DungeonGenerator <int>(mapDescription);
dungeonGenerator.InjectRandomGenerator(new Random(0));
var layout = dungeonGenerator.GenerateLayout();
Assert.That(layout, Is.Not.Null);
Assert.That(layout.Rooms.Count(), Is.EqualTo(2));
}
private void LoadRooms(MapDescription <int> mapDescription, MapDescriptionModel mapDescriptionModel, Dictionary <string, RoomDescriptionsSetModel> roomDescriptionsSets)
{
if (mapDescriptionModel.RoomsRange == null)
{
throw new InvalidOperationException("Rooms range must be defined");
}
if (mapDescriptionModel.RoomsRange.To - mapDescriptionModel.RoomsRange.From <= 0)
{
throw new InvalidOperationException("There must be at least one roon in the room range. 'To' must be greater than 'From'.");
}
var notUsedRooms = new List <int>();
for (var i = mapDescriptionModel.RoomsRange.From; i <= mapDescriptionModel.RoomsRange.To; i++)
{
notUsedRooms.Add(i);
}
if (mapDescriptionModel.Rooms != null)
{
foreach (var pair in mapDescriptionModel.Rooms)
{
var roomModel = pair.Value;
var rooms = pair.Key;
if (roomModel.RoomShapes != null)
{
var roomTemplates = GetRoomTemplates(roomModel.RoomShapes, roomDescriptionsSets, mapDescriptionModel.CustomRoomDescriptionsSet);
var roomDescription = new BasicRoomDescription(roomTemplates);
foreach (var room in rooms)
{
mapDescription.AddRoom(room, roomDescription);
notUsedRooms.Remove(room);
}
}
}
}
if (notUsedRooms.Count != 0)
{
if (mapDescriptionModel.DefaultRoomShapes != null)
{
var roomTemplates = GetRoomTemplates(mapDescriptionModel.DefaultRoomShapes, roomDescriptionsSets, mapDescriptionModel.CustomRoomDescriptionsSet);
var roomDescription = new BasicRoomDescription(roomTemplates);
foreach (var room in notUsedRooms)
{
mapDescription.AddRoom(room, roomDescription);
}
}
else
{
throw new InvalidOperationException($"Default room shapes must be provided if there are rooms that do not have their own room shapes assigned. Rooms with missing room shapes: {string.Join(", ", notUsedRooms)}");
}
}
}
public void AddRoom_DuplicateRoom_Throws()
{
var mapDescription = new MapDescription <int>();
var roomDescription = new BasicRoomDescription(GetRoomTemplates());
mapDescription.AddRoom(0, roomDescription);
Assert.Throws <ArgumentException>(() => mapDescription.AddRoom(0, roomDescription));
}
public void NoImmediate()
{
var roomTemplate1 = GetRoomTemplate(RoomTemplateRepeatMode.NoImmediate);
var roomTemplate2 = GetRoomTemplate(RoomTemplateRepeatMode.NoImmediate);
var roomTemplate3 = GetRoomTemplate(RoomTemplateRepeatMode.NoImmediate);
var roomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate1, roomTemplate2, roomTemplate3
});
var mapDescription = GetMapDescription(roomDescription);
var configurationSpaces = GetConfigurationSpaces(mapDescription);
var roomShapesHandler = new RoomShapesHandler <int, Configuration <CorridorsData> >(
configurationSpaces,
configurationSpaces.GetIntAliasMapping(),
mapDescription
);
var roomShapes = configurationSpaces.GetIntAliasMapping().Values.ToList();
var layout = new Layout <Configuration <CorridorsData> >(mapDescription.GetGraph());
SetConfiguration(layout, 0, roomShapes[0]);
SetConfiguration(layout, 1, roomShapes[1]);
SetConfiguration(layout, 2, roomShapes[2]);
{
// Node 0
var shapes = roomShapesHandler.GetPossibleShapesForNode(layout, 0);
var expectedShapes = new List <IntAlias <PolygonGrid2D> >()
{
roomShapes[0], roomShapes[2]
};
Assert.That(shapes, Is.EquivalentTo(expectedShapes));
}
{
// Node 1
var shapes = roomShapesHandler.GetPossibleShapesForNode(layout, 1);
var expectedShapes = new List <IntAlias <PolygonGrid2D> >()
{
roomShapes[1]
};
Assert.That(shapes, Is.EquivalentTo(expectedShapes));
}
{
// Node 2
var shapes = roomShapesHandler.GetPossibleShapesForNode(layout, 2);
var expectedShapes = new List <IntAlias <PolygonGrid2D> >()
{
roomShapes[0], roomShapes[2]
};
Assert.That(shapes, Is.EquivalentTo(expectedShapes));
}
}
public void GetRoomDescription_ReturnsRoomDescription()
{
var mapDescription = new MapDescription <int>();
var basicRoomDescription1 = new BasicRoomDescription(GetRoomTemplates());
var basicRoomDescription2 = new BasicRoomDescription(GetRoomTemplates());
mapDescription.AddRoom(0, basicRoomDescription1);
mapDescription.AddRoom(1, basicRoomDescription2);
Assert.That(mapDescription.GetRoomDescription(0), Is.EqualTo(basicRoomDescription1));
Assert.That(mapDescription.GetRoomDescription(1), Is.EqualTo(basicRoomDescription2));
}
public MapDescription <int> GetMapDescription()
{
// Prepare room templates
var doorMode = new SimpleDoorMode(1, 1);
var squareRoom = new RoomTemplate(
new PolygonGrid2DBuilder()
.AddPoint(0, 0)
.AddPoint(0, 8)
.AddPoint(8, 8)
.AddPoint(8, 0)
.Build(),
doorMode
);
var rectangleRoom = new RoomTemplate(
PolygonGrid2D.GetRectangle(6, 10),
doorMode,
new List <TransformationGrid2D>()
{
TransformationGrid2D.Identity, TransformationGrid2D.Rotate90
}
);
// Create room description
var basicRoomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
squareRoom, rectangleRoom
});
// Create map description
var mapDescription = new MapDescription <int>();
// Add rooms
mapDescription.AddRoom(0, basicRoomDescription);
mapDescription.AddRoom(1, basicRoomDescription);
mapDescription.AddRoom(2, basicRoomDescription);
mapDescription.AddRoom(3, basicRoomDescription);
// Add connections
mapDescription.AddConnection(0, 1);
mapDescription.AddConnection(0, 3);
mapDescription.AddConnection(1, 2);
mapDescription.AddConnection(2, 3);
// Add room shapes
return(mapDescription);
}
public void GetGraph_WhenCorridorTooManyNeighbors_Throws()
{
var mapDescription = new MapDescription <int>();
var basicRoomDescription = new BasicRoomDescription(GetRoomTemplates());
var corridorRoomDescription = new CorridorRoomDescription(GetRoomTemplates());
mapDescription.AddRoom(0, corridorRoomDescription);
mapDescription.AddRoom(1, basicRoomDescription);
mapDescription.AddRoom(2, basicRoomDescription);
mapDescription.AddRoom(3, basicRoomDescription);
mapDescription.AddConnection(0, 1);
mapDescription.AddConnection(0, 2);
mapDescription.AddConnection(0, 3);
Assert.Throws <ArgumentException>(() => mapDescription.GetGraph());
Assert.Throws <ArgumentException>(() => mapDescription.GetStageOneGraph());
}
public void GetGraph_WhenOnlyBasicRooms_ReturnsGraph()
{
var mapDescription = new MapDescription <int>();
var basicRoomDescription = new BasicRoomDescription(GetRoomTemplates());
mapDescription.AddRoom(0, basicRoomDescription);
mapDescription.AddRoom(1, basicRoomDescription);
mapDescription.AddRoom(2, basicRoomDescription);
mapDescription.AddRoom(3, basicRoomDescription);
mapDescription.AddConnection(0, 1);
mapDescription.AddConnection(0, 2);
mapDescription.AddConnection(0, 3);
var graph = mapDescription.GetGraph();
var stageOneGraph = mapDescription.GetStageOneGraph();
Assert.That(graph.VerticesCount, Is.EqualTo(4));
Assert.That(graph.Edges.Count(), Is.EqualTo(3));
Assert.That(stageOneGraph.VerticesCount, Is.EqualTo(4));
Assert.That(stageOneGraph.Edges.Count(), Is.EqualTo(3));
}
private MapDescription <int> GetMapDescription(BasicRoomDescription roomDescription, CorridorRoomDescription corridorRoomDescription = null)
{
var mapDescription = new MapDescription <int>();
var graph = new UndirectedAdjacencyListGraph <int>();
graph.AddVertex(0);
graph.AddVertex(1);
graph.AddVertex(2);
graph.AddEdge(0, 1);
graph.AddEdge(1, 2);
foreach (var vertex in graph.Vertices)
{
mapDescription.AddRoom(vertex, roomDescription);
}
var corridorCounter = graph.VerticesCount;
foreach (var edge in graph.Edges)
{
if (corridorRoomDescription != null)
{
mapDescription.AddRoom(corridorCounter, corridorRoomDescription);
mapDescription.AddConnection(corridorCounter, edge.From);
mapDescription.AddConnection(corridorCounter, edge.To);
corridorCounter++;
}
else
{
mapDescription.AddConnection(edge.From, edge.To);
}
}
return(mapDescription);
}
/// <summary>
/// Gets a room description that cannot be draw because every room template has only a single door position
/// but there is a room that should be connected to two other rooms.
/// </summary>
/// <returns></returns>
public static MapDescription <int> GetImpossibleMapDescription()
{
var roomShape = PolygonGrid2D.GetSquare(3);
var doorPositions = new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(0, 1)),
};
var roomTemplate = new RoomTemplate(roomShape, new ManualDoorMode(doorPositions), TransformationGrid2DHelper.GetAllTransformationsOld().ToList());
var roomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
roomTemplate
});
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0, roomDescription);
mapDescription.AddRoom(1, roomDescription);
mapDescription.AddRoom(2, roomDescription);
mapDescription.AddConnection(0, 1);
mapDescription.AddConnection(0, 2);
return(mapDescription);
}
public static void RunOld(Options options)
{
// TODO: make better
Directory = Path.Combine("DungeonGeneratorEvolutions", FileNamesHelper.PrefixWithTimestamp(options.Name));
System.IO.Directory.CreateDirectory(Directory);
Logger = new Logger(new ConsoleLoggerHandler(), new FileLoggerHandler(Path.Combine(Directory, "log.txt")));
var allGraphs = new Dictionary <string, Tuple <string, IGraph <int> > >()
{
{ "1", Tuple.Create("Example 1 (fig. 1)", GraphsDatabase.GetExample1()) },
{ "2", Tuple.Create("Example 2 (fig. 7 top)", GraphsDatabase.GetExample2()) },
{ "3", Tuple.Create("Example 3 (fig. 7 bottom)", GraphsDatabase.GetExample3()) },
{ "4", Tuple.Create("Example 4 (fig. 8)", GraphsDatabase.GetExample4()) },
{ "5", Tuple.Create("Example 5 (fig. 9)", GraphsDatabase.GetExample5()) },
};
var mapDescriptions = new Dictionary <string, Tuple <string, MapDescription <int> > >()
{
{ "gungeon_1_1", Tuple.Create("Gungeon 1_1", LoadMapDescription("gungeon_1_1")) },
{ "gungeon_1_2", Tuple.Create("Gungeon 1_2", LoadMapDescription("gungeon_1_2")) },
{ "gungeon_2_1", Tuple.Create("Gungeon 2_1", LoadMapDescription("gungeon_2_1")) },
{ "gungeon_2_2", Tuple.Create("Gungeon 2_2", LoadMapDescription("gungeon_2_2")) },
// { "gungeon_2_4", Tuple.Create("Gungeon 2_4", LoadMapDescription("gungeon_2_4")) },
};
var allAnalyzers = new Dictionary <string, Func <IMapDescription <int>, IPerformanceAnalyzer <DungeonGeneratorConfiguration <int>, Individual <int> > > >()
{
{ "MaxStageTwoFailures", (_) => new MaxStageTwoFailuresAnalyzer <DungeonGeneratorConfiguration <int>, GeneratorData>() },
{ "MaxIterations", (_) => new MaxIterationsAnalyzer <DungeonGeneratorConfiguration <int>, GeneratorData>() },
{ "ChainMerge", (_) => new ChainMergeAnalyzer <DungeonGeneratorConfiguration <int>, int, GeneratorData>() },
{ "ChainOrder", (_) => new ChainOrderAnalyzer <DungeonGeneratorConfiguration <int>, int, GeneratorData>() },
{ "MaxBranching", (_) => new MaxBranchingAnalyzer <DungeonGeneratorConfiguration <int>, GeneratorData>() },
{ "ChainDecomposition", (mapDescription) => new ChainDecompositionAnalyzer <DungeonGeneratorConfiguration <int>, int, GeneratorData>(mapDescription) },
};
// Select graphs
var graphs =
options.Graphs.Count() != 0
? options
.Graphs
.Select(x => allGraphs[x])
.ToList()
: allGraphs.Values.ToList();
graphs = options
.Graphs
.Select(x => allGraphs[x])
.ToList();
// Select analyzers
var analyzers =
options.Mutations.Count() != 0
? options
.Mutations
.Select(x => allAnalyzers[x])
.ToList()
: allAnalyzers.Values.ToList();
var inputs = new List <Input>();
foreach (var graphPair in graphs)
{
foreach (var corridorOffset in options.CorridorOffsets)
{
var corridorOffsets = corridorOffset.Split(",").Select(x => int.Parse(x)).ToList();
var withCorridors = corridorOffsets[0] != 0;
var canTouch = options.CanTouch || !withCorridors;
var name = MapDescriptionUtils.GetInputName(graphPair.Item1, options.Scale, withCorridors,
corridorOffsets, canTouch);
var graph = graphPair.Item2;
var basicRoomTemplates = MapDescriptionUtils.GetBasicRoomTemplates(options.Scale);
var basicRoomDescription = new BasicRoomDescription(basicRoomTemplates);
var corridorRoomTemplates = withCorridors ? MapDescriptionUtils.GetCorridorRoomTemplates(corridorOffsets) : null;
var corridorRoomDescription = withCorridors ? new CorridorRoomDescription(corridorRoomTemplates) : null;
var mapDescription = MapDescriptionUtils.GetBasicMapDescription(graph, basicRoomDescription,
corridorRoomDescription, withCorridors);
inputs.Add(new Input()
{
Name = name,
MapDescription = mapDescription,
Configuration = new DungeonGeneratorConfiguration <int>()
{
RoomsCanTouch = canTouch,
}
});
}
}
foreach (var mapDescriptionKey in options.MapDescriptions)
{
var mapDescription = mapDescriptions[mapDescriptionKey];
inputs.Add(new Input()
{
Name = mapDescription.Item1,
MapDescription = mapDescription.Item2,
Configuration = new DungeonGeneratorConfiguration <int>()
{
RoomsCanTouch = options.CanTouch,
}
});
}
var resultsDict = new Dictionary <Input, Result>();
var partitioner = Partitioner.Create(inputs, EnumerablePartitionerOptions.NoBuffering);
Parallel.ForEach(partitioner, new ParallelOptions {
MaxDegreeOfParallelism = options.MaxThreads
}, input =>
{
lock (Logger)
{
Logger.WriteLine($"Started {input.Name}");
}
var result = RunEvolution(input, options, analyzers.Select(x => x(input.MapDescription)).ToList());
lock (Logger)
{
Logger.WriteLine($"Ended {input.Name}");
}
lock (resultsDict)
{
resultsDict[input] = result;
}
});
var results = inputs.Select(x => resultsDict[x]).ToList();
Logger.WriteLine();
AnalyzeMutations(results.ToList());
var inputsNewConfigurations = results.Select(x =>
new DungeonGeneratorInput <int>(x.Input.Name, x.Input.MapDescription, x.NewConfiguration));
var inputsOldConfigurations = results.Select(x =>
new DungeonGeneratorInput <int>(x.Input.Name, x.Input.MapDescription, x.Input.Configuration));
var benchmarkRunner = new BenchmarkRunner <IMapDescription <int> >();
var benchmarkScenarioNew = new BenchmarkScenario <IMapDescription <int> >("NewConfigurations", GetGeneratorRunnerFactory);
var benchmarkScenarioOld = new BenchmarkScenario <IMapDescription <int> >("OldConfigurations", GetGeneratorRunnerFactory);
var resultSaver = new BenchmarkResultSaver();
var scenarioResultNew = benchmarkRunner.Run(benchmarkScenarioNew, inputsNewConfigurations, options.FinalEvaluationIterations, new BenchmarkOptions()
{
WithConsolePreview = false,
});
resultSaver.SaveResultDefaultLocation(scenarioResultNew, directory: Directory);
var scenarioResultOld = benchmarkRunner.Run(benchmarkScenarioOld, inputsOldConfigurations, options.FinalEvaluationIterations, new BenchmarkOptions()
{
WithConsolePreview = false,
});
resultSaver.SaveResultDefaultLocation(scenarioResultOld, directory: Directory);
}
public MapDescription <int> GetMapDescription()
{
const bool useLongCorridors = false;
const bool useLShapedCorridors = false;
const bool useWideCorridors = false;
// Create basic room templates and room description
var doorMode = new SimpleDoorMode(1, 1);
var squareRoom = new RoomTemplate(
PolygonGrid2D.GetSquare(8),
doorMode
);
var rectangleRoom = new RoomTemplate(
PolygonGrid2D.GetRectangle(6, 10),
doorMode,
new List <TransformationGrid2D>()
{
TransformationGrid2D.Identity, TransformationGrid2D.Rotate90
}
);
var basicRoomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
squareRoom, rectangleRoom
});
// Basic corridor shape
var corridorRoom1x2 = new RoomTemplate(
PolygonGrid2D.GetRectangle(1, 2),
new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(1, 0)),
new OrthogonalLineGrid2D(new Vector2Int(0, 2), new Vector2Int(1, 2))
}),
new List <TransformationGrid2D>()
{
TransformationGrid2D.Identity, TransformationGrid2D.Rotate90
}
);
var corridorRoomDescription = new CorridorRoomDescription(new List <RoomTemplate>()
{
corridorRoom1x2
});
// Add longer corridor
if (useLongCorridors)
{
var corridorRoom1x4 = new RoomTemplate(
PolygonGrid2D.GetRectangle(1, 4),
new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 0), new Vector2Int(1, 0)),
new OrthogonalLineGrid2D(new Vector2Int(0, 4), new Vector2Int(1, 4))
}),
new List <TransformationGrid2D>()
{
TransformationGrid2D.Identity, TransformationGrid2D.Rotate90
}
);
corridorRoomDescription.RoomTemplates.Add(corridorRoom1x4);
}
// Add l-shaped corridor
if (useLShapedCorridors)
{
var corridorRoomLShaped = new RoomTemplate(
new PolygonGrid2DBuilder()
.AddPoint(0, 2)
.AddPoint(0, 3)
.AddPoint(3, 3)
.AddPoint(3, 0)
.AddPoint(2, 0)
.AddPoint(2, 2)
.Build(),
new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(0, 2), new Vector2Int(0, 3)),
new OrthogonalLineGrid2D(new Vector2Int(2, 0), new Vector2Int(3, 0))
}),
TransformationGrid2DHelper.GetAllTransformationsOld().ToList()
);
corridorRoomDescription.RoomTemplates.Add(corridorRoomLShaped);
}
// Add wide corridor
if (useWideCorridors)
{
var corridorWide = new RoomTemplate(
new PolygonGrid2DBuilder()
.AddPoint(1, 0)
.AddPoint(1, 1)
.AddPoint(0, 1)
.AddPoint(0, 4)
.AddPoint(1, 4)
.AddPoint(1, 5)
.AddPoint(2, 5)
.AddPoint(2, 4)
.AddPoint(3, 4)
.AddPoint(3, 1)
.AddPoint(2, 1)
.AddPoint(2, 0)
.Build(),
new ManualDoorMode(new List <OrthogonalLineGrid2D>()
{
new OrthogonalLineGrid2D(new Vector2Int(1, 0), new Vector2Int(2, 0)),
new OrthogonalLineGrid2D(new Vector2Int(1, 5), new Vector2Int(2, 5))
}),
TransformationGrid2DHelper.GetAllTransformationsOld().ToList()
);
corridorRoomDescription.RoomTemplates.Add(corridorWide);
}
// Create map description
var mapDescription = new MapDescription <int>();
var graph = GraphsDatabase.GetExample1();
// Add non-corridor rooms
foreach (var room in graph.Vertices)
{
mapDescription.AddRoom(room, basicRoomDescription);
}
// We need to somehow identify our corridor rooms
// Here we simply number them and keep track which was the last used number
var counter = graph.VerticesCount;
foreach (var connection in graph.Edges)
{
if (true)
{
if (true)
{
if (connection.From % 2 == 0 && connection.To % 2 == 0)
{
// We manually insert a new node between each neighboring nodes in the graph
mapDescription.AddRoom(counter, corridorRoomDescription);
// And instead of connecting the rooms directly, we connect them to the corridor room
mapDescription.AddConnection(connection.From, counter);
mapDescription.AddConnection(connection.To, counter);
counter++;
}
else
{
mapDescription.AddConnection(connection.From, connection.To);
}
}
else
{
var desc1 = new CorridorRoomDescription(new List <RoomTemplate>()
{
corridorRoomDescription.RoomTemplates[0]
});
var desc2 = new CorridorRoomDescription(new List <RoomTemplate>()
{
corridorRoomDescription.RoomTemplates[1]
});
// We manually insert a new node between each neighboring nodes in the graph
mapDescription.AddRoom(counter, connection.From % 2 == 0 && connection.To % 2 == 0 ? desc2 : desc1);
// And instead of connecting the rooms directly, we connect them to the corridor room
mapDescription.AddConnection(connection.From, counter);
mapDescription.AddConnection(connection.To, counter);
counter++;
}
}
else
{
// We manually insert a new node between each neighboring nodes in the graph
mapDescription.AddRoom(counter, corridorRoomDescription);
// And instead of connecting the rooms directly, we connect them to the corridor room
mapDescription.AddConnection(connection.From, counter);
mapDescription.AddConnection(connection.To, counter);
counter++;
}
}
return(mapDescription);
}
public void Run()
{
var rectangularRoomTemplates = MapDescriptionUtils.GetRectangularRoomTemplates(new Vector2Int(1, 1));
var basicRoomDescription = new BasicRoomDescription(rectangularRoomTemplates);
var inputs = new List <DungeonGeneratorInput <int> >();
inputs.AddRange(Program.GetMapDescriptionsSet(new Vector2Int(1, 1), false, null, true));
inputs.AddRange(Program.GetMapDescriptionsSet(new Vector2Int(1, 1), false, null, true, basicRoomDescription: basicRoomDescription, suffix: "rect shapes"));
inputs.AddRange(Program.GetMapDescriptionsSet(new Vector2Int(1, 1), true, new List <int>()
{
2
}, false));
inputs.Add(LoadInput("gungeon_1_1"));
inputs.Add(LoadInput("gungeon_1_1", true));
inputs.Add(LoadInput("gungeon_1_2"));
inputs.Add(LoadInput("gungeon_1_2", true));
inputs.Add(LoadInput("gungeon_2_1"));
inputs.Add(LoadInput("gungeon_2_1", true));
inputs.Add(LoadInput("gungeon_2_2"));
inputs.Add(LoadInput("gungeon_2_2", true));
foreach (var input in inputs)
{
var mapDescription = input.MapDescription;
var graph = mapDescription.GetStageOneGraph();
Console.WriteLine($"{input.Name} {graph.VerticesCount} {graph.Edges.Count()}");
}
if (true)
{
inputs.Sort((x1, x2) => string.Compare(x1.Name, x2.Name, StringComparison.Ordinal));
}
inputs = inputs.Where(x => !x.Name.StartsWith("Example 4")).ToList();
var layoutDrawer = new SVGLayoutDrawer <int>();
var benchmarkRunner = new BenchmarkRunner <IMapDescription <int> >();
var benchmarkScenario = new BenchmarkScenario <IMapDescription <int> >("CorridorConfigurationSpaces", input =>
{
var dungeonGeneratorInput = (DungeonGeneratorInput <int>)input;
var layoutGenerator = new DungeonGenerator <int>(input.MapDescription, dungeonGeneratorInput.Configuration);
layoutGenerator.InjectRandomGenerator(new Random(0));
return(new LambdaGeneratorRunner(() =>
{
var simulatedAnnealingArgsContainer = new List <SimulatedAnnealingEventArgs>();
void SimulatedAnnealingEventHandler(object sender, SimulatedAnnealingEventArgs eventArgs)
{
simulatedAnnealingArgsContainer.Add(eventArgs);
}
layoutGenerator.OnSimulatedAnnealingEvent += SimulatedAnnealingEventHandler;
var layout = layoutGenerator.GenerateLayout();
layoutGenerator.OnSimulatedAnnealingEvent -= SimulatedAnnealingEventHandler;
var additionalData = new AdditionalRunData()
{
SimulatedAnnealingEventArgs = simulatedAnnealingArgsContainer,
GeneratedLayoutSvg = layoutDrawer.DrawLayout(layout, 800, forceSquare: true),
GeneratedLayout = layout,
};
var generatorRun = new GeneratorRun <AdditionalRunData>(layout != null, layoutGenerator.TimeTotal, layoutGenerator.IterationsCount, additionalData);
return generatorRun;
}));
});
public MapDescription <int> GetMapDescription()
{
// Create boss room template and room description
var bossRoom = new RoomTemplate(
new PolygonGrid2DBuilder()
.AddPoint(2, 0).AddPoint(2, 1).AddPoint(1, 1).AddPoint(1, 2)
.AddPoint(0, 2).AddPoint(0, 7).AddPoint(1, 7).AddPoint(1, 8)
.AddPoint(2, 8).AddPoint(2, 9).AddPoint(7, 9).AddPoint(7, 8)
.AddPoint(8, 8).AddPoint(8, 7).AddPoint(9, 7).AddPoint(9, 2)
.AddPoint(8, 2).AddPoint(8, 1).AddPoint(7, 1).AddPoint(7, 0)
.Build().Scale(new Vector2Int(2, 2)),
new SimpleDoorMode(1, 1)
);
var bossRoomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
bossRoom
});
// Create basic room templates and room description
var doorMode = new SimpleDoorMode(1, 1);
var squareRoom = new RoomTemplate(
PolygonGrid2D.GetSquare(8),
doorMode
);
var rectangleRoom = new RoomTemplate(
PolygonGrid2D.GetRectangle(6, 10),
doorMode,
new List <TransformationGrid2D>()
{
TransformationGrid2D.Identity, TransformationGrid2D.Rotate90
}
);
var basicRoomDescription = new BasicRoomDescription(new List <RoomTemplate>()
{
squareRoom, rectangleRoom
});
// Create map description
var mapDescription = new MapDescription <int>();
// Get graph
var graph = GraphsDatabase.GetExample2();
// Add boss room
mapDescription.AddRoom(8, bossRoomDescription);
// Add other rooms
foreach (var vertex in graph.Vertices.Where(x => x != 8))
{
mapDescription.AddRoom(vertex, basicRoomDescription);
}
// Add connections
foreach (var connection in graph.Edges)
{
mapDescription.AddConnection(connection.From, connection.To);
}
return(mapDescription);
}
