public void Connect(Room source, MappableDirection directionFromSource, Room target, bool assumeTwoWayConnections)
{
try { mControl.Invoke((MethodInvoker) delegate { mCanvas.Connect(source, directionFromSource, target, assumeTwoWayConnections); }); }
catch (Exception) {
// ignored
}
}
public void RemoveExitStub(Room room, MappableDirection direction)
{
try { mControl.Invoke((MethodInvoker) delegate { mCanvas.RemoveExitStub(room, direction); }); }
catch (Exception) {
// ignored
}
}
private static string toAdventuronDirectionName(MappableDirection direction)
{
switch (direction)
{
case MappableDirection.North: return("north_oneway");
case MappableDirection.South: return("south_oneway");
case MappableDirection.East: return("east_oneway");
case MappableDirection.West: return("west_oneway");
case MappableDirection.NorthEast: return("northeast_oneway");
case MappableDirection.NorthWest: return("northwest_oneway");
case MappableDirection.SouthEast: return("southeast_oneway");
case MappableDirection.SouthWest: return("southwest_oneway");
case MappableDirection.Up: return("up_oneway");
case MappableDirection.Down: return("down_oneway");
case MappableDirection.In: return("enter_oneway");
case MappableDirection.Out: return("leave_oneway");
default:
throw new InvalidOperationException("Cannot convert a direction to its Adventuron version.");
}
}
Room IAutomapCanvas.CreateRoom(Room existing, MappableDirection directionFromExisting, string roomName, string line)
{
if (!Project.Current.Elements.Contains(existing))
{
return(null);
}
var room = new Room(Project.Current)
{
Name = roomName
};
if (line != roomName)
{
room.SubTitle = line.Replace(roomName, "");
}
positionRelativeTo(room, existing, CompassPointHelper.GetCompassDirection(directionFromExisting), out var delta);
if (anyRoomsIntersect(room))
{
shiftMap(room.InnerBounds, delta);
Debug.WriteLine("Shift map.");
}
Project.Current.Elements.Add(room);
return(room);
}
public Exit GetBestExit(MappableDirection direction)
{
Exit exit;
if (mMapDirectionToBestExit.TryGetValue(direction, out exit))
{
return(exit);
}
return(null);
}
public Room CreateRoom(Room existing, MappableDirection 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);
}
// Get the priority of the exit, in the given direction, with respect to other exits.
// Higher priorities indicate more suitable exits.
public int GetPriority(MappableDirection direction)
{
if (direction == PrimaryDirection)
{
return(mPrimaryPriority);
}
if (direction == SecondaryDirection)
{
return(1);
}
return(-1);
}
private void writeDoor(TextWriter writer, Location location, MappableDirection 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();
}
// Test whether an exit is reciprocated in the other direction; i.e. is there a bidirectional connection.
public static bool IsReciprocated(Location source, MappableDirection 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, MappableDirection 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();
}
private static string getAlanName(MappableDirection direction)
{
switch (direction)
{
case MappableDirection.North:
return("North");
case MappableDirection.South:
return("South");
case MappableDirection.East:
return("East");
case MappableDirection.West:
return("West");
case MappableDirection.NorthEast:
return("Northeast");
case MappableDirection.SouthEast:
return("Southeast");
case MappableDirection.NorthWest:
return("Northwest");
case MappableDirection.SouthWest:
return("Southwest");
case MappableDirection.Up:
return("Up");
case MappableDirection.Down:
return("Down");
case MappableDirection.In:
return("Inside");
case MappableDirection.Out:
return("Outside");
default:
return("");
throw new InvalidOperationException("Cannot convert a direction to its Inform 7 equivalent.");
}
}
private static string toHugoPropertyName(MappableDirection direction)
{
switch (direction)
{
case MappableDirection.North:
return("n_to");
case MappableDirection.South:
return("s_to");
case MappableDirection.East:
return("e_to");
case MappableDirection.West:
return("w_to");
case MappableDirection.NorthEast:
return("ne_to");
case MappableDirection.NorthWest:
return("nw_to");
case MappableDirection.SouthEast:
return("se_to");
case MappableDirection.SouthWest:
return("sw_to");
case MappableDirection.Up:
return("u_to");
case MappableDirection.Down:
return("d_to");
case MappableDirection.In:
return("in_to");
case MappableDirection.Out:
return("out_to");
default:
Debug.Assert(false, "Unrecognised automap direction.");
return("n_to");
}
}
private static string toTadsPropertyName(MappableDirection direction)
{
switch (direction)
{
case MappableDirection.North:
return("north");
case MappableDirection.South:
return("south");
case MappableDirection.East:
return("east");
case MappableDirection.West:
return("west");
case MappableDirection.NorthEast:
return("northeast");
case MappableDirection.NorthWest:
return("northwest");
case MappableDirection.SouthEast:
return("southeast");
case MappableDirection.SouthWest:
return("southwest");
case MappableDirection.Up:
return("up");
case MappableDirection.Down:
return("down");
case MappableDirection.In:
return("in");
case MappableDirection.Out:
return("out");
default:
Debug.Assert(false, "Unrecognised automap direction.");
return("north");
}
}
/// <summary>
/// Get the literal opposite of any direction.
/// </summary>
public static MappableDirection GetOpposite(MappableDirection direction)
{
switch (direction)
{
case MappableDirection.North:
return(MappableDirection.South);
case MappableDirection.South:
return(MappableDirection.North);
case MappableDirection.East:
return(MappableDirection.West);
case MappableDirection.West:
return(MappableDirection.East);
case MappableDirection.NorthEast:
return(MappableDirection.SouthWest);
case MappableDirection.NorthWest:
return(MappableDirection.SouthEast);
case MappableDirection.SouthEast:
return(MappableDirection.NorthWest);
case MappableDirection.SouthWest:
return(MappableDirection.NorthEast);
case MappableDirection.Up:
return(MappableDirection.Down);
case MappableDirection.Down:
return(MappableDirection.Up);
case MappableDirection.In:
return(MappableDirection.Out);
case MappableDirection.Out:
return(MappableDirection.In);
default:
Debug.Assert(false, "Couldn't work out the opposite of the given direction.");
return(MappableDirection.North);
}
}
/// <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(MappableDirection direction)
{
switch (direction)
{
case MappableDirection.Up:
return(CompassPoint.NorthNorthWest);
case MappableDirection.Down:
return(CompassPoint.SouthSouthWest);
case MappableDirection.In:
return(CompassPoint.EastNorthEast);
case MappableDirection.Out:
return(CompassPoint.WestNorthWest);
case MappableDirection.North:
return(CompassPoint.North);
case MappableDirection.South:
return(CompassPoint.South);
case MappableDirection.East:
return(CompassPoint.East);
case MappableDirection.West:
return(CompassPoint.West);
case MappableDirection.NorthEast:
return(CompassPoint.NorthEast);
case MappableDirection.NorthWest:
return(CompassPoint.NorthWest);
case MappableDirection.SouthEast:
return(CompassPoint.SouthEast);
case MappableDirection.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 toZILPropertyName(MappableDirection direction)
{
switch (direction)
{
case MappableDirection.North:
return("NORTH");
case MappableDirection.South:
return("SOUTH");
case MappableDirection.East:
return("EAST");
case MappableDirection.West:
return("WEST");
case MappableDirection.NorthEast:
return("NE");
case MappableDirection.SouthEast:
return("SE");
case MappableDirection.SouthWest:
return("SW");
case MappableDirection.NorthWest:
return("NW");
case MappableDirection.Up:
return("UP");
case MappableDirection.Down:
return("DOWN");
case MappableDirection.In:
return("IN");
case MappableDirection.Out:
return("OUT");
default:
throw new ArgumentOutOfRangeException(nameof(direction), direction, null);
}
}
void IAutomapCanvas.RemoveExitStub(Room room, MappableDirection direction)
{
if (!Project.Current.Elements.Contains(room))
{
return;
}
var compassPoint = CompassPointHelper.GetCompassDirection(direction);
foreach (var connection in room.GetConnections(compassPoint))
{
var source = connection.GetSourceRoom(out var sourceCompassPoint);
var target = connection.GetTargetRoom(out var targetCompassPoint);
if (source == room && target == room && sourceCompassPoint == compassPoint && targetCompassPoint == compassPoint)
{
Project.Current.Elements.Remove(connection);
}
}
}
private static void writeNormalExit(TextWriter writer, Location location, MappableDirection 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.AddExitStub(Room room, MappableDirection direction)
{
if (!Project.Current.Elements.Contains(room))
{
return;
}
var sourceCompassPoint = CompassPointHelper.GetCompassDirection(direction);
var connection = addConnection(room, sourceCompassPoint, room, sourceCompassPoint);
switch (direction)
{
case MappableDirection.Up:
connection.StartText = Connection.Up;
break;
case MappableDirection.Down:
connection.StartText = Connection.Down;
break;
}
}
private Exit pickBestExit(MappableDirection direction)
{
// sort exits by priority for this direction only
mExits.Sort((a, 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);
}
public Exit GetBestExit(MappableDirection direction)
{
return(mMapDirectionToBestExit.TryGetValue(direction, out var exit) ? exit : null);
}
void IAutomapCanvas.Connect(Room source, MappableDirection directionFromSource, Room target, bool assumeTwoWayConnections)
{
if (!Project.Current.Elements.Contains(source) || !Project.Current.Elements.Contains(target))
{
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 MappableDirection.Up:
case MappableDirection.Down:
case MappableDirection.In:
case MappableDirection.Out:
acceptableSourceCompassPoint = null; // any existing connection will do
break;
default:
acceptableSourceCompassPoint = sourceCompassPoint;
break;
}
var connection = findConnection(source, target, acceptableSourceCompassPoint, out var 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);
if (mAutomap.UseDottedConnection)
{
connection.Style = ConnectionStyle.Dashed;
mAutomap.UseDottedConnection = false;
}
else
{
connection.Style = ConnectionStyle.Solid;
}
connection.Flow = assumeTwoWayConnections ? ConnectionFlow.TwoWay : 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 MappableDirection.Up:
case MappableDirection.Down:
case MappableDirection.In:
case MappableDirection.Out:
if (string.IsNullOrEmpty(connection.StartText) && string.IsNullOrEmpty(connection.EndText))
{
switch (directionFromSource)
{
case MappableDirection.Up:
connection.SetText(wrongWay ? ConnectionLabel.Down : ConnectionLabel.Up);
break;
case MappableDirection.Down:
connection.SetText(wrongWay ? ConnectionLabel.Up : ConnectionLabel.Down);
break;
case MappableDirection.In:
connection.SetText(wrongWay ? ConnectionLabel.Out : ConnectionLabel.In);
break;
case MappableDirection.Out:
connection.SetText(wrongWay ? ConnectionLabel.In : ConnectionLabel.Out);
break;
}
}
break;
}
}
