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);
}
}
}
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 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;
}
}
public void RemoveExitStub(Room room, AutomapDirection direction)
{
try { m_control.Invoke((MethodInvoker) delegate { m_canvas.RemoveExitStub(room, direction); }); }
catch (Exception)
{
}
}
/// <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;
}
}
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);
}
}
}
public void Connect(Room source, AutomapDirection directionFromSource, Room target)
{
try { m_control.Invoke((MethodInvoker) delegate { m_canvas.Connect(source, directionFromSource, target); }); }
catch (Exception)
{
}
}
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);
}
}
