/// <summary>
/// Gets a basic layout generator that should not be used to generated layouts with corridors.
/// </summary>
/// <typeparam name="TNode"></typeparam>
/// <returns></returns>
public static ChainBasedGenerator <MapDescription <TNode>, Layout <Configuration <EnergyData>, BasicEnergyData>, int, Configuration <EnergyData>, IMapLayout <TNode> > GetDefaultChainBasedGenerator <TNode>()
{
var layoutGenerator = new ChainBasedGenerator <MapDescription <TNode>, Layout <Configuration <EnergyData>, BasicEnergyData>, int, Configuration <EnergyData>, IMapLayout <TNode> >();
var chainDecomposition = new BreadthFirstChainDecomposition <int>(new GraphDecomposer <int>());
var configurationSpacesGenerator = new ConfigurationSpacesGenerator(new PolygonOverlap(), DoorHandler.DefaultHandler, new OrthogonalLineIntersection(), new GridPolygonUtils());
var generatorPlanner = new BasicGeneratorPlanner <Layout <Configuration <EnergyData>, BasicEnergyData> >();
layoutGenerator.SetChainDecompositionCreator(mapDescription => chainDecomposition);
layoutGenerator.SetConfigurationSpacesCreator(mapDescription => configurationSpacesGenerator.Generate <TNode, Configuration <EnergyData> >(mapDescription));
layoutGenerator.SetInitialLayoutCreator(mapDescription => new Layout <Configuration <EnergyData>, BasicEnergyData>(mapDescription.GetGraph()));
layoutGenerator.SetGeneratorPlannerCreator(mapDescription => generatorPlanner);
layoutGenerator.SetLayoutConverterCreator((mapDescription, configurationSpaces) => new BasicLayoutConverter <Layout <Configuration <EnergyData>, BasicEnergyData>, TNode, Configuration <EnergyData> >(mapDescription, configurationSpaces, configurationSpacesGenerator.LastIntAliasMapping));
layoutGenerator.SetLayoutEvolverCreator((mapDescription, layoutOperations) => new SimulatedAnnealingEvolver <Layout <Configuration <EnergyData>, BasicEnergyData>, int, Configuration <EnergyData> >(layoutOperations));
layoutGenerator.SetLayoutOperationsCreator((mapDescription, configurationSpaces) =>
{
var layoutOperations = new LayoutOperationsWithConstraints <Layout <Configuration <EnergyData>, BasicEnergyData>, int, Configuration <EnergyData>, IntAlias <GridPolygon>, EnergyData, BasicEnergyData>(configurationSpaces, configurationSpaces.GetAverageSize());
var averageSize = configurationSpaces.GetAverageSize();
layoutOperations.AddNodeConstraint(new BasicContraint <Layout <Configuration <EnergyData>, BasicEnergyData>, int, Configuration <EnergyData>, EnergyData, IntAlias <GridPolygon> >(
new FastPolygonOverlap(),
averageSize,
configurationSpaces
));
return(layoutOperations);
});
return(layoutGenerator);
}
/// <summary>
/// Gets a generator that can work with corridors.
/// </summary>
/// <remarks>
/// TODO: This is only a temporary solution because we must be able to inject our own corridor nodes creator and this is the easiest way right now.
/// </remarks>
/// <param name="offsets"></param>
/// <param name="canTouch">Whether rooms can touch. Perfomance is decreased when set to false.</param>
/// <param name="corridorNodesCreator"></param>
/// <returns></returns>
public static ChainBasedGenerator <MapDescription <TNode>, Layout <Configuration <CorridorsData>, BasicEnergyData>, int, Configuration <CorridorsData>, IMapLayout <TNode> > GetChainBasedGeneratorWithCorridors <TNode>(List <int> offsets, bool canTouch = false, ICorridorNodesCreator <TNode> corridorNodesCreator = null)
{
var layoutGenerator = new ChainBasedGenerator <MapDescription <TNode>, Layout <Configuration <CorridorsData>, BasicEnergyData>, int, Configuration <CorridorsData>, IMapLayout <TNode> >();
var chainDecomposition = new BreadthFirstChainDecomposition <int>();
var configurationSpacesGenerator = new ConfigurationSpacesGenerator(new PolygonOverlap(), DoorHandler.DefaultHandler, new OrthogonalLineIntersection(), new GridPolygonUtils());
var generatorPlanner = new BasicGeneratorPlanner <Layout <Configuration <CorridorsData>, BasicEnergyData> >();
layoutGenerator.SetChainDecompositionCreator(mapDescription => new CorridorsChainDecomposition <int>(mapDescription, chainDecomposition));
layoutGenerator.SetConfigurationSpacesCreator(mapDescription => configurationSpacesGenerator.Generate <TNode, Configuration <CorridorsData> >(mapDescription));
layoutGenerator.SetInitialLayoutCreator(mapDescription => new Layout <Configuration <CorridorsData>, BasicEnergyData>(mapDescription.GetGraph()));
layoutGenerator.SetGeneratorPlannerCreator(mapDescription => generatorPlanner);
layoutGenerator.SetLayoutConverterCreator((mapDescription, configurationSpaces) => new BasicLayoutConverter <Layout <Configuration <CorridorsData>, BasicEnergyData>, TNode, Configuration <CorridorsData> >(mapDescription, configurationSpaces, configurationSpacesGenerator.LastIntAliasMapping, corridorNodesCreator));
layoutGenerator.SetLayoutEvolverCreator((mapDescription, layoutOperations) => new SimulatedAnnealingEvolver <Layout <Configuration <CorridorsData>, BasicEnergyData>, int, Configuration <CorridorsData> >(layoutOperations));
layoutGenerator.SetLayoutOperationsCreator((mapDescription, configurationSpaces) =>
{
var corridorConfigurationSpaces = configurationSpacesGenerator.Generate <TNode, Configuration <CorridorsData> >(mapDescription, offsets);
var layoutOperations = new LayoutOperationsWithCorridors <Layout <Configuration <CorridorsData>, BasicEnergyData>, int, Configuration <CorridorsData>, IntAlias <GridPolygon>, CorridorsData, BasicEnergyData>(configurationSpaces, mapDescription, corridorConfigurationSpaces, configurationSpaces.GetAverageSize());
var polygonOverlap = new FastPolygonOverlap();
var averageSize = configurationSpaces.GetAverageSize();
layoutOperations.AddNodeConstraint(new BasicContraint <Layout <Configuration <CorridorsData>, BasicEnergyData>, int, Configuration <CorridorsData>, CorridorsData, IntAlias <GridPolygon> >(
polygonOverlap,
averageSize,
configurationSpaces
));
layoutOperations.AddNodeConstraint(new CorridorConstraints <Layout <Configuration <CorridorsData>, BasicEnergyData>, int, Configuration <CorridorsData>, CorridorsData, IntAlias <GridPolygon> >(
mapDescription,
averageSize,
corridorConfigurationSpaces
));
if (!canTouch)
{
layoutOperations.AddNodeConstraint(new TouchingConstraints <Layout <Configuration <CorridorsData>, BasicEnergyData>, int, Configuration <CorridorsData>, CorridorsData, IntAlias <GridPolygon> >(
mapDescription,
polygonOverlap
));
}
return(layoutOperations);
});
return(layoutGenerator);
}
private void SetupGenerator()
{
var mapping = mapDescription.GetMapping();
var chainsGeneric = configuration.Chains;
if (chainsGeneric == null)
{
var chainDecomposition = new TwoStageChainDecomposition <TNode>(mapDescriptionOriginal, new BreadthFirstChainDecomposition <TNode>(configuration.ChainDecompositionConfiguration ?? new ChainDecompositionConfiguration()));
chainsGeneric = chainDecomposition.GetChains(mapDescriptionOriginal.GetGraph());
}
var chains = chainsGeneric
.Select(x => new Chain <int>(x.Nodes.Select(y => mapping[y]).ToList(), x.Number))
.ToList();
var generatorPlanner = new GeneratorPlanner <Layout <Configuration <CorridorsData> >, int>(configuration.SimulatedAnnealingMaxBranching);
var configurationSpacesGenerator = new ConfigurationSpacesGenerator(
new PolygonOverlap(),
DoorHandler.DefaultHandler,
new OrthogonalLineIntersection(),
new GridPolygonUtils());
var configurationSpaces = configurationSpacesGenerator.GetConfigurationSpaces <Configuration <CorridorsData> >(mapDescription);
//var corridorConfigurationSpaces = mapDescription.IsWithCorridors ? configurationSpacesGenerator.Generate<TNode, Configuration<CorridorsData>>(mapDescription, mapDescription.CorridorsOffsets) : configurationSpaces;
var corridorConfigurationSpaces = configurationSpaces;
var averageSize = configurationSpaces.GetAverageSize();
var polygonOverlap = new FastPolygonOverlap();
var stageOneConstraints =
new List <INodeConstraint <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>,
CorridorsData> >
{
new BasicConstraint <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>,
CorridorsData, IntAlias <PolygonGrid2D> >(
new FastPolygonOverlap(),
averageSize,
configurationSpaces
),
new CorridorConstraints <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, CorridorsData, IntAlias <PolygonGrid2D> >(
mapDescription,
averageSize,
corridorConfigurationSpaces
),
};
if (!configuration.RoomsCanTouch)
{
stageOneConstraints.Add(new TouchingConstraints <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, CorridorsData, IntAlias <PolygonGrid2D> >(
mapDescription,
polygonOverlap
));
}
var stageOneConstraintsEvaluator = new ConstraintsEvaluator <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, IntAlias <PolygonGrid2D>, CorridorsData>(stageOneConstraints);
//if (mapDescription.IsWithCorridors)
//{
// layoutOperations.AddNodeConstraint(new CorridorConstraints<Layout<Configuration<CorridorsData>>, int, Configuration<CorridorsData>, CorridorsData, IntAlias<GridPolygon>>(
// mapDescription,
// averageSize,
// corridorConfigurationSpaces
// ));
// if (!false) // TODO:
// {
// var polygonOverlap = new FastPolygonOverlap();
// layoutOperations.AddNodeConstraint(new TouchingConstraints<Layout<Configuration<CorridorsData>>, int, Configuration<CorridorsData>, CorridorsData, IntAlias<GridPolygon>>(
// mapDescription,
// polygonOverlap
// ));
// }
//}
var roomShapesHandler = new RoomShapesHandler <int, Configuration <CorridorsData> >(
configurationSpaces,
configurationSpaces.GetIntAliasMapping(),
mapDescription,
configuration.RepeatModeOverride
);
var layoutOperations = new LayoutOperations <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, IntAlias <PolygonGrid2D>, CorridorsData>(corridorConfigurationSpaces, configurationSpaces.GetAverageSize(), mapDescription, stageOneConstraintsEvaluator, stageOneConstraintsEvaluator, roomShapesHandler, configuration.ThrowIfRepeatModeNotSatisfied);
var initialLayout = new Layout <Configuration <CorridorsData> >(mapDescription.GetGraph());
var layoutConverter =
new BasicLayoutConverter <Layout <Configuration <CorridorsData> >, TNode,
Configuration <CorridorsData> >(mapDescription, configurationSpaces,
configurationSpaces.GetIntAliasMapping());
var layoutEvolver =
new PlatformersEvolver <Layout <Configuration <CorridorsData> >, int,
Configuration <CorridorsData> >(layoutOperations);
generator = new ChainBasedGenerator <Layout <Configuration <CorridorsData> >, MapLayout <TNode>, int>(initialLayout, generatorPlanner, chains, layoutEvolver, layoutConverter);
generator.OnRandomInjected += (random) =>
{
((IRandomInjectable)configurationSpaces).InjectRandomGenerator(random);
((IRandomInjectable)layoutOperations).InjectRandomGenerator(random);
((IRandomInjectable)layoutEvolver).InjectRandomGenerator(random);
((IRandomInjectable)layoutConverter).InjectRandomGenerator(random);
};
generator.OnCancellationTokenInjected += (token) =>
{
((ICancellable)generatorPlanner).SetCancellationToken(token);
((ICancellable)layoutEvolver).SetCancellationToken(token);
};
// layoutEvolver.OnEvent += (sender, args) => OnSimulatedAnnealingEvent?.Invoke(sender, args);
layoutEvolver.OnPerturbed += (sender, layout) => OnPerturbed?.Invoke(layoutConverter.Convert(layout, false));
layoutEvolver.OnPerturbed += (sender, layout) => OnPerturbedInternal?.Invoke(layout);
layoutEvolver.OnValid += (sender, layout) => OnPartialValid?.Invoke(layoutConverter.Convert(layout, true));
generatorPlanner.OnLayoutGenerated += layout => OnValid?.Invoke(layoutConverter.Convert(layout, true));
}
private void SetupGenerator()
{
var mapping = levelDescriptionMapped.GetMapping();
var chainsGeneric = configuration.Chains;
// Create chain decomposition
if (chainsGeneric == null)
{
var chainDecomposition = new Common.TwoStageChainDecomposition <TRoom>(levelDescription, new BreadthFirstChainDecomposition <TRoom>(configuration.ChainDecompositionConfiguration ?? new ChainDecompositionConfiguration()));
chainsGeneric = chainDecomposition.GetChains(levelDescription.GetGraph());
}
var chains = chainsGeneric
.Select(x => new Chain <RoomNode <TRoom> >(x.Nodes.Select(y => mapping[y]).ToList(), x.Number)
{
IsFromFace = x.IsFromFace
})
.ToList();
// Create generator planner
var generatorPlanner = new GeneratorPlanner <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom> >(configuration.SimulatedAnnealingMaxBranching);
// Create configuration spaces
var configurationSpacesGenerator = new ConfigurationSpacesGenerator(
new PolygonOverlap(),
DoorHandler.DefaultHandler,
new OrthogonalLineIntersection(),
new GridPolygonUtils());
// var configurationSpaces = configurationSpacesGenerator.GetConfigurationSpaces<ConfigurationNew2<CorridorsDataNew>>(mapDescription);
var simpleConfigurationSpaces = new ConfigurationSpacesGrid2D <ConfigurationGrid2D <TRoom, EnergyData>, RoomNode <TRoom> >(levelDescriptionMapped);
// Needlessly complex for backwards compatibility
#region IntAliasMapping
var roomDescriptions = levelDescriptionMapped.GetGraph().Vertices.ToDictionary(x => x, x => (RoomDescriptionGrid2D)levelDescriptionMapped.GetRoomDescription(x));
var roomTemplates = roomDescriptions.Values.SelectMany(x => x.RoomTemplates).Distinct().ToList();
var roomTemplateInstances = roomTemplates.ToDictionary(x => x, configurationSpacesGenerator.GetRoomTemplateInstances);
var roomTemplateInstancesMapping = roomTemplateInstances.SelectMany(x => x.Value).CreateIntMapping();
var intAliasMapping = new TwoWayDictionary <RoomTemplateInstanceGrid2D, IntAlias <PolygonGrid2D> >();
foreach (var shape1 in roomTemplateInstancesMapping.Keys)
{
foreach (var shape2 in roomTemplateInstancesMapping.Keys)
{
if (!intAliasMapping.ContainsKey(shape1))
{
var newAlias = new IntAlias <PolygonGrid2D>(intAliasMapping.Count, shape1.RoomShape);
intAliasMapping.Add(shape1, newAlias);
shape1.RoomShapeAlias = newAlias;
}
if (!intAliasMapping.ContainsKey(shape2))
{
var newAlias = new IntAlias <PolygonGrid2D>(intAliasMapping.Count, shape2.RoomShape);
intAliasMapping.Add(shape2, newAlias);
shape2.RoomShapeAlias = newAlias;
}
}
}
// TODO: remove when possible
foreach (var pair in intAliasMapping)
{
pair.Key.RoomShapeAlias = pair.Value;
}
var shapesForNodes = new Dictionary <RoomNode <TRoom>, List <WeightedShape> >();
foreach (var vertex in levelDescriptionMapped.GetGraph().Vertices)
{
shapesForNodes.Add(vertex, new List <WeightedShape>());
// var roomDescription = levelDescriptionMapped.GetRoomDescription(vertex);
var roomDescription = roomDescriptions[vertex];
foreach (var roomTemplate in roomDescription.RoomTemplates)
{
var instances = roomTemplateInstances[roomTemplate];
foreach (var roomTemplateInstance in instances)
{
shapesForNodes[vertex].Add(new WeightedShape(intAliasMapping[roomTemplateInstance], 1d / instances.Count));
}
}
}
var usedShapes = new HashSet <int>();
var allShapes = new List <IntAlias <PolygonGrid2D> >();
foreach (var vertex in levelDescriptionMapped.GetGraph().Vertices)
{
var shapes = shapesForNodes[vertex];
foreach (var shape in shapes)
{
if (!usedShapes.Contains(shape.Shape.Alias))
{
allShapes.Add(shape.Shape);
usedShapes.Add(shape.Shape.Alias);
}
}
}
var averageSize = (int)allShapes.Select(x => x.Value.BoundingRectangle).Average(x => (x.Width + x.Height) / 2);
#endregion
// var averageSize = configurationSpaces.GetAverageSize();
var energyUpdater = new BasicEnergyUpdater <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData> >(10 * averageSize);
var roomShapeGeometry = new FastGridPolygonGeometry <ConfigurationGrid2D <TRoom, EnergyData>, RoomNode <TRoom> >();
// Create generator constraints
var stageOneConstraints =
new List <INodeConstraint <ILayout <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>,
EnergyData> >
{
new BasicConstraint <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(
roomShapeGeometry,
simpleConfigurationSpaces,
levelDescriptionMapped,
configuration.OptimizeCorridorConstraints
),
new CorridorConstraint <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(
levelDescriptionMapped,
simpleConfigurationSpaces,
roomShapeGeometry
),
};
if (levelDescription.MinimumRoomDistance > 0)
{
stageOneConstraints.Add(new MinimumDistanceConstraint <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(
levelDescriptionMapped,
roomShapeGeometry,
levelDescription.MinimumRoomDistance
));
}
var constraintsEvaluator = new ConstraintsEvaluator <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(stageOneConstraints, energyUpdater);
var roomShapesHandler = new RoomShapesHandlerGrid2D <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData> >(
intAliasMapping,
levelDescriptionMapped,
shapesForNodes,
levelDescription.RoomTemplateRepeatModeOverride,
levelDescription.RoomTemplateRepeatModeDefault
);
// Create layout operations
var layoutOperations = new LayoutController <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, RoomTemplateInstanceGrid2D, EnergyData>(averageSize, levelDescriptionMapped, constraintsEvaluator, roomShapesHandler, configuration.ThrowIfRepeatModeNotSatisfied, simpleConfigurationSpaces, roomShapeGeometry);
var initialLayout = new Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >(levelDescriptionMapped.GetGraph());
var layoutConverter =
new BasicLayoutConverterGrid2D <TRoom,
ConfigurationGrid2D <TRoom, EnergyData> >(levelDescription, simpleConfigurationSpaces,
intAliasMapping);
// Create simulated annealing evolver
var layoutEvolver =
new Common.SimulatedAnnealingEvolver <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom>,
ConfigurationGrid2D <TRoom, EnergyData> >(layoutOperations, configuration.SimulatedAnnealingConfiguration, true);
// Create the generator itself
generator = new ChainBasedGenerator <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, LayoutGrid2D <TRoom>, RoomNode <TRoom> >(initialLayout, generatorPlanner, chains, layoutEvolver, layoutConverter);
// Register event handlers
generator.OnRandomInjected += (random) =>
{
// ((IRandomInjectable)configurationSpaces).InjectRandomGenerator(random);
((IRandomInjectable)layoutOperations).InjectRandomGenerator(random);
((IRandomInjectable)layoutEvolver).InjectRandomGenerator(random);
((IRandomInjectable)layoutConverter).InjectRandomGenerator(random);
((IRandomInjectable)simpleConfigurationSpaces).InjectRandomGenerator(random);
((IRandomInjectable)roomShapesHandler).InjectRandomGenerator(random);
};
generator.OnCancellationTokenInjected += (token) =>
{
((ICancellable)generatorPlanner).SetCancellationToken(token);
((ICancellable)layoutEvolver).SetCancellationToken(token);
};
layoutEvolver.OnEvent += (sender, args) => OnSimulatedAnnealingEvent?.Invoke(sender, args);
layoutEvolver.OnPerturbed += (sender, layout) => OnPerturbed?.Invoke(layoutConverter.Convert(layout, false));
layoutEvolver.OnPerturbed += (sender, layout) => OnPerturbedInternal?.Invoke(layout);
layoutEvolver.OnValid += (sender, layout) => OnPartialValid?.Invoke(layoutConverter.Convert(layout, true));
generatorPlanner.OnLayoutGenerated += layout => OnValid?.Invoke(layoutConverter.Convert(layout, true));
}
