public CorridorConstraints(ICorridorMapDescription <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;
graphWithoutCorridors = this.mapDescription.GetGraphWithoutCorrridors();
}
public BasicConstraint(IRoomShapeGeometry <TConfiguration> roomShapeGeometry, IConfigurationSpaces <TConfiguration> configurationSpaces, ILevelDescription <TNode> mapDescription, bool optimizeCorridors)
{
this.configurationSpaces = configurationSpaces;
this.mapDescription = mapDescription;
this.optimizeCorridors = optimizeCorridors;
this.roomShapeGeometry = roomShapeGeometry;
}
public CorridorConstraint(ILevelDescription <TNode> mapDescription, IConfigurationSpaces <TConfiguration> configurationSpaces, IRoomShapeGeometry <TConfiguration> roomShapeGeometry)
{
this.mapDescription = mapDescription;
this.configurationSpaces = configurationSpaces;
this.roomShapeGeometry = roomShapeGeometry;
graphWithoutCorridors = mapDescription.GetGraphWithoutCorridors();
graph = mapDescription.GetGraph();
}
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 BasicLayoutConverter(
MapDescriptionMapping <TNode> mapDescription,
IConfigurationSpaces <int, IntAlias <PolygonGrid2D>, TConfiguration, ConfigurationSpace> configurationSpaces,
TwoWayDictionary <RoomTemplateInstance, IntAlias <PolygonGrid2D> > intAliasMapping
)
{
MapDescription = mapDescription;
ConfigurationSpaces = configurationSpaces;
IntAliasMapping = intAliasMapping;
}
public LayoutOperationsWithCorridors(
IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces,
ICorridorMapDescription <TNode> mapDescription,
IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> corridorConfigurationSpaces,
int averageSize
) : base(configurationSpaces, averageSize)
{
MapDescription = mapDescription;
CorridorConfigurationSpaces = corridorConfigurationSpaces;
GraphWithoutCorridors = mapDescription.GetGraphWithoutCorrridors();
}
public BasicLayoutConverter(
MapDescription <TNode> mapDescription,
IConfigurationSpaces <int, IntAlias <GridPolygon>, TConfiguration, ConfigurationSpace> configurationSpaces,
Dictionary <int, ConfigurationSpacesGenerator.RoomInfo> intAliasMapping,
ICorridorNodesCreator <TNode> corridorNodesCreator = null
)
{
MapDescription = mapDescription;
ConfigurationSpaces = configurationSpaces;
CorridorNodesCreator = corridorNodesCreator ?? CorridorNodesCreatorFactory.Default.GetCreator <TNode>();
IntAliasMapping = intAliasMapping;
}
public LayoutController(
int averageSize,
ILevelDescription <TNode> levelDescription,
ConstraintsEvaluator <TNode, TConfiguration, TEnergyData> constraintsEvaluator,
IRoomShapesHandler <TLayout, TNode, TShapeContainer> roomShapesHandler, bool throwIfRepeatModeNotSatisfied, IConfigurationSpaces <TConfiguration, Vector2Int> simpleConfigurationSpaces, IRoomShapeGeometry <TConfiguration> roomShapeGeometry)
: base(averageSize,
levelDescription,
roomShapesHandler,
roomShapeGeometry)
{
this.constraintsEvaluator = constraintsEvaluator;
this.throwIfRepeatModeNotSatisfied = throwIfRepeatModeNotSatisfied;
this.simpleConfigurationSpaces = simpleConfigurationSpaces;
}
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();
}
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 int GetAverageSize <TNode, TConfiguration, TConfigurationSpace>(this IConfigurationSpaces <TNode, IntAlias <GridPolygon>, TConfiguration, TConfigurationSpace> configurationSpaces)
{
return((int)configurationSpaces.GetAllShapes().Select(x => x.Value.BoundingRectangle).Average(x => (x.Width + x.Height) / 2));
}
public BasicConstraint(IPolygonOverlap <TShapeContainer> polygonOverlap, float averageSize, IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces)
{
this.polygonOverlap = polygonOverlap;
energySigma = 10 * averageSize;
this.configurationSpaces = configurationSpaces;
}
protected AbstractLayoutOperations(IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces, int averageSize)
{
ConfigurationSpaces = configurationSpaces;
AverageSize = averageSize;
}
public PlatformerLayoutOperations(IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces, int averageSize) : base(configurationSpaces, averageSize)
{
}
public IList <TOutputLayout> GetLayouts(TMapDescription mapDescription, int numberOfLayouts)
{
var graph = mapDescription.GetGraph();
if (graph.VerticesCount < 2)
{
throw new ArgumentException("Given mapDescription must contain at least two nodes.", nameof(mapDescription));
}
if (!graphUtils.IsConnected(graph))
{
throw new ArgumentException("Given mapDescription must represent a connected graph.", nameof(mapDescription));
}
if (!graphUtils.IsPlanar(graph))
{
throw new ArgumentException("Given mapDescription must represent a planar graph.", nameof(mapDescription));
}
// Create instances and inject the random generator and the cancellation token if possible
configurationSpaces = configurationSpacesCreator(mapDescription);
TryInjectRandomAndCancellationToken(configurationSpaces);
chainDecomposition = chainDecompositionCreator(mapDescription);
TryInjectRandomAndCancellationToken(chainDecomposition);
initialLayout = initialLayoutCreator(mapDescription);
TryInjectRandomAndCancellationToken(initialLayout);
generatorPlanner = generatorPlannerCreator(mapDescription);
TryInjectRandomAndCancellationToken(generatorPlanner);
layoutOperations = layoutOperationsCreator(mapDescription, configurationSpaces);
TryInjectRandomAndCancellationToken(layoutOperations);
layoutConverter = layoutConverterCreator(mapDescription, configurationSpaces);
TryInjectRandomAndCancellationToken(layoutConverter);
layoutEvolver = layoutEvolverCreator(mapDescription, layoutOperations);
TryInjectRandomAndCancellationToken(layoutEvolver);
// Restart stopwatch
stopwatch.Restart();
chains = chainDecomposition.GetChains(graph);
context = new GeneratorContext();
RegisterEventHandlers();
// TODO: handle number of layouts to be evolved - who should control that? generator or planner?
// TODO: handle context.. this is ugly
var layouts = generatorPlanner.Generate(initialLayout, numberOfLayouts, chains.Count,
(layout, chainNumber, numOfLayouts) => layoutEvolver.Evolve(AddChain(layout, chainNumber), chains[chainNumber], numOfLayouts), context);
// Stop stopwatch and prepare benchmark info
stopwatch.Stop();
timeTotal = stopwatch.ElapsedMilliseconds;
layoutsCount = layouts.Count;
// Reset cancellation token if it was already used
if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
{
CancellationToken = null;
}
return(layouts.Select(x => layoutConverter.Convert(x, true)).ToList());
}
public LayoutOperationsWithConstraints(IConfigurationSpaces <TNode, TShapeContainer, TConfiguration, ConfigurationSpace> configurationSpaces, int averageSize) : base(configurationSpaces, averageSize)
{
/* empty */
}
