public TouchingConstraints(IMapDescription <TNode> mapDescription, IPolygonOverlap <TShapeContainer> polygonOverlap)
{
this.mapDescription = mapDescription;
this.polygonOverlap = polygonOverlap;
stageOneGraph = mapDescription.GetStageOneGraph();
graph = mapDescription.GetGraph();
}
public DungeonGeneratorEvolution(
IMapDescription <TNode> mapDescription,
List <IPerformanceAnalyzer <DungeonGeneratorConfiguration <TNode>, Individual <TNode> > > analyzers, EvolutionOptions options, string resultsDirectory)
: base(analyzers, options, resultsDirectory)
{
this.mapDescription = mapDescription;
}
public double ComputeRoomTemplatesEntropy <TNode>(IMapDescription <TNode> mapDescription, List <MapLayout <TNode> > layouts, TNode node, bool normalize = true)
{
var distribution = GetRoomTemplatesDistribution(mapDescription, layouts, node);
var entropy = ComputeEntropy(distribution, normalize);
return(entropy);
}
public PlatformersGenerator(IMapDescription <TNode> mapDescription, DungeonGeneratorConfiguration <TNode> configuration = null)
{
this.mapDescription = new MapDescriptionMapping <TNode>(mapDescription);
this.configuration = configuration ?? new DungeonGeneratorConfiguration <TNode>();
this.mapDescriptionOriginal = mapDescription;
SetupGenerator();
}
protected AbstractLayoutOperations(IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces, int averageSize, IMapDescription <TNode> mapDescription, IRoomShapesHandler <TLayout, TNode, TShapeContainer> roomShapesHandler)
{
ConfigurationSpaces = configurationSpaces;
AverageSize = averageSize;
MapDescription = mapDescription;
RoomShapesHandler = roomShapesHandler;
StageOneGraph = mapDescription.GetStageOneGraph();
}
public CorridorConstraints(IMapDescription <TNode> mapDescription, float averageSize, IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces)
{
this.mapDescription = mapDescription;
this.energySigma = 10 * averageSize; // TODO: should it be like this?
this.configurationSpaces = configurationSpaces;
stageOneGraph = mapDescription.GetStageOneGraph();
graph = mapDescription.GetGraph();
}
public double ComputeAverageRoomTemplatesEntropy <TNode>(IMapDescription <TNode> mapDescription, List <MapLayout <TNode> > layouts, bool normalize = true)
{
return(mapDescription
.GetGraph()
.Vertices
.Where(x => mapDescription.GetRoomDescription(x).RoomTemplates.Count > 1)
.Select(x => ComputeRoomTemplatesEntropy(mapDescription, layouts, x, normalize))
.Average());
}
public RoomShapesHandler(
IConfigurationSpaces <TNode, IntAlias <PolygonGrid2D>, TConfiguration, ConfigurationSpace> configurationSpaces,
TwoWayDictionary <RoomTemplateInstance, IntAlias <PolygonGrid2D> > intAliasMapping,
IMapDescription <TNode> mapDescription,
RoomTemplateRepeatMode?repeatModeOverride = null)
{
this.configurationSpaces = configurationSpaces;
this.intAliasMapping = intAliasMapping;
this.mapDescription = mapDescription;
this.repeatModeOverride = repeatModeOverride;
stageOneGraph = mapDescription.GetStageOneGraph();
Initialize();
}
private IMapDescription <int> GetIntMapDescription(IMapDescription <Room> mapDescription)
{
var newMapDescription = new MapDescription <int>();
var mapping = mapDescription.GetGraph().Vertices.CreateIntMapping();
foreach (var vertex in mapDescription.GetGraph().Vertices)
{
newMapDescription.AddRoom(mapping[vertex], mapDescription.GetRoomDescription(vertex));
}
foreach (var edge in mapDescription.GetGraph().Edges)
{
newMapDescription.AddConnection(mapping[edge.From], mapping[edge.To]);
}
return(newMapDescription);
}
public LayoutOperations(
IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces,
int averageSize,
IMapDescription <TNode> mapDescription,
ConstraintsEvaluator <TLayout, TNode, TConfiguration, TShapeContainer, TEnergyData> stageOneConstraintsEvaluator,
ConstraintsEvaluator <TLayout, TNode, TConfiguration, TShapeContainer, TEnergyData> stageTwoConstraintsEvaluator,
IRoomShapesHandler <TLayout, TNode, TShapeContainer> roomShapesHandler, bool throwIfRepeatModeNotSatisfied)
: base(
configurationSpaces,
averageSize,
mapDescription,
roomShapesHandler)
{
this.stageOneConstraintsEvaluator = stageOneConstraintsEvaluator;
this.stageTwoConstraintsEvaluator = stageTwoConstraintsEvaluator;
this.throwIfRepeatModeNotSatisfied = throwIfRepeatModeNotSatisfied;
}
public static double GetAverageRoomTemplateSize <TNode>(IMapDescription <TNode> mapDescription)
{
var roomTemplates = mapDescription
.GetGraph()
.Vertices
.Select(mapDescription.GetRoomDescription)
.Where(x => x is BasicRoomDescription)
.SelectMany(x => x.RoomTemplates)
.Distinct()
.ToList();
var averageSize = roomTemplates
.Select(x => x.Shape.BoundingRectangle.Width + x.Shape.BoundingRectangle.Height)
.Average();
return(averageSize);
}
public static LevelDescriptionGrid2D <TNode> GetLevelDescription <TNode>(this IMapDescription <TNode> mapDescription)
{
var levelDescription = new LevelDescriptionGrid2D <TNode>();
var graph = mapDescription.GetGraph();
var corridorRoomDescriptions = new Dictionary <IRoomDescription, RoomDescriptionGrid2D>();
var roomTemplateMapping = new Dictionary <RoomTemplate, RoomTemplateGrid2D>();
foreach (var room in graph.Vertices)
{
var roomDescription = mapDescription.GetRoomDescription(room);
if (roomDescription.IsCorridor)
{
if (corridorRoomDescriptions.TryGetValue(roomDescription, out var cached))
{
levelDescription.AddRoom(room, cached);
}
else
{
var corridorRoomDescription = new RoomDescriptionGrid2D(true, roomDescription.RoomTemplates.Select(x => GetNewRoomTemplate(x, roomTemplateMapping)).ToList());
corridorRoomDescriptions[roomDescription] = corridorRoomDescription;
levelDescription.AddRoom(room, corridorRoomDescription);
}
}
else
{
levelDescription.AddRoom(room, new RoomDescriptionGrid2D(false, roomDescription.RoomTemplates.Select(x => GetNewRoomTemplate(x, roomTemplateMapping)).ToList()));
}
}
foreach (var edge in graph.Edges)
{
levelDescription.AddConnection(edge.From, edge.To);
}
return(levelDescription);
}
public ChainDecompositionAnalyzer(IMapDescription <TNode> mapDescription)
{
this.mapDescription = mapDescription;
}
public Dictionary <RoomTemplateInstance, double> GetRoomTemplatesDistribution <TNode>(IMapDescription <TNode> mapDescription, List <MapLayout <TNode> > layouts, TNode node)
{
var roomDescription = mapDescription.GetRoomDescription(node);
var availableRoomTemplateInstances = roomDescription.RoomTemplates.SelectMany(x => configurationSpacesGenerator.GetRoomTemplateInstances(x)).ToList();
var data = layouts
.Select(x => x.Rooms.Single(y => y.Node.Equals(node)))
.Select(x => x.RoomTemplateInstance)
.ToList();
return(GetProbabilityDistribution(data, availableRoomTemplateInstances));
}
public Dictionary <Tuple <TNode, TNode>, CorridorRoomDescription> GetNodesToCorridorMapping <TNode>(IMapDescription <TNode> mapDescription)
{
var mapping = new Dictionary <Tuple <TNode, TNode>, CorridorRoomDescription>();
var graph = mapDescription.GetGraph();
foreach (var room in graph.Vertices)
{
var roomDescription = mapDescription.GetRoomDescription(room);
if (roomDescription is CorridorRoomDescription corridorRoomDescription)
{
var neighbors = graph.GetNeighbours(room).ToList();
mapping.Add(new Tuple <TNode, TNode>(neighbors[0], neighbors[1]), corridorRoomDescription);
mapping.Add(new Tuple <TNode, TNode>(neighbors[1], neighbors[0]), corridorRoomDescription);
}
}
return(mapping);
}
public NamedMapDescription(IMapDescription <int> mapDescription, string name, bool isWithCorridors)
{
MapDescription = mapDescription;
Name = name;
IsWithCorridors = isWithCorridors;
}
public DungeonGeneratorInput(string name, IMapDescription <TNode> mapDescription, DungeonGeneratorConfiguration <TNode> configuration) : base(name, mapDescription)
{
Configuration = configuration;
}
private void method_1(ref IMapDescription imapDescription_0, ref IMapServer imapServer_1)
{
}
public ConfigurationSpaces <TConfiguration> GetConfigurationSpaces <TConfiguration>(IMapDescription <int> mapDescription)
where TConfiguration : IConfiguration <IntAlias <PolygonGrid2D>, int>
{
var graph = mapDescription.GetGraph();
var roomDescriptions = graph
.Vertices
.ToDictionary(x => x, mapDescription.GetRoomDescription);
var roomTemplates = roomDescriptions
.Values
.SelectMany(x => x.RoomTemplates)
.Distinct()
.ToList();
var roomTemplateInstances = roomTemplates
.ToDictionary(x => x, GetRoomTemplateInstances);
var roomTemplateInstancesMapping = roomTemplateInstances
.SelectMany(x => x.Value)
.CreateIntMapping();
var roomTemplateInstancesCount = roomTemplateInstancesMapping.Count;
var corridorRoomDescriptionsMapping = roomDescriptions
.Values
.Where(x => x.GetType() == typeof(CorridorRoomDescription))
.Cast <CorridorRoomDescription>()
.Distinct()
.CreateIntMapping();
var corridorRoomTemplateInstances = corridorRoomDescriptionsMapping
.Keys
.ToDictionary(
x => x,
x => x.RoomTemplates.SelectMany(y => roomTemplateInstances[y]).ToList());
var nodesToCorridorMapping = GetNodesToCorridorMapping(mapDescription)
.ToDictionary(
x => x.Key,
x => corridorRoomDescriptionsMapping[x.Value] + 1
);
var configurationSpaces = new ConfigurationSpaces <TConfiguration>(lineIntersection,
roomTemplateInstancesCount, graph.VerticesCount, (configuration1, configuration2) =>
{
if (nodesToCorridorMapping.TryGetValue(new Tuple <int, int>(configuration1.Node, configuration2.Node), out var corridor))
{
return(corridor);
}
return(0);
});
// Generate configuration spaces
foreach (var shape1 in roomTemplateInstancesMapping.Keys)
{
foreach (var shape2 in roomTemplateInstancesMapping.Keys)
{
var configurationSpacesList = new ConfigurationSpace[corridorRoomDescriptionsMapping.Count + 1];
configurationSpacesList[0] = GetConfigurationSpace(shape1, shape2);
foreach (var pair in corridorRoomDescriptionsMapping)
{
var roomDescription = pair.Key;
var intAlias = pair.Value;
configurationSpacesList[intAlias + 1] = GetConfigurationSpaceOverCorridors(shape1, shape2,
corridorRoomTemplateInstances[roomDescription]);
}
configurationSpaces.AddConfigurationSpace(shape1, shape2, configurationSpacesList.ToArray());
}
}
foreach (var vertex in graph.Vertices)
{
var roomDescription = mapDescription.GetRoomDescription(vertex);
foreach (var roomTemplate in roomDescription.RoomTemplates)
{
var instances = roomTemplateInstances[roomTemplate];
foreach (var roomTemplateInstance in instances)
{
configurationSpaces.AddShapeForNode(vertex, roomTemplateInstance, 1d / instances.Count);
}
}
}
return(configurationSpaces);
}
public MapDescriptionMapping(IMapDescription <TNode> mapDescription)
{
this.mapDescription = mapDescription;
roomDescriptions = new IRoomDescription[mapDescription.GetGraph().VerticesCount];
DoMapping();
}
public NamedMapDescription(IMapDescription <int> mapDescription, NamedGraph graph, bool isWithCorridors)
{
MapDescription = mapDescription;
IsWithCorridors = isWithCorridors;
Name = graph.Name;
}
public TwoStageChainDecomposition(IMapDescription <TNode> mapDescription, IChainDecomposition <TNode> decomposition)
{
this.mapDescription = mapDescription;
this.decomposition = decomposition;
}
public SimpleDungeonGeneratorEvolution(IMapDescription <TNode> mapDescription, List <IPerformanceAnalyzer <DungeonGeneratorConfiguration <TNode>, Individual <TNode> > > analyzers, EvolutionOptions options, string resultsDirectory) : base(mapDescription, analyzers, options, resultsDirectory)
{
OnEvolutionStarted += () => generationNumber = 0;
}
public DungeonGeneratorInput(string name, IMapDescription <TNode> mapDescription, DungeonGeneratorConfiguration <TNode> configuration, List <int> offsets) : base(name, mapDescription)
{
Configuration = configuration;
Offsets = offsets;
}
