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; } }