public static bool FindDirection(string direction, out ExitDirections exitDirection)
{
exitDirection = ExitDirections.North;
if (direction == "n" || direction == "north")
{
exitDirection = ExitDirections.North;
}
else if (direction == "e" || direction == "east")
{
exitDirection = ExitDirections.East;
}
else if (direction == "s" || direction == "south")
{
exitDirection = ExitDirections.South;
}
else if (direction == "w" || direction == "west")
{
exitDirection = ExitDirections.West;
}
else if (direction == "u" || direction == "up")
{
exitDirection = ExitDirections.Up;
}
else if (direction == "d" || direction == "down")
{
exitDirection = ExitDirections.Down;
}
else if (direction == "n" || direction == "north")
{
exitDirection = ExitDirections.North;
}
else if (direction == "ne" || direction == "northeast")
{
exitDirection = ExitDirections.NorthEast;
}
else if (direction == "nw" || direction == "northwest")
{
exitDirection = ExitDirections.NorthWest;
}
else if (direction == "se" || direction == "southeas")
{
exitDirection = ExitDirections.SouthEast;
}
else if (direction == "sw" || direction == "southwest")
{
exitDirection = ExitDirections.SouthWest;
}
else
{
return(false);
}
return(true);
}
public GridRef GetOffsetGridRef(ExitDirections direction)
{
//Generate grid reference
GridRef[] positionOffsets = new GridRef[] {
new GridRef(0, 1), //Y = N
new GridRef(1, 0), //X = E
new GridRef(0, -1), //-Y = S
new GridRef(-1, 0) //-X = W
};
return(new Place.GridRef(
PlaceGridRef.x + positionOffsets[(int)direction].x,
PlaceGridRef.y + positionOffsets[(int)direction].y
));
}
public static ExitDirections InvertExitState(ExitDirections direction)
{
switch (direction)
{
default:
case ExitDirections.North:
return(ExitDirections.South);
case ExitDirections.South:
return(ExitDirections.North);
case ExitDirections.East:
return(ExitDirections.West);
case ExitDirections.West:
return(ExitDirections.East);
}
}
private bool FindDoor(CommandParameter parameter, out ExitDirections exitDirection, out bool wasAskingForDirection)
{
if (ExitHelpers.FindDirection(parameter.Value, out exitDirection))
{
wasAskingForDirection = true;
return(true);
}
wasAskingForDirection = false;
//exit = Room.Exits.FirstOrDefault(x => x?.Destination != null && x.IsDoor && x.Keywords.Any(k => FindHelpers.StringStartsWith(k, parameter.Value)));
foreach (ExitDirections direction in EnumHelpers.GetValues <ExitDirections>())
{
IExit exit = Room.Exit(direction);
if (exit?.Destination != null && exit.IsDoor && exit.Keywords.Any(k => FindHelpers.StringStartsWith(k, parameter.Value)))
{
exitDirection = direction;
return(true);
}
}
return(false);
}
public static string ShortExitDirections(ExitDirections exitDirections)
{
switch (exitDirections)
{
case ExitDirections.North:
return("N");
case ExitDirections.East:
return("E");
case ExitDirections.South:
return("S");
case ExitDirections.West:
return("W");
case ExitDirections.Up:
return("U");
case ExitDirections.Down:
return("D");
case ExitDirections.NorthEast:
return("ne");
case ExitDirections.NorthWest:
return("nw");
case ExitDirections.SouthEast:
return("se");
case ExitDirections.SouthWest:
return("sw");
default:
return("?");
}
}
public List <ConnectedSceneResult> ConnectedScenes()
{
var scenesSharingCorners = Core.Scenes.CurrentWorldScenes.Where(s => s.CornerPositions.Any(pos => CornerPositions.Contains(pos)));
var output = new List <ConnectedSceneResult>();
bool withinBounds;
foreach (var other in scenesSharingCorners)
{
var onSouthEdge = other.NorthWest.X == SouthWest.X && other.NorthEast.X == SouthEast.X;
withinBounds = other.Size.X < Size.X
? other.NorthWest.Y >= SouthWest.Y && other.NorthEast.Y <= SouthEast.Y
: other.NorthWest.Y <= SouthWest.Y && other.NorthEast.Y >= SouthEast.Y;
if (onSouthEdge && withinBounds)
{
if (other.ExitDirections.HasFlag(SceneExitDirections.North) && ExitDirections.HasFlag(SceneExitDirections.South))
{
output.Add(new ConnectedSceneResult
{
Scene = other,
Direction = SceneExitDirections.South,
ExitPosition = ExitPositions[SceneExitDirections.South],
EdgePointA = other.NorthWest,
EdgePointB = other.NorthEast,
});
}
continue;
}
var onNorthEdge = other.SouthWest.X == NorthWest.X && other.SouthEast.X == NorthEast.X;
withinBounds = other.Size.X < Size.X
? other.SouthWest.Y >= NorthWest.Y && other.SouthEast.Y <= NorthEast.Y
: other.SouthWest.Y <= NorthWest.Y && other.SouthEast.Y >= NorthEast.Y;
if (onNorthEdge && withinBounds)
{
if (other.ExitDirections.HasFlag(SceneExitDirections.South) && ExitDirections.HasFlag(SceneExitDirections.North))
{
output.Add(new ConnectedSceneResult
{
Scene = other,
Direction = SceneExitDirections.North,
ExitPosition = ExitPositions[SceneExitDirections.North],
EdgePointA = other.SouthEast,
EdgePointB = other.SouthWest,
});
}
continue;
}
var onEastEdge = other.NorthWest.Y == NorthEast.Y && other.SouthWest.Y == SouthEast.Y;
withinBounds = other.Size.X < Size.X
? other.NorthWest.X >= NorthEast.X && other.SouthWest.X <= SouthEast.X
: other.NorthWest.X <= NorthEast.X && other.SouthWest.X >= SouthEast.X;
if (onEastEdge && withinBounds)
{
if (other.ExitDirections.HasFlag(SceneExitDirections.West) && ExitDirections.HasFlag(SceneExitDirections.East))
{
output.Add(new ConnectedSceneResult
{
Scene = other,
Direction = SceneExitDirections.East,
ExitPosition = ExitPositions[SceneExitDirections.East],
EdgePointA = other.NorthWest,
EdgePointB = other.SouthWest,
});
}
continue;
}
var onWestEdge = other.NorthEast.Y == NorthWest.Y && other.SouthEast.Y == SouthWest.Y;
withinBounds = other.Size.X < Size.X
? other.NorthEast.X >= NorthWest.X && other.SouthEast.X <= SouthWest.X
: other.NorthEast.X <= NorthWest.X && other.SouthEast.X >= SouthWest.X;
if (onWestEdge && withinBounds)
{
if (other.ExitDirections.HasFlag(SceneExitDirections.East) && ExitDirections.HasFlag(SceneExitDirections.West))
{
output.Add(new ConnectedSceneResult
{
Scene = other,
Direction = SceneExitDirections.West,
ExitPosition = ExitPositions[SceneExitDirections.West],
EdgePointA = other.SouthEast,
EdgePointB = other.NorthEast,
});
}
}
}
return(output);
}
public IExit AddExit(IRoom from, IRoom to, ExitBlueprint blueprint, ExitDirections direction)
{
throw new NotImplementedException();
}
public void OnGreet(ICharacter actor, ExitDirections from)
{
LuaFunction function = GetLuaFunction();
object[] returnedValues = function?.Call(Character, actor, from);
}
public GenerationNode(ExitDirections Direction)
{
exitDirection = Direction;
}
/// <summary>
/// Creates a new room at the given position (bottom left corner) with the given layout.
/// </summary>
/// <param name="posX">The x-Position of the room.</param>
/// <param name="posY">The y-Position of the room.</param>
/// <param name="layout">The layout of the room.</param>
public Room(int posX, int posY, Fast2DArray <TileType> layout, List <TiledImporter.PrefabLocations> gameObjects, RoomType roomType)
{
this.Position = new Vector2Int(posX, posY);
this.Type = roomType;
this.Layout = layout;
this.GameObjects = gameObjects;
this.ExitDirections = new Dictionary <Vector2Int, Direction>();
this.TileCount = 0;
List <Vector2Int> checkedPositions = new List <Vector2Int>();
for (int x = 0; x < this.Layout.XSize; x++)
{
for (int y = 0; y < this.Layout.YSize; y++)
{
if (this.Layout[x, y] == TileType.Floor)
{
TileCount++;
}
if (this.Layout[x, y] == TileType.CorridorAccess && !checkedPositions.Contains(new Vector2Int(x, y)))
{
checkedPositions.Add(new Vector2Int(x, y));
if (this.Layout[x + 1, y] == TileType.CorridorAccess)
{
if (this.Layout[x, y + 1] == TileType.Floor)
{
ExitDirections.Add(new Vector2Int(x, y), Direction.Down);
int delta = 1;
while (this.Layout[x + delta, y] == TileType.CorridorAccess && this.Layout[x + delta + 1, y] == TileType.CorridorAccess)
{
checkedPositions.Add(new Vector2Int(x + delta, y));
ExitDirections.Add(new Vector2Int(x + delta, y), Direction.Down);
delta++;
}
}
else if (this.Layout[x, y - 1] == TileType.Floor)
{
ExitDirections.Add(new Vector2Int(x, y), Direction.Up);
int delta = 1;
while (this.Layout[x + delta, y] == TileType.CorridorAccess && this.Layout[x + delta + 1, y] == TileType.CorridorAccess)
{
checkedPositions.Add(new Vector2Int(x + delta, y));
ExitDirections.Add(new Vector2Int(x + delta, y), Direction.Up);
delta++;
}
}
}
else if (this.Layout[x, y + 1] == TileType.CorridorAccess)
{
if (this.Layout[x + 1, y] == TileType.Floor)
{
ExitDirections.Add(new Vector2Int(x, y), Direction.Left);
int delta = 1;
while (this.Layout[x, y + delta] == TileType.CorridorAccess && this.Layout[x, y + delta + 1] == TileType.CorridorAccess && this.Layout[x, y + delta + 2] == TileType.CorridorAccess)
{
checkedPositions.Add(new Vector2Int(x, y + delta));
ExitDirections.Add(new Vector2Int(x, y + delta), Direction.Left);
delta++;
}
checkedPositions.Add(new Vector2Int(x, y + delta));
}
else if (this.Layout[x - 1, y] == TileType.Floor)
{
ExitDirections.Add(new Vector2Int(x, y), Direction.Right);
int delta = 1;
while (this.Layout[x, y + delta] == TileType.CorridorAccess && this.Layout[x, y + delta + 1] == TileType.CorridorAccess && this.Layout[x, y + delta + 2] == TileType.CorridorAccess)
{
checkedPositions.Add(new Vector2Int(x, y + delta));
ExitDirections.Add(new Vector2Int(x, y + delta), Direction.Right);
delta++;
}
checkedPositions.Add(new Vector2Int(x, y + delta));
}
}
}
}
}
}
public IExit Exit(ExitDirections direction)
{
return(Exits[(int)direction]);
}
public IRoom GetRoom(ExitDirections direction)
{
IExit exit = Exit(direction);
return(exit?.Destination);
}
