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));
}
public void Generate_BasicTest()
{
// This test cannot check if the generated configuration spaces are valid
var mapDescription = new MapDescription <int>();
var squareRoom = new RoomDescription(GridPolygon.GetSquare(3), new OverlapMode(1, 0));
var rectangleRoom = new RoomDescription(GridPolygon.GetRectangle(4, 5), new OverlapMode(1, 1));
mapDescription.AddRoomShapes(squareRoom);
mapDescription.AddRoomShapes(rectangleRoom, probability: 0.5d);
mapDescription.AddRoom(0);
mapDescription.AddRoom(1);
mapDescription.AddPassage(0, 1);
mapDescription.AddRoomShapes(1, rectangleRoom, new List <Transformation>()
{
Transformation.Identity
});
// var configurationSpaces = generator.Generate(mapDescription);
Assert.IsTrue(false); // TODO: repair
//Assert.AreEqual(3, configurationSpaces.GetShapesForNode(0).Count);
//Assert.AreEqual(1, configurationSpaces.GetShapesForNode(1).Count);
}
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));
}
private void LoadCorridors(MapDescription <int> mapDescription, MapDescriptionModel mapDescriptionModel, Dictionary <string, RoomDescriptionsSetModel> roomDescriptionsSets)
{
if (mapDescriptionModel.Corridors == null)
{
return;
}
var corridors = mapDescriptionModel.Corridors;
var enable = corridors.Enable ?? true;
if (enable && (corridors.Offsets == null || corridors.Offsets.Count == 0))
{
throw new InvalidOperationException("There must be at least one offset if corridors are enabled");
}
mapDescription.SetWithCorridors(enable, corridors.Offsets);
if (enable && (corridors.CorridorShapes == null || corridors.CorridorShapes.Count == 0))
{
throw new InvalidOperationException("There must be at least one shape for corridors if they are enabled.");
}
foreach (var rooms in corridors.CorridorShapes)
{
var roomShapes = GetRoomDescriptions(rooms, roomDescriptionsSets, mapDescriptionModel.CustomRoomDescriptionsSet, rooms.Scale);
mapDescription.AddCorridorShapes(roomShapes, GetTransformations(rooms.Rotate), rooms.Probability ?? 1, rooms.NormalizeProbabilities ?? true);
}
}
static void Main(string[] args)
{
SampleServer6.USA_MapServer mapservice = new SampleServer6.USA_MapServer();
String defaultMapName = mapservice.GetDefaultMapName();
Console.WriteLine("Map name: " + defaultMapName + "\n");
MapServerInfo mapinfo = mapservice.GetServerInfo(defaultMapName);
MapDescription mapdesc = mapinfo.DefaultMapDescription;
ImageType imgtype = new ImageType();
imgtype.ImageFormat = esriImageFormat.esriImagePNG;
imgtype.ImageReturnType = esriImageReturnType.esriImageReturnURL;
ImageDisplay imgdisp = new ImageDisplay();
imgdisp.ImageHeight = 500; //pixels
imgdisp.ImageWidth = 500; //pixels
imgdisp.ImageDPI = 96;
ImageDescription imgdesc = new ImageDescription();
imgdesc.ImageDisplay = imgdisp;
imgdesc.ImageType = imgtype;
MapImage mapimg = mapservice.ExportMapImage(mapdesc, imgdesc);
Console.WriteLine("Output URL:" + mapimg.ImageURL);
Console.ReadLine();
}
static void GenerateMap(SpaceGraph graph, int seed = 0)
{
var mapDescription = new MapDescription <int>();
//Add rooms
graph.AllNodes.ForEach(node => mapDescription.AddRoom(node.Id));
//Add connections
List <List <int> > connections = graph.ConvertToAdjList(false);
for (int node = 0; node < connections.Count; node++)
{
for (int link = 0; link < connections[node].Count; link++)
{
mapDescription.AddPassage(node, connections[node][link]);
}
}
//Add room descriptions
using (var reader = new StreamReader(@"Resources\Rooms\SMB.yml"))
{
var roomLoader = cfloader.LoadRoomDescriptionsSetModel(reader);
foreach (var roomDescription in roomLoader.RoomDescriptions)
{
GridPolygon shape = new GridPolygon(roomDescription.Value.Shape);
RoomDescription roomShape = new RoomDescription(shape, (roomDescription.Value.DoorMode == null) ? roomLoader.Default.DoorMode : roomDescription.Value.DoorMode);
mapDescription.AddRoomShapes(roomShape);
}
}
// Generate bitmap
SaveBitmap(mapDescription, seed);
}
protected virtual NamedMapDescription GetMapDescription(string name)
{
var settings = new JsonSerializerSettings()
{
PreserveReferencesHandling = PreserveReferencesHandling.All,
TypeNameHandling = TypeNameHandling.All,
};
MapDescription <int> mapDescription = null;
if (File.Exists($"Resources/MapDescriptions/{name}.json"))
{
mapDescription = JsonConvert.DeserializeObject <MapDescription <int> >(
File.ReadAllText($"Resources/MapDescriptions/{name}.json"), settings);
}
else
{
using (var sr = new StreamReader($"Resources/Maps/Thesis/{name}.yml"))
{
mapDescription = configLoader.LoadMapDescription(sr);
}
}
return(new NamedMapDescription(mapDescription, name, mapDescription.GetGraph().VerticesCount != mapDescription.GetStageOneGraph().VerticesCount));
}
public MapDescription<int> GetMapDescription()
{
var mapDescription = new MapDescription<int>();
mapDescription.SetupWithGraph(GraphsDatabase.GetExample5());
// Add room shapes
var doorMode = new OverlapMode(1, 1);
var squareRoomBig = new RoomDescription(
GridPolygon.GetSquare(8),
doorMode
);
var squareRoomSmall = new RoomDescription(
GridPolygon.GetSquare(6),
doorMode
);
var rectangleRoomBig = new RoomDescription(
GridPolygon.GetRectangle(8, 12),
doorMode
);
var rectangleRoomSmall = new RoomDescription(
GridPolygon.GetRectangle(6, 10),
doorMode
);
mapDescription.AddRoomShapes(squareRoomBig, probability: 10);
mapDescription.AddRoomShapes(squareRoomSmall);
mapDescription.AddRoomShapes(rectangleRoomBig);
mapDescription.AddRoomShapes(rectangleRoomSmall);
return mapDescription;
}
public void TransformPointToNewPosition_RectanglePoints()
{
// Create a rectangular room shape
// Move it away from (0, 0) so that we can properly test the functionality
var rectangleShape = GridPolygon.GetRectangle(10, 4) + new IntVector2(10, 10);
// Create points to be transformed
// These could be for example traps, spawn points, etc.
// We use points of the rectangle here because it is easy to check that the transformation is correct.
var pointsToTransform = rectangleShape.GetPoints();
var mapDescription = new MapDescription <int>();
// Create simple graph with 2 vertices and 1 edge
mapDescription.AddRoom(0);
mapDescription.AddRoom(1);
mapDescription.AddPassage(0, 1);
// Add the rectangle shape
mapDescription.AddRoomShapes(new RoomDescription(rectangleShape, new OverlapMode(1, 0)));
var layoutGenerator = LayoutGeneratorFactory.GetDefaultChainBasedGenerator <int>();
var layout = layoutGenerator.GetLayouts(mapDescription, 1)[0];
foreach (var room in layout.Rooms)
{
// The points were chosen to be the points of the polygon, so after transforming them, they should
// be equal to the room.Shape + room.Position points
var transformedPoints = pointsToTransform.Select(x => room.TransformPointToNewPosition(x));
var expectedPoints = (room.Shape + room.Position).GetPoints();
Assert.That(transformedPoints, Is.EquivalentTo(expectedPoints));
}
}
private void LoadPassages(MapDescription <int> mapDescription, MapDescriptionModel mapDescriptionModel, Dictionary <string, RoomDescriptionsSetModel> roomDescriptionsSets)
{
if (mapDescriptionModel.Passages == null)
{
return;
}
var corridors = GetCorridors(mapDescriptionModel, roomDescriptionsSets);
var corridorsCounter = mapDescription.GetGraph().Vertices.Max() + 1;
foreach (var passage in mapDescriptionModel.Passages)
{
if (corridors != null)
{
var corridorRoom = corridorsCounter++;
mapDescription.AddRoom(corridorRoom, corridors);
mapDescription.AddConnection(passage.X, corridorRoom);
mapDescription.AddConnection(passage.Y, corridorRoom);
}
else
{
mapDescription.AddConnection(passage.X, passage.Y);
}
}
}
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 static MapDescription <int> GetBasicMapDescription(IGraph <int> graph,
IRoomDescription basicRoomDescription, IRoomDescription corridorRoomDescription = null,
bool withCorridors = false)
{
var mapDescription = new MapDescription <int>();
foreach (var room in graph.Vertices)
{
mapDescription.AddRoom(room, basicRoomDescription);
}
var counter = graph.VerticesCount;
foreach (var connection in graph.Edges)
{
if (withCorridors)
{
mapDescription.AddRoom(counter, corridorRoomDescription);
mapDescription.AddConnection(connection.From, counter);
mapDescription.AddConnection(connection.To, counter);
counter++;
}
else
{
mapDescription.AddConnection(connection.From, connection.To);
}
}
return(mapDescription);
}
public MapDescription <int> GetMapDescription()
{
var mapDescription = new MapDescription <int>();
// Add rooms ( - you would normally use a for cycle)
mapDescription.AddRoom(0);
mapDescription.AddRoom(1);
mapDescription.AddRoom(2);
mapDescription.AddRoom(3);
// Add passages
mapDescription.AddPassage(0, 1);
mapDescription.AddPassage(0, 3);
mapDescription.AddPassage(1, 2);
mapDescription.AddPassage(2, 3);
// Add room shapes
var doorMode = new OverlapMode(1, 1);
var squareRoom = new RoomDescription(
GridPolygon.GetSquare(8),
doorMode
);
var rectangleRoom = new RoomDescription(
GridPolygon.GetRectangle(6, 10),
doorMode
);
mapDescription.AddRoomShapes(squareRoom);
mapDescription.AddRoomShapes(rectangleRoom);
return(mapDescription);
}
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 MapImage ExportMapImage(MapDescription MapDescription, ImageDescription ImageDescription)
{
ServiceMethod <MapImage> method = (client) =>
{
return(client.ExportMapImage(MapDescription, ImageDescription));
};
return(Invoke <MapImage>(method));
}
/// <summary>
/// Setups default room shapes.
/// These are used if a room does not have any room shapes assigned.
/// </summary>
/// <param name="mapDescription"></param>
/// <param name="levelGraph"></param>
protected void SetupDefaultRoomShapes(MapDescription <int> mapDescription, LevelGraph levelGraph)
{
var roomDescriptions = GetRoomDescriptions(levelGraph.DefaultRoomTemplateSets, levelGraph.DefaultIndividualRoomTemplates).Distinct();
foreach (var roomDescription in roomDescriptions)
{
mapDescription.AddRoomShapes(roomDescription);
}
}
public void Generate_NodeWithoutShape()
{
var mapDescription = new MapDescription <int>();
mapDescription.AddRoom(0);
Assert.Throws <ArgumentException>(
() => generator.Generate <int, IConfiguration <IntAlias <GridPolygon> > >(mapDescription));
}
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 UpdateMapImageTask()
{
this.Mapservice = null;
this.Imagedescription = null;
this.Mapdesc = null;
this.UpdateForm = null;
this.OutputSpatialReference = null;
this.GeometryService = null;
}
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;
}
private void LoadPassagess(MapDescription <int> mapDescription, MapDescriptionModel mapDescriptionModel)
{
if (mapDescriptionModel.Passages == null)
{
return;
}
foreach (var passage in mapDescriptionModel.Passages)
{
mapDescription.AddPassage(passage.X, passage.Y);
}
}
public void LoadMap(MapDescription desc)
{
mapSize = desc.Size;
//加载地形
m_Terrain.Size = MapSize;
terrainLayer = new TerrainType[MapSize.x, MapSize.y];
generateTerrain(desc.terrainDict);
//加载元素
m_Element.Size = MapSize;
elementLayer = new ElementType[MapSize.x, MapSize.y];
generateElement(desc.elementDict);
}
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));
}
private MapImage GetMapImage(esriImageReturnType returnType)
{
MapDescription mapDescription = ((AgsDataFrame)DataFrame).MapServerInfo.NewMapDescription(Extent);
mapDescription.SetAllLayersNotVisible();
for (int i = 0; i < _layerList.Count; ++i)
{
AgsLayer layer = _layerList[i];
string query = _queryList[i];
MapLayerInfo mapLayerInfo = layer.MapLayerInfo;
while (mapLayerInfo != null)
{
LayerDescription layerDescription = mapDescription.LayerDescriptions.First(ld => ld.LayerID == mapLayerInfo.LayerID);
layerDescription.Visible = true;
if (!String.IsNullOrEmpty(query))
{
layerDescription.DefinitionExpression = query;
}
mapLayerInfo = mapLayerInfo.Parent;
query = null;
}
}
ImageDescription imageDescription = new ImageDescription();
imageDescription.ImageDisplay = new ImageDisplay(Convert.ToInt32(Width * Resolution), Convert.ToInt32(Height * Resolution), DataFrame.Dpi * Resolution);
imageDescription.ImageType = new ImageType(returnType);
switch (ImageType)
{
case CommonImageType.Png:
imageDescription.ImageType.ImageFormat = esriImageFormat.esriImagePNG32;
if (TransparentBackground)
{
mapDescription.TransparentColor = mapDescription.BackgroundSymbol.Color;
}
break;
default:
imageDescription.ImageType.ImageFormat = esriImageFormat.esriImageJPG;
break;
}
return(_service.MapServer.ExportMapImage(mapDescription, imageDescription));
}
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MapDescription mapDescription = await db.MapDescriptions.FindAsync(id);
if (mapDescription == null)
{
return(HttpNotFound());
}
return(View(mapDescription));
}
public static MapDescription <TNode> SetupWithGraph <TNode>(this MapDescription <TNode> mapDescription, IGraph <TNode> graph)
{
foreach (var vertex in graph.Vertices)
{
mapDescription.AddRoom(vertex);
}
foreach (var edge in graph.Edges)
{
mapDescription.AddPassage(edge.From, edge.To);
}
return(mapDescription);
}
/// <summary>
/// Adds basic room shapes to a given map description.
/// </summary>
/// <typeparam name="TNode"></typeparam>
/// <param name="mapDescription"></param>
/// <param name="scale"></param>
/// <returns></returns>
public static MapDescription <TNode> AddClassicRoomShapes <TNode>(this MapDescription <TNode> mapDescription,
IntVector2 scale)
{
var overlapScale = Math.Min(scale.X, scale.Y);
var doorMode = new OverlapMode(1 * overlapScale, 0);
var squareRoom = new RoomDescription(GridPolygon.GetSquare(6).Scale(scale), doorMode);
var rectangleRoom = new RoomDescription(GridPolygon.GetRectangle(6, 9).Scale(scale), doorMode);
var room1 = new RoomDescription(
new GridPolygonBuilder()
.AddPoint(0, 0)
.AddPoint(0, 6)
.AddPoint(3, 6)
.AddPoint(3, 3)
.AddPoint(6, 3)
.AddPoint(6, 0)
.Build().Scale(scale)
, doorMode);
var room2 = new RoomDescription(
new GridPolygonBuilder()
.AddPoint(0, 0)
.AddPoint(0, 9)
.AddPoint(3, 9)
.AddPoint(3, 3)
.AddPoint(6, 3)
.AddPoint(6, 0)
.Build().Scale(scale)
, doorMode);
var room3 = new RoomDescription(
new GridPolygonBuilder()
.AddPoint(0, 0)
.AddPoint(0, 3)
.AddPoint(3, 3)
.AddPoint(3, 6)
.AddPoint(6, 6)
.AddPoint(6, 3)
.AddPoint(9, 3)
.AddPoint(9, 0)
.Build().Scale(scale)
, doorMode);
mapDescription.AddRoomShapes(squareRoom, probability: 4);
mapDescription.AddRoomShapes(rectangleRoom, probability: 2);
mapDescription.AddRoomShapes(room1);
mapDescription.AddRoomShapes(room2);
mapDescription.AddRoomShapes(room3);
return(mapDescription);
}
/// <summary>
/// Perturbs non corridor rooms until a valid layout is found.
/// Then tries to use a greedy algorithm to lay out corridor rooms.
/// </summary>
/// <param name="layout"></param>
/// <param name="chain"></param>
/// <param name="updateLayout"></param>
public override void PerturbLayout(TLayout layout, IList <TNode> chain, bool updateLayout)
{
// TODO: change
var nonCorridors = chain.Where(x => MapDescription.GetRoomDescription(x).Stage == 1).ToList();
if (Random.NextDouble() < 0.4f)
{
PerturbShape(layout, nonCorridors, updateLayout);
}
else
{
var random = nonCorridors.GetRandom(Random);
PerturbPosition(layout, random, updateLayout);
}
}
protected override MapDescription <int> SetupMapDescription()
{
if (Config.LevelGraph == null)
{
throw new ArgumentException("LevelGraph must not be null.");
}
RoomToIntMapping = new TwoWayDictionary <Room, int>();
var mapDescription = new MapDescription <int>();
mapDescription.SetDefaultTransformations(new List <Transformation>()
{
Transformation.Identity
});
// Setup individual rooms
foreach (var room in Config.LevelGraph.Rooms)
{
RoomToIntMapping.Add(room, RoomToIntMapping.Count);
mapDescription.AddRoom(RoomToIntMapping[room]);
SetupRoomShapesForRoom(mapDescription, room);
}
// Add default room shapes
SetupDefaultRoomShapes(mapDescription, Config.LevelGraph);
// Add corridors
if (Config.UseCorridors)
{
SetupCorridorRoomShapes(mapDescription, Config.LevelGraph);
}
// Add passages
foreach (var connection in Config.LevelGraph.Connections)
{
var from = RoomToIntMapping[connection.From];
var to = RoomToIntMapping[connection.To];
mapDescription.AddPassage(from, to);
}
if (Payload is IRoomToIntMappingPayload <Room> payloadWithMapping)
{
payloadWithMapping.RoomToIntMapping = RoomToIntMapping;
}
return(mapDescription);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes routine (support reinit).
/// </summary>
/// <param name="mapLayer">Layer for creating images.</param>
public void Init(MapLayer mapLayer)
{
Debug.Assert(null != mapLayer);
Debug.Assert(!_serviceInWorkedState); // only once
AgsServer server = ((AgsMapLayer)mapLayer).Server;
ServiceHelper.ValidateServerState(server);
_mapService = new MapServiceClient(mapLayer.Url, server.OpenConnection());
_mapInfo = _mapService.GetServerInfo(_mapService.GetDefaultMapName());
_mapDescription = _mapInfo.DefaultMapDescription;
var imgType = new ImageType();
imgType.ImageFormat = esriImageFormat.esriImagePNG;
imgType.ImageReturnType = esriImageReturnType.esriImageReturnMimeData;
_imgDescription = new ImageDescription();
_imgDescription.ImageType = imgType;
_serviceInWorkedState = true;
}
public MapFrame( MapDescription mapDescription, MapServerProxy mapServerProxy, ImageDescription imageDescription)
{
m_mapDescription = mapDescription;
m_mapServerProxy = mapServerProxy;
m_imageDescription = imageDescription;
}
