Room IAutomapCanvas.CreateRoom(Room existing, AutomapDirection directionFromExisting, string name) { if (!Project.Current.Elements.Contains(existing)) { // avoid issues if the user has just deleted the existing room return(null); } var room = new Room(Project.Current); room.Name = name; Vector delta; PositionRelativeTo(room, existing, CompassPointHelper.GetCompassDirection(directionFromExisting), out delta); if (AnyRoomsIntersect(room)) { ShiftMap(room.InnerBounds, delta); Debug.WriteLine("Shift map."); } Project.Current.Elements.Add(room); return(room); }
public void RemoveExitStub(Room room, AutomapDirection direction) { try { m_control.Invoke((MethodInvoker) delegate { m_canvas.RemoveExitStub(room, direction); }); } catch (Exception) { } }
public void Connect(Room source, AutomapDirection directionFromSource, Room target) { try { m_control.Invoke((MethodInvoker) delegate { m_canvas.Connect(source, directionFromSource, target); }); } catch (Exception) { } }
public void Connect(Room source, AutomapDirection directionFromSource, Room target, bool assumeTwoWayConnections) { try { mControl.Invoke((MethodInvoker) delegate { mCanvas.Connect(source, directionFromSource, target, assumeTwoWayConnections); }); } catch (Exception) { // ignored } }
public void AddExitStub(Room room, AutomapDirection direction) { try { mControl.Invoke((MethodInvoker) delegate { mCanvas.AddExitStub(room, direction); }); } catch (Exception) { // ignored } }
public Room CreateRoom(Room existing, AutomapDirection directionFromExisting, string name) { Room room = null; try { m_control.Invoke((MethodInvoker) delegate() { room = m_canvas.CreateRoom(existing, directionFromExisting, name); }); } catch (Exception) { } return(room); }
public Exit GetBestExit(AutomapDirection direction) { Exit exit; if (mMapDirectionToBestExit.TryGetValue(direction, out exit)) { return(exit); } return(null); }
public Room CreateRoom(Room existing, AutomapDirection directionFromExisting, string roomName, string line) { Room room = null; try { mControl.Invoke((MethodInvoker) delegate { room = mCanvas.CreateRoom(existing, directionFromExisting, roomName, line); }); } catch (Exception) { // ignored } return(room); }
private void writeDoor(TextWriter writer, Location location, AutomapDirection direction, Exit exit) { var oppositeDirection = CompassPointHelper.GetOpposite(direction); var reciprocal = exit.Target.GetBestExit(oppositeDirection); writer.WriteLine($"{exit.ConnectionName} is a door. {exit.ConnectionName} is {direction.ToString().ToLower()} of {location.ExportName} and {oppositeDirection.ToString().ToLower()} of {exit.Target.ExportName}. "); writer.WriteLine($"{exit.ConnectionName} is {(exit.Door.Open ? "open" : "closed")} and {(exit.Door.Openable ? "openable" : "not openable")}."); writer.WriteLine($"{exit.ConnectionName} is {(exit.Door.Locked ? "locked" : "unlocked")} and {(exit.Door.Lockable ? "lockable" : "not lockable")}."); writer.WriteLine($"The description of {exit.ConnectionName} is {toInform7PrintableString(exit.ConnectionDescription)}."); reciprocal.Exported = true; writer.WriteLine(); }
/// <summary> /// Get the priority of the exit, in the given direction, with respect to other exits. /// Higher priorities indicate more suitable exits. /// </summary> public int GetPriority(AutomapDirection direction) { if (direction == PrimaryDirection) { return(mPrimaryPriority); } if (direction == SecondaryDirection) { return(1); } return(-1); }
/// <summary> /// Test whether an exit is reciprocated in the other direction; i.e. is there a bidirectional connection. /// </summary> public static bool IsReciprocated(Location source, AutomapDirection direction, Location target) { if (target != null) { var oppositeDirection = CompassPointHelper.GetOpposite(direction); var reciprocal = target.GetBestExit(oppositeDirection); if (reciprocal != null) { Debug.Assert(reciprocal.PrimaryDirection == oppositeDirection || reciprocal.SecondaryDirection == oppositeDirection, "Alleged opposite direction appears to lead somewhere else. Something went wrong whilst building the set of exits from each room."); return(reciprocal.Target == source); } } return(false); }
private void writeDoor(TextWriter writer, Location location, AutomapDirection direction, Exit exit) { var oppositeDirection = CompassPointHelper.GetOpposite(direction); var reciprocal = exit.Target.GetBestExit(oppositeDirection); writer.WriteLine("Object {0} {1}", GetExportName(exit.ConnectionName, null), exit.ConnectionDescription); writer.WriteLine(" with name {0},", toI6Words(deaccent(stripUnaccentedCharacters(exit.ConnectionName)))); writer.WriteLine(" description {0},", toI6String(exit.ConnectionDescription, DOUBLE_QUOTE)); writer.WriteLine(" found_in {0} {1},", location.ExportName, exit.Target.ExportName); writer.WriteLine(" door_to [; if (self in {0}) return {1}; return {0};],", location.ExportName, exit.Target.ExportName); writer.WriteLine(" door_dir [; if (self in {0}) return {1}; return {2}; ],", location.ExportName, toI6PropertyName(direction), toI6PropertyName(oppositeDirection)); writer.WriteLine(" has door {0} {1} {2} {3} ;", (exit.Door.Openable ? "openable" : string.Empty), (exit.Door.Open ? "open" : "~open"), (exit.Door.Lockable ? "lockable" : string.Empty), (exit.Door.Locked ? "locked" : "~locked")); reciprocal.Exported = true; writer.WriteLine(); }
private static string getAlanName(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return("North"); case AutomapDirection.South: return("South"); case AutomapDirection.East: return("East"); case AutomapDirection.West: return("West"); case AutomapDirection.NorthEast: return("Northeast"); case AutomapDirection.SouthEast: return("Southeast"); case AutomapDirection.NorthWest: return("Northwest"); case AutomapDirection.SouthWest: return("Southwest"); case AutomapDirection.Up: return("Up"); case AutomapDirection.Down: return("Down"); case AutomapDirection.In: return("Inside"); case AutomapDirection.Out: return("Outside"); default: return(""); throw new InvalidOperationException("Cannot convert a direction to its Inform 7 equivalent."); } }
/// <summary> /// Convert an automap direction into a compass point. /// Compass directions map directly; up/down/in/out are assigned specific other diretions. /// </summary> public static CompassPoint GetCompassDirection(AutomapDirection direction) { switch (direction) { case AutomapDirection.Up: return(CompassPoint.NorthNorthWest); case AutomapDirection.Down: return(CompassPoint.SouthSouthWest); case AutomapDirection.In: return(CompassPoint.EastNorthEast); case AutomapDirection.Out: return(CompassPoint.WestNorthWest); case AutomapDirection.North: return(CompassPoint.North); case AutomapDirection.South: return(CompassPoint.South); case AutomapDirection.East: return(CompassPoint.East); case AutomapDirection.West: return(CompassPoint.West); case AutomapDirection.NorthEast: return(CompassPoint.NorthEast); case AutomapDirection.NorthWest: return(CompassPoint.NorthWest); case AutomapDirection.SouthEast: return(CompassPoint.SouthEast); case AutomapDirection.SouthWest: return(CompassPoint.SouthWest); default: Debug.Assert(false, "Couldn't work out the compass direction for the given automap direction."); return(CompassPoint.North); } }
private static string ToTadsPropertyName(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return("north"); case AutomapDirection.South: return("south"); case AutomapDirection.East: return("east"); case AutomapDirection.West: return("west"); case AutomapDirection.NorthEast: return("northeast"); case AutomapDirection.NorthWest: return("northwest"); case AutomapDirection.SouthEast: return("southeast"); case AutomapDirection.SouthWest: return("southwest"); case AutomapDirection.Up: return("up"); case AutomapDirection.Down: return("down"); case AutomapDirection.In: return("in"); case AutomapDirection.Out: return("out"); default: Debug.Assert(false, "Unrecognised automap direction."); return("north"); } }
/// <summary> /// Get the literal opposite of any direction. /// </summary> public static AutomapDirection GetOpposite(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return(AutomapDirection.South); case AutomapDirection.South: return(AutomapDirection.North); case AutomapDirection.East: return(AutomapDirection.West); case AutomapDirection.West: return(AutomapDirection.East); case AutomapDirection.NorthEast: return(AutomapDirection.SouthWest); case AutomapDirection.NorthWest: return(AutomapDirection.SouthEast); case AutomapDirection.SouthEast: return(AutomapDirection.NorthWest); case AutomapDirection.SouthWest: return(AutomapDirection.NorthEast); case AutomapDirection.Up: return(AutomapDirection.Down); case AutomapDirection.Down: return(AutomapDirection.Up); case AutomapDirection.In: return(AutomapDirection.Out); case AutomapDirection.Out: return(AutomapDirection.In); default: Debug.Assert(false, "Couldn't work out the opposite of the given direction."); return(AutomapDirection.North); } }
private static string toHugoPropertyName(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return("n_to"); case AutomapDirection.South: return("s_to"); case AutomapDirection.East: return("e_to"); case AutomapDirection.West: return("w_to"); case AutomapDirection.NorthEast: return("ne_to"); case AutomapDirection.NorthWest: return("nw_to"); case AutomapDirection.SouthEast: return("se_to"); case AutomapDirection.SouthWest: return("sw_to"); case AutomapDirection.Up: return("u_to"); case AutomapDirection.Down: return("d_to"); case AutomapDirection.In: return("in_to"); case AutomapDirection.Out: return("out_to"); default: Debug.Assert(false, "Unrecognised automap direction."); return("n_to"); } }
private static string toZILPropertyName(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return("NORTH"); case AutomapDirection.South: return("SOUTH"); case AutomapDirection.East: return("EAST"); case AutomapDirection.West: return("WEST"); case AutomapDirection.NorthEast: return("NE"); case AutomapDirection.SouthEast: return("SE"); case AutomapDirection.SouthWest: return("SW"); case AutomapDirection.NorthWest: return("NW"); case AutomapDirection.Up: return("UP"); case AutomapDirection.Down: return("DOWN"); case AutomapDirection.In: return("IN"); case AutomapDirection.Out: return("OUT"); default: throw new ArgumentOutOfRangeException(nameof(direction), direction, null); } }
void IAutomapCanvas.AddExitStub(Room room, AutomapDirection direction) { if (!Project.Current.Elements.Contains(room)) { // avoid issues if the user has just deleted one of these rooms return; } var sourceCompassPoint = CompassPointHelper.GetCompassDirection(direction); var connection = addConnection(room, sourceCompassPoint, room, sourceCompassPoint); switch (direction) { case AutomapDirection.Up: connection.StartText = Connection.Up; break; case AutomapDirection.Down: connection.StartText = Connection.Down; break; } }
private static void writeNormalExit(TextWriter writer, Location location, AutomapDirection direction, Exit exit) { writer.Write($"{getInform7Name(direction)} of {location.ExportName} is {exit.Target.ExportName}."); var oppositeDirection = CompassPointHelper.GetOpposite(direction); if (Exit.IsReciprocated(location, direction, exit.Target)) { // only export each connection once, if reciprocated; // I7 will infer that the direction is two way unless contradicted. var reciprocal = exit.Target.GetBestExit(oppositeDirection); reciprocal.Exported = true; } else if (exit.Target.GetBestExit(oppositeDirection) == null) { // if we aren't laying down a contradiction which I7 will pick up, // then be clear about one way connections. writer.Write($" {getInform7Name(oppositeDirection)} of {exit.Target.ExportName} is nowhere."); } writer.WriteLine(); }
void IAutomapCanvas.RemoveExitStub(Room room, AutomapDirection direction) { if (!Project.Current.Elements.Contains(room)) { // avoid issues if the user has just deleted one of these rooms return; } var compassPoint = CompassPointHelper.GetCompassDirection(direction); foreach (var connection in room.GetConnections(compassPoint)) { CompassPoint sourceCompassPoint, targetCompassPoint; var source = connection.GetSourceRoom(out sourceCompassPoint); var target = connection.GetTargetRoom(out targetCompassPoint); if (source == room && target == room && sourceCompassPoint == compassPoint && targetCompassPoint == compassPoint) { Project.Current.Elements.Remove(connection); } } }
private Exit pickBestExit(AutomapDirection direction) { // sort exits by priority for this direction only mExits.Sort((Exit a, Exit b) => { var one = a.GetPriority(direction); var two = b.GetPriority(direction); return(two - one); }); // pick the highest priority exit if its direction matches; // if the highest priority exit's direction doesn't match, // there's no exit in this direction. if (mExits.Count > 0) { var exit = mExits[0]; if (exit.PrimaryDirection == direction || exit.SecondaryDirection == direction) { return(exit); } } return(null); }
private static string ToTadsPropertyName(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return "north"; case AutomapDirection.South: return "south"; case AutomapDirection.East: return "east"; case AutomapDirection.West: return "west"; case AutomapDirection.NorthEast: return "northeast"; case AutomapDirection.NorthWest: return "northwest"; case AutomapDirection.SouthEast: return "southeast"; case AutomapDirection.SouthWest: return "southwest"; case AutomapDirection.Up: return "up"; case AutomapDirection.Down: return "down"; case AutomapDirection.In: return "in"; case AutomapDirection.Out: return "out"; default: Debug.Assert(false, "Unrecognised automap direction."); return "north"; } }
private static string toI6PropertyName(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return "n_to"; case AutomapDirection.South: return "s_to"; case AutomapDirection.East: return "e_to"; case AutomapDirection.West: return "w_to"; case AutomapDirection.NorthEast: return "ne_to"; case AutomapDirection.NorthWest: return "nw_to"; case AutomapDirection.SouthEast: return "se_to"; case AutomapDirection.SouthWest: return "sw_to"; case AutomapDirection.Up: return "u_to"; case AutomapDirection.Down: return "d_to"; case AutomapDirection.In: return "in_to"; case AutomapDirection.Out: return "out_to"; default: Debug.Assert(false, "Unrecognised automap direction."); return "north"; } }
/// <summary> /// Get the literal opposite of any direction. /// </summary> public static AutomapDirection GetOpposite(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return AutomapDirection.South; case AutomapDirection.South: return AutomapDirection.North; case AutomapDirection.East: return AutomapDirection.West; case AutomapDirection.West: return AutomapDirection.East; case AutomapDirection.NorthEast: return AutomapDirection.SouthWest; case AutomapDirection.NorthWest: return AutomapDirection.SouthEast; case AutomapDirection.SouthEast: return AutomapDirection.NorthWest; case AutomapDirection.SouthWest: return AutomapDirection.NorthEast; case AutomapDirection.Up: return AutomapDirection.Down; case AutomapDirection.Down: return AutomapDirection.Up; case AutomapDirection.In: return AutomapDirection.Out; case AutomapDirection.Out: return AutomapDirection.In; default: Debug.Assert(false, "Couldn't work out the opposite of the given direction."); return AutomapDirection.North; } }
/// <summary> /// Test whether an exit is reciprocated in the other direction; i.e. is there a bidirectional connection. /// </summary> public static bool IsReciprocated(Location source, AutomapDirection direction, Location target) { if (target != null) { var oppositeDirection = CompassPointHelper.GetOpposite(direction); var reciprocal = target.GetBestExit(oppositeDirection); if (reciprocal != null) { Debug.Assert(reciprocal.PrimaryDirection == oppositeDirection || reciprocal.SecondaryDirection == oppositeDirection, "Alleged opposite direction appears to lead somewhere else. Something went wrong whilst building the set of exits from each room."); return reciprocal.Target == source; } } return false; }
void IAutomapCanvas.Connect(Room source, AutomapDirection directionFromSource, Room target) { if (!Project.Current.Elements.Contains(source) || !Project.Current.Elements.Contains(target)) { // avoid issues if the user has just deleted one of these rooms return; } // work out the correct compass point to use for the given direction // look for existing connections: // if the given direction is up/down/in/out, any existing connection will suffice; // otherwise, only match an existing connection if it's pretty close to the one we want. var sourceCompassPoint = CompassPointHelper.GetCompassDirection(directionFromSource); CompassPoint? acceptableSourceCompassPoint; switch (directionFromSource) { case AutomapDirection.Up: case AutomapDirection.Down: case AutomapDirection.In: case AutomapDirection.Out: acceptableSourceCompassPoint = null; // any existing connection will do break; default: acceptableSourceCompassPoint = sourceCompassPoint; break; } bool wrongWay; var connection = FindConnection(source, target, acceptableSourceCompassPoint, out wrongWay); if (connection == null) { // there is no suitable connection between these rooms: var targetCompassPoint = CompassPointHelper.GetAutomapOpposite(sourceCompassPoint); // check whether we can move one of the rooms to make the connection tidier; // we won't need this very often, but it can be useful especially if the user teleports into a room // and then steps out into an existing one (this can appear to happen if the user moves into a // dark room, turns on the light, then leaves). TryMoveRoomsForTidyConnection(source, sourceCompassPoint, target, targetCompassPoint); // add a new connection connection = addConnection(source, sourceCompassPoint, target, targetCompassPoint); connection.Style = ConnectionStyle.Solid; connection.Flow = ConnectionFlow.OneWay; } else if (wrongWay) { // there is a suitable connection between these rooms, but it goes the wrong way; // make it bidirectional since we can now go both ways. connection.Flow = ConnectionFlow.TwoWay; } // if this is an up/down/in/out connection, mark it as such; // but don't override any existing text. switch (directionFromSource) { case AutomapDirection.Up: case AutomapDirection.Down: case AutomapDirection.In: case AutomapDirection.Out: if (string.IsNullOrEmpty(connection.StartText) && string.IsNullOrEmpty(connection.EndText)) { switch (directionFromSource) { case AutomapDirection.Up: connection.SetText(wrongWay ? ConnectionLabel.Down : ConnectionLabel.Up); break; case AutomapDirection.Down: connection.SetText(wrongWay ? ConnectionLabel.Up : ConnectionLabel.Down); break; case AutomapDirection.In: connection.SetText(wrongWay ? ConnectionLabel.Out : ConnectionLabel.In); break; case AutomapDirection.Out: connection.SetText(wrongWay ? ConnectionLabel.In : ConnectionLabel.Out); break; } } break; } }
public Room CreateRoom(Room existing, AutomapDirection directionFromExisting, string roomName, string line) { Room room = null; try { m_control.Invoke((MethodInvoker) delegate { room = m_canvas.CreateRoom(existing, directionFromExisting, roomName,line); }); } catch (Exception) { } return room; }
private static string getInform7Name(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return "North"; case AutomapDirection.South: return "South"; case AutomapDirection.East: return "East"; case AutomapDirection.West: return "West"; case AutomapDirection.NorthEast: return "Northeast"; case AutomapDirection.SouthEast: return "Southeast"; case AutomapDirection.NorthWest: return "Northwest"; case AutomapDirection.SouthWest: return "Southwest"; case AutomapDirection.Up: return "Up"; case AutomapDirection.Down: return "Down"; case AutomapDirection.In: return "Inside"; case AutomapDirection.Out: return "Outside"; default: throw new InvalidOperationException("Cannot convert a direction to its Inform 7 equivalent."); } }
private Exit pickBestExit(AutomapDirection direction) { // sort exits by priority for this direction only mExits.Sort((Exit a, Exit b) => { var one = a.GetPriority(direction); var two = b.GetPriority(direction); return two - one; }); // pick the highest priority exit if its direction matches; // if the highest priority exit's direction doesn't match, // there's no exit in this direction. if (mExits.Count > 0) { var exit = mExits[0]; if (exit.PrimaryDirection == direction || exit.SecondaryDirection == direction) { return exit; } } return null; }
void IAutomapCanvas.Connect(Room source, AutomapDirection directionFromSource, Room target) { if (!Project.Current.Elements.Contains(source) || !Project.Current.Elements.Contains(target)) { // avoid issues if the user has just deleted one of these rooms return; } // work out the correct compass point to use for the given direction // look for existing connections: // if the given direction is up/down/in/out, any existing connection will suffice; // otherwise, only match an existing connection if it's pretty close to the one we want. var sourceCompassPoint = CompassPointHelper.GetCompassDirection(directionFromSource); CompassPoint?acceptableSourceCompassPoint; switch (directionFromSource) { case AutomapDirection.Up: case AutomapDirection.Down: case AutomapDirection.In: case AutomapDirection.Out: acceptableSourceCompassPoint = null; // any existing connection will do break; default: acceptableSourceCompassPoint = sourceCompassPoint; break; } bool wrongWay; var connection = FindConnection(source, target, acceptableSourceCompassPoint, out wrongWay); if (connection == null) { // there is no suitable connection between these rooms: var targetCompassPoint = CompassPointHelper.GetAutomapOpposite(sourceCompassPoint); // check whether we can move one of the rooms to make the connection tidier; // we won't need this very often, but it can be useful especially if the user teleports into a room // and then steps out into an existing one (this can appear to happen if the user moves into a // dark room, turns on the light, then leaves). TryMoveRoomsForTidyConnection(source, sourceCompassPoint, target, targetCompassPoint); // add a new connection connection = addConnection(source, sourceCompassPoint, target, targetCompassPoint); connection.Style = ConnectionStyle.Solid; connection.Flow = ConnectionFlow.OneWay; } else if (wrongWay) { // there is a suitable connection between these rooms, but it goes the wrong way; // make it bidirectional since we can now go both ways. connection.Flow = ConnectionFlow.TwoWay; } // if this is an up/down/in/out connection, mark it as such; // but don't override any existing text. switch (directionFromSource) { case AutomapDirection.Up: case AutomapDirection.Down: case AutomapDirection.In: case AutomapDirection.Out: if (string.IsNullOrEmpty(connection.StartText) && string.IsNullOrEmpty(connection.EndText)) { switch (directionFromSource) { case AutomapDirection.Up: connection.SetText(wrongWay ? ConnectionLabel.Down : ConnectionLabel.Up); break; case AutomapDirection.Down: connection.SetText(wrongWay ? ConnectionLabel.Up : ConnectionLabel.Down); break; case AutomapDirection.In: connection.SetText(wrongWay ? ConnectionLabel.Out : ConnectionLabel.In); break; case AutomapDirection.Out: connection.SetText(wrongWay ? ConnectionLabel.In : ConnectionLabel.Out); break; } } break; } }
public Exit GetBestExit(AutomapDirection direction) { Exit exit; if (mMapDirectionToBestExit.TryGetValue(direction, out exit)) { return exit; } return null; }
/// <summary> /// Get the priority of the exit, in the given direction, with respect to other exits. /// Higher priorities indicate more suitable exits. /// </summary> public int GetPriority(AutomapDirection direction) { if (direction == PrimaryDirection) { return mPrimaryPriority; } if (direction == SecondaryDirection) { return 1; } return -1; }
/// <summary> /// Convert an automap direction into a compass point. /// Compass directions map directly; up/down/in/out are assigned specific other diretions. /// </summary> public static CompassPoint GetCompassDirection(AutomapDirection direction) { switch (direction) { case AutomapDirection.Up: return CompassPoint.NorthNorthWest; case AutomapDirection.Down: return CompassPoint.SouthSouthWest; case AutomapDirection.In: return CompassPoint.EastNorthEast; case AutomapDirection.Out: return CompassPoint.WestNorthWest; case AutomapDirection.North: return CompassPoint.North; case AutomapDirection.South: return CompassPoint.South; case AutomapDirection.East: return CompassPoint.East; case AutomapDirection.West: return CompassPoint.West; case AutomapDirection.NorthEast: return CompassPoint.NorthEast; case AutomapDirection.NorthWest: return CompassPoint.NorthWest; case AutomapDirection.SouthEast: return CompassPoint.SouthEast; case AutomapDirection.SouthWest: return CompassPoint.SouthWest; default: Debug.Assert(false, "Couldn't work out the compass direction for the given automap direction."); return CompassPoint.North; } }
Room IAutomapCanvas.CreateRoom(Room existing, AutomapDirection directionFromExisting, string roomName, string line) { if (!Project.Current.Elements.Contains(existing)) { // avoid issues if the user has just deleted the existing room return null; } var room = new Room(Project.Current) {Name = roomName}; if (line != roomName) { room.SubTitle = line.Replace(roomName, ""); } Vector delta; PositionRelativeTo(room, existing, CompassPointHelper.GetCompassDirection(directionFromExisting), out delta); if (AnyRoomsIntersect(room)) { ShiftMap(room.InnerBounds, delta); Debug.WriteLine("Shift map."); } Project.Current.Elements.Add(room); return room; }
private static string toZILPropertyName(AutomapDirection direction) { switch (direction) { case AutomapDirection.North: return "NORTH"; case AutomapDirection.South: return "SOUTH"; case AutomapDirection.East: return "EAST"; case AutomapDirection.West: return "WEST"; case AutomapDirection.NorthEast: return "NE"; case AutomapDirection.SouthEast: return "SE"; case AutomapDirection.SouthWest: return "SW"; case AutomapDirection.NorthWest: return "NW"; case AutomapDirection.Up: return "UP"; case AutomapDirection.Down: return "DOWN"; case AutomapDirection.In: return "IN"; case AutomapDirection.Out: return "OUT"; default: throw new ArgumentOutOfRangeException(nameof(direction), direction, null); } }