public Vector2 Transform(TransformationGrid2D transformation)
{
switch (transformation)
{
case TransformationGrid2D.Identity:
return(this);
case TransformationGrid2D.Rotate90:
return(RotateAroundCenter(90));
case TransformationGrid2D.Rotate180:
return(RotateAroundCenter(180));
case TransformationGrid2D.Rotate270:
return(RotateAroundCenter(270));
case TransformationGrid2D.MirrorX:
return(new Vector2(X, -Y));
case TransformationGrid2D.MirrorY:
return(new Vector2(-X, Y));
case TransformationGrid2D.Diagonal13:
return(new Vector2(Y, X));
case TransformationGrid2D.Diagonal24:
return(new Vector2(-Y, -X));
default:
throw new ArgumentException("Given polygon transformation is not implemented");
}
}
/// <param name="room">See the <see cref="Room"/> property.</param>
/// <param name="outline">See the <see cref="Outline"/> property.</param>
/// <param name="position">See the <see cref="Position"/> property.</param>
/// <param name="isCorridor">See the <see cref="IsCorridor"/> property.</param>
/// <param name="roomTemplate">See the <see cref="RoomTemplate"/> property.</param>
/// <param name="roomDescription">See the <see cref="RoomDescription"/> property.</param>
/// <param name="transformation">See the <see cref="Transformation"/> property.</param>
public LayoutRoomGrid2D(TRoom room, PolygonGrid2D outline, Vector2Int position, bool isCorridor, RoomTemplateGrid2D roomTemplate, RoomDescriptionGrid2D roomDescription, TransformationGrid2D transformation)
{
Room = room;
Outline = outline;
Position = position;
IsCorridor = isCorridor;
RoomTemplate = roomTemplate;
Transformation = transformation;
RoomDescription = roomDescription;
}
public Room(TNode node, PolygonGrid2D shape, Vector2Int position, bool isCorridor, RoomTemplate roomTemplate, IRoomDescription roomDescription, TransformationGrid2D transformation, List <TransformationGrid2D> transformations, RoomTemplateInstance roomTemplateInstance)
{
Node = node;
Shape = shape;
Position = position;
IsCorridor = isCorridor;
RoomTemplate = roomTemplate;
Transformation = transformation;
Transformations = transformations;
RoomTemplateInstance = roomTemplateInstance;
RoomDescription = roomDescription;
}
/// <summary>
/// Transforms a given polygon.
/// </summary>
/// <remarks>
/// Returns a new polygon rather than modifying the original one.
///
/// Some transformations would result in a counter-clockwise order of points, which is currently not allowed.
/// In that case, the order of points is reversed with the first point staying the same.
/// </remarks>
/// <param name="transformation"></param>
/// <returns></returns>
public PolygonGrid2D Transform(TransformationGrid2D transformation)
{
var newPoints = points.Select(x => x.Transform(transformation));
// Change order of points if needed
if (transformation == TransformationGrid2D.MirrorX ||
transformation == TransformationGrid2D.MirrorY ||
transformation == TransformationGrid2D.Diagonal13 ||
transformation == TransformationGrid2D.Diagonal24)
{
var newPointsList = newPoints.ToList();
newPoints = new[] { newPointsList[0] }.Concat(newPointsList.Skip(1).Reverse());
}
return(new PolygonGrid2D(newPoints));
}
public static DoorLineGrid2D TransformDoorLine(DoorLineGrid2D doorLine, TransformationGrid2D transformation)
{
var doorPosition = doorLine.Line;
if (doorPosition.GetDirection() == OrthogonalLineGrid2D.Direction.Undefined)
{
throw new InvalidOperationException("Cannot fix door direction when original direction is undefined");
}
switch (transformation)
{
case TransformationGrid2D.Identity:
return(doorLine);
case TransformationGrid2D.Rotate90:
return(new DoorLineGrid2D(doorPosition.Rotate(90), doorLine.Length, doorLine.DoorSocket));
case TransformationGrid2D.Rotate180:
return(new DoorLineGrid2D(doorPosition.Rotate(180), doorLine.Length, doorLine.DoorSocket));
case TransformationGrid2D.Rotate270:
return(new DoorLineGrid2D(doorPosition.Rotate(270), doorLine.Length, doorLine.DoorSocket));
}
// Other transformations need to switch door directions
var firstStartPoint = doorPosition.From.Transform(transformation);
var lastStartPoint = doorPosition.To.Transform(transformation);
var length = doorLine.Length;
var transformedDirection = TransformDirection(doorPosition.GetDirection(), transformation);
var transformedLine = new OrthogonalLineGrid2D(firstStartPoint, lastStartPoint, transformedDirection);
var lastEndPoint = lastStartPoint + length * transformedLine.GetDirectionVector();
var newDirection = OrthogonalLineGrid2D.GetOppositeDirection(transformedDirection);
var newDoorPosition = new OrthogonalLineGrid2D(lastEndPoint, lastEndPoint + transformedLine.Length * transformedLine.SwitchOrientation().GetDirectionVector(), newDirection);
if (newDoorPosition.Length != doorPosition.Length)
{
throw new InvalidOperationException();
}
return(new DoorLineGrid2D(newDoorPosition, doorLine.Length, doorLine.DoorSocket));
}
public RoomTemplateInstance(RoomTemplate roomTemplate, PolygonGrid2D roomShape, TransformationGrid2D transformation, List <DoorLine> doorLines)
: this(roomTemplate, roomShape, new List <TransformationGrid2D>() { transformation }, doorLines)
{
}
private static OrthogonalLineGrid2D.Direction TransformDirection(OrthogonalLineGrid2D.Direction originalDirection, TransformationGrid2D transformation)
{
if (originalDirection == OrthogonalLineGrid2D.Direction.Undefined)
{
throw new InvalidOperationException("Cannot transform direction when original direction is undefined");
}
switch (transformation)
{
case TransformationGrid2D.MirrorX:
if (IsHorizontal(originalDirection))
{
return(originalDirection);
}
return(OrthogonalLineGrid2D.GetOppositeDirection(originalDirection));
case TransformationGrid2D.MirrorY:
if (IsHorizontal(originalDirection))
{
return(OrthogonalLineGrid2D.GetOppositeDirection(originalDirection));
}
return(originalDirection);
case TransformationGrid2D.Diagonal13:
switch (originalDirection)
{
case OrthogonalLineGrid2D.Direction.Top:
return(OrthogonalLineGrid2D.Direction.Right);
case OrthogonalLineGrid2D.Direction.Right:
return(OrthogonalLineGrid2D.Direction.Top);
case OrthogonalLineGrid2D.Direction.Bottom:
return(OrthogonalLineGrid2D.Direction.Left);
case OrthogonalLineGrid2D.Direction.Left:
return(OrthogonalLineGrid2D.Direction.Bottom);
default:
throw new ArgumentException();
}
case TransformationGrid2D.Diagonal24:
switch (originalDirection)
{
case OrthogonalLineGrid2D.Direction.Top:
return(OrthogonalLineGrid2D.Direction.Left);
case OrthogonalLineGrid2D.Direction.Right:
return(OrthogonalLineGrid2D.Direction.Bottom);
case OrthogonalLineGrid2D.Direction.Bottom:
return(OrthogonalLineGrid2D.Direction.Right);
case OrthogonalLineGrid2D.Direction.Left:
return(OrthogonalLineGrid2D.Direction.Top);
default:
throw new ArgumentException();
}
}
throw new ArgumentException();
}
// TODO: not nice
public static Vector3Int Transform(this Vector3Int vector, TransformationGrid2D transformation)
{
return(vector.ToCustomIntVector2().Transform(transformation).ToUnityIntVector3());
}
