private bool UpdateRoomPosition(Vector2 newRoomPos, Room roomReference, bool moveRooms)
{
VectorInt2 newRoomPosInt = VectorInt2.FromRounded(newRoomPos);
VectorInt2 roomMovement = newRoomPosInt - roomReference.SectorPos;
if (roomMovement != new VectorInt2())
{
if (EditorActions.CheckForLockedRooms(this, _roomsToMove))
{
_roomMouseClicked = null;
}
else
{
var delta = new VectorInt3(roomMovement.X, 0, roomMovement.Y);
if (roomMovement.X != 0 || roomMovement.Y != 0)
{
_overallDelta += delta;
if (moveRooms)
{
EditorActions.MoveRooms(delta, _roomsToMove, true);
return(true);
}
}
}
}
return(false);
}
public MoveRoomsUndoInstance(EditorUndoManager parent, List <Room> rooms, VectorInt3 delta) : base(parent, null)
{
Delta = -delta;
Rooms = rooms;
Rooms.ForEach(room => Sizes.Add(room, room.SectorSize));
Valid = () => Rooms != null && Rooms.All(room => room != null && room.ExistsInLevel && !room.Locked) &&
Rooms.All(room => !Parent.Editor.Level.GetConnectedRooms(room).Except(Rooms).Any()) &&
Rooms.All(room => Sizes.ContainsKey(room) && room.SectorSize == Sizes[room]);
UndoAction = () => EditorActions.MoveRooms(Delta, Rooms, true);
RedoInstance = () => new MoveRoomsUndoInstance(Parent, Rooms, Delta);
}
public void MoveRoomRelative(Room room, VectorInt3 pos)
{
if (panel3D.Camera.RotationY < Math.PI * (1.0 / 4.0))
{
EditorActions.MoveRooms(pos, room.Versions);
}
else if (panel3D.Camera.RotationY < Math.PI * (3.0 / 4.0))
{
EditorActions.MoveRooms(new VectorInt3(pos.Z, pos.Y, -pos.X), room.Versions); // valid
}
else if (panel3D.Camera.RotationY < Math.PI * (5.0 / 4.0))
{
EditorActions.MoveRooms(new VectorInt3(-pos.X, pos.Y, -pos.Z), room.Versions); // valid
}
else if (panel3D.Camera.RotationY < Math.PI * (7.0 / 4.0))
{
EditorActions.MoveRooms(new VectorInt3(-pos.Z, pos.Y, pos.X), room.Versions);
}
else
{
EditorActions.MoveRooms(pos, room.Versions);
}
}
public void MouseMove(MouseEventArgs e, Size parentControlSize)
{
RectangleF barArea = getBarArea(parentControlSize);
switch (_selectionMode)
{
case SelectionMode.SelectedLimit0:
_selectedLimit0 = FromVisualY(barArea, e.Y);
InvalidateParent?.Invoke();
break;
case SelectionMode.SelectedLimit1:
_selectedLimit1 = FromVisualY(barArea, e.Y);
InvalidateParent?.Invoke();
break;
case SelectionMode.SelectedLimitBoth:
float barHeight = _selectedLimit1 - _selectedLimit0;
float newBarPos = FromVisualY(barArea, _barMouseOffset + e.Y);
newBarPos = (float)Math.Max(Math.Min(newBarPos + (double)barHeight, MaxDepth), MinDepth) - barHeight;
_selectedLimit0 = newBarPos;
_selectedLimit1 = newBarPos + barHeight;
InvalidateParent?.Invoke();
break;
case SelectionMode.RoomMove:
float destinationHeight = FromVisualY(barArea, e.Y) - _roomMouseOffset;
if (_roomsToMove == null)
{
HashSet <Room> roomsToMove = new HashSet <Room>();
// If multiple rooms are selected, build a list of rooms to move based on that.
// Otherwise, use only room which was clicked before.
if (_editor.SelectedRooms.Count > 1)
{
foreach (var room in _editor.SelectedRooms)
{
roomsToMove.UnionWith(_editor.Level.GetConnectedRooms(room));
}
}
else
{
roomsToMove = _editor.Level.GetConnectedRooms(_roomMouseClicked);
}
if (EditorActions.CheckForLockedRooms(GetParent?.Invoke(), roomsToMove))
{
_roomsToMove = null;
_selectionMode = SelectionMode.None;
break;
}
_roomsToMove = roomsToMove;
InvalidateParent?.Invoke();
}
// limit room movement to valid range
float maxHeight = MaxDepth;
float minHeight = MinDepth;
foreach (Room room in _roomsToMove)
{
float roomUpperLimit = MaxDepth - (room.Position.Y - _roomMouseClicked.Position.Y + room.GetHighestCorner());
float roomLowerLimit = MinDepth - (room.Position.Y - _roomMouseClicked.Position.Y + room.GetLowestCorner());
maxHeight = Math.Min(maxHeight, roomUpperLimit);
minHeight = Math.Max(minHeight, roomLowerLimit);
}
destinationHeight = Math.Max(Math.Min(destinationHeight, maxHeight), minHeight);
int delta = (int)(Math.Ceiling(destinationHeight) - _roomMouseClicked.Position.Y);
// Snapping
if (!(Control.ModifierKeys.HasFlag(Keys.Alt) || Control.ModifierKeys.HasFlag(Keys.Shift)))
{
HashSet <Room> roomsInGroup = new HashSet <Room>();
List <List <RelevantRoom> > roomSequences = groupBuildRoomSequences(Vector2.Zero, _groupMouseClicked);
for (int i = 0; i < roomSequences.Count; ++i)
{
for (int j = 0; j < roomSequences[i].Count; ++j)
{
roomsInGroup.Add(roomSequences[i][j].Room);
}
}
int highestGroupPoint = _editor.Level.GetHighestRoomGroupPoint(_roomsToMove);
int lowestGroupPoint = _editor.Level.GetLowestRoomGroupPoint(_roomsToMove);
Room nearbyRoom = _editor.Level.GetNearbyRoomBelow(_roomsToMove, roomsInGroup, lowestGroupPoint, _snappingMargin);
if (nearbyRoom != null)
{
if (Math.Abs(delta) <= _snappingMargin)
{
int newDelta = -(lowestGroupPoint - (nearbyRoom.Position.Y + nearbyRoom.GetHighestCorner()));
if (newDelta + highestGroupPoint > MaxDepth)
{
break; // Do not push room out of bounds
}
delta = newDelta;
}
else if (Math.Abs(delta) <= _snappingMargin + 1)
{
break; // Noise reduction
}
}
else
{
nearbyRoom = _editor.Level.GetNearbyRoomAbove(_roomsToMove, roomsInGroup, highestGroupPoint, 5);
if (nearbyRoom != null)
{
if (Math.Abs(delta) <= _snappingMargin)
{
int newDelta = ((nearbyRoom.Position.Y + nearbyRoom.GetLowestCorner()) - highestGroupPoint);
if (newDelta + lowestGroupPoint < MinDepth)
{
break; // Do not push room out of bounds
}
delta = newDelta;
}
else if (Math.Abs(delta) <= _snappingMargin + 1)
{
break; // Noise reduction
}
}
}
}
// do movement
if (delta != 0)
{
_overallDelta += delta;
EditorActions.MoveRooms(new VectorInt3(0, delta, 0), _roomsToMove, true);
}
break;
}
}
