/// <inheritdoc />
public virtual void PerturbShape(TLayout layout, IList <TNode> chain, bool updateLayout)
{
var canBePerturbed = chain
.Where(x => MapDescription.GetRoomDescription(x).Stage == 1) // TODO: handle better
.Where(x => ConfigurationSpaces.CanPerturbShape(x))
.ToList();
if (canBePerturbed.Count == 0)
{
return;
}
PerturbShape(layout, canBePerturbed.GetRandom(Random), updateLayout);
}
private void DoMapping()
{
var graph = mapDescription.GetGraph();
var stageOneGraph = mapDescription.GetStageOneGraph();
foreach (var vertex in graph.Vertices)
{
// Create vertices mapping
nodeToIntMapping.Add(vertex, nodeToIntMapping.Count);
mappedGraph.AddVertex(nodeToIntMapping[vertex]);
// Store room description
roomDescriptions[nodeToIntMapping[vertex]] = mapDescription.GetRoomDescription(vertex);
}
// Handle main graph edges
foreach (var edge in graph.Edges)
{
mappedGraph.AddEdge(nodeToIntMapping[edge.From], nodeToIntMapping[edge.To]);
}
// Handle stage one graph vertices
foreach (var vertex in stageOneGraph.Vertices)
{
mappedStageOneGraph.AddVertex(nodeToIntMapping[vertex]);
}
// Handle stage one graph edges
foreach (var edge in stageOneGraph.Edges)
{
mappedStageOneGraph.AddEdge(nodeToIntMapping[edge.From], nodeToIntMapping[edge.To]);
}
}
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());
}
/// <inheritdoc />
public bool ComputeEnergyData(TLayout layout, TNode node, TConfiguration configuration, ref TEnergyData energyData)
{
if (mapDescription.GetRoomDescription(node).GetType() == typeof(CorridorRoomDescription))
{
return(true);
}
var numberOfTouching = 0;
foreach (var vertex in layout.Graph.Vertices)
{
if (vertex.Equals(node))
{
continue;
}
if (!layout.GetConfiguration(vertex, out var c))
{
continue;
}
if (mapDescription.GetRoomDescription(vertex).GetType() == typeof(CorridorRoomDescription))
{
continue;
}
if (AreNeighbours(node, vertex))
{
continue;
}
if (DoTouch(configuration, c))
{
numberOfTouching++;
}
}
energyData.NumberOfTouching = numberOfTouching;
energyData.Energy += numberOfTouching;
return(numberOfTouching == 0);
}
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));
}
/// <inheritdoc />
public bool ComputeEnergyData(TLayout layout, TNode node, TConfiguration configuration, ref TEnergyData energyData)
{
if (mapDescription.GetRoomDescription(node).GetType() == typeof(CorridorRoomDescription))
{
return(true);
}
var distance = 0;
var neighbours = stageOneGraph.GetNeighbours(node).ToList();
foreach (var vertex in neighbours)
{
if (vertex.Equals(node))
{
continue;
}
if (!layout.GetConfiguration(vertex, out var c))
{
continue;
}
// TODO: why wasn't this here?
if (!AreNeighboursWithoutCorridors(vertex, node))
{
continue;
}
if (!configurationSpaces.HaveValidPosition(configuration, c))
{
distance += ComputeDistance(configuration, c);
}
}
var energy = ComputeEnergy(0, distance);
energyData.CorridorDistance = distance;
energyData.Energy += energy;
return(distance == 0);
}
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 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 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);
}
/// <inheritdoc />
public List <Chain <TNode> > GetChains(IGraph <TNode> graph)
{
// Get all the faces from the stage one graph
var stageOneGraph = mapDescription.GetStageOneGraph();
var faces = decomposition.GetChains(stageOneGraph);
var usedVertices = new HashSet <TNode>();
var notUsedStageTwoRooms = graph.Vertices.Where(x => mapDescription.GetRoomDescription(x).Stage == 2).ToList();
// Iterate through all the faces, marking all the seen vertices
// As soon as all the neighbors of a stage two room are used, add the stage two room to the current face
foreach (var face in faces)
{
// TODO: weird ForEach
face.Nodes.ToList().ForEach(x => usedVertices.Add(x));
foreach (var stageTwoRoom in notUsedStageTwoRooms.ToList())
{
var neighbors = graph.GetNeighbours(stageTwoRoom).ToList();
if (neighbors.TrueForAll(x => usedVertices.Contains(x)))
{
notUsedStageTwoRooms.Remove(stageTwoRoom);
face.Nodes.Add(stageTwoRoom);
}
}
}
// It must not happen that a stage two room is not in the decomposition
if (notUsedStageTwoRooms.Count != 0)
{
throw new ArgumentException();
}
return(faces);
}
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);
}
