public void CreateUpgradeErrorMessage(string text, bool isSinglePlayer, Character character)
{
// 10 second cooldown on the error message but not the UI sound
if (lastErrorSpeak == DateTime.MinValue || lastErrorSpeak.AddSeconds(10) < DateTime.Now)
{
UpgradeNPCSpeak(text, isSinglePlayer, character);
lastErrorSpeak = DateTime.Now;
}
#if CLIENT
SoundPlayer.PlayUISound(GUISoundType.PickItemFail);
#endif
}
/// <summary>
/// Scrolls the list to the specific element, currently only works when smooth scrolling and PadBottom are enabled.
/// </summary>
/// <param name="component"></param>
public void ScrollToElement(GUIComponent component)
{
SoundPlayer.PlayUISound(GUISoundType.Click);
List <GUIComponent> children = Content.Children.ToList();
int index = children.IndexOf(component);
if (index < 0)
{
return;
}
targetScroll = MathHelper.Clamp(MathHelper.Lerp(0, 1, MathUtils.InverseLerp(0, (children.Count - 0.9f), index)), ScrollBar.MinValue, ScrollBar.MaxValue);
}
private void UpdateBar()
{
if (msgBox != null && !msgBox.Closed && GUIMessageBox.MessageBoxes.Contains(msgBox))
{
if (msgBox.FindChild(TimerData, true) is GUIProgressBar bar)
{
bar.BarSize = time / endTime;
}
}
// play click sound after a second has passed
int second = (int)Math.Ceiling(time);
if (second < lastSecond)
{
SoundPlayer.PlayUISound(GUISoundType.PopupMenu);
lastSecond = second;
}
}
/// <summary>
/// Scrolls the list to the specific element, currently only works when smooth scrolling and PadBottom are enabled.
/// </summary>
/// <param name="component"></param>
public void ScrollToElement(GUIComponent component)
{
SoundPlayer.PlayUISound(GUISoundType.Click);
List <GUIComponent> children = Content.Children.ToList();
int index = children.IndexOf(component);
if (index < 0)
{
return;
}
if (!Content.Children.Contains(component) || !component.Visible)
{
scrollToElement = null;
}
else
{
scrollToElement = component;
}
}
protected bool TrySwapping(int index, Item item, Character user, bool createNetworkEvent, bool swapWholeStack)
{
if (item?.ParentInventory == null || !slots[index].Any())
{
return(false);
}
//swap to InvSlotType.Any if possible
Inventory otherInventory = item.ParentInventory;
bool otherIsEquipped = false;
int otherIndex = -1;
for (int i = 0; i < otherInventory.slots.Length; i++)
{
if (!otherInventory.slots[i].Contains(item))
{
continue;
}
if (otherInventory is CharacterInventory characterInventory)
{
if (characterInventory.SlotTypes[i] == InvSlotType.Any)
{
otherIndex = i;
break;
}
else
{
otherIsEquipped = true;
}
}
}
if (otherIndex == -1)
{
otherIndex = otherInventory.FindIndex(item);
if (otherIndex == -1)
{
DebugConsole.ThrowError("Something went wrong when trying to swap items between inventory slots: couldn't find the source item from it's inventory.\n" + Environment.StackTrace.CleanupStackTrace());
return(false);
}
}
List <Item> existingItems = new List <Item>();
if (swapWholeStack)
{
existingItems.AddRange(slots[index].Items);
for (int j = 0; j < capacity; j++)
{
if (existingItems.Any(existingItem => slots[j].Contains(existingItem)))
{
slots[j].RemoveAllItems();
}
}
}
else
{
existingItems.Add(slots[index].FirstOrDefault());
for (int j = 0; j < capacity; j++)
{
if (existingItems.Any(existingItem => slots[j].Contains(existingItem)))
{
slots[j].RemoveItem(existingItems.First());
}
}
}
List <Item> stackedItems = new List <Item>();
if (swapWholeStack)
{
for (int j = 0; j < otherInventory.capacity; j++)
{
if (otherInventory.slots[j].Contains(item))
{
stackedItems.AddRange(otherInventory.slots[j].Items);
otherInventory.slots[j].RemoveAllItems();
}
}
}
else
{
stackedItems.Add(item);
otherInventory.slots[otherIndex].RemoveItem(item);
}
bool swapSuccessful = false;
if (otherIsEquipped)
{
swapSuccessful =
stackedItems.Distinct().All(stackedItem => TryPutItem(stackedItem, index, false, false, user, createNetworkEvent))
&&
(existingItems.All(existingItem => otherInventory.TryPutItem(existingItem, otherIndex, false, false, user, createNetworkEvent)) ||
existingItems.Count == 1 && otherInventory.TryPutItem(existingItems.First(), user, CharacterInventory.anySlot, createNetworkEvent));
}
else
{
swapSuccessful =
(existingItems.All(existingItem => otherInventory.TryPutItem(existingItem, otherIndex, false, false, user, createNetworkEvent)) ||
existingItems.Count == 1 && otherInventory.TryPutItem(existingItems.First(), user, CharacterInventory.anySlot, createNetworkEvent))
&&
stackedItems.Distinct().All(stackedItem => TryPutItem(stackedItem, index, false, false, user, createNetworkEvent));
if (!swapSuccessful && existingItems.Count == 1 && existingItems[0].AllowDroppingOnSwapWith(item))
{
if (!(existingItems[0].Container?.ParentInventory is CharacterInventory characterInv) ||
!characterInv.TryPutItem(existingItems[0], user, new List <InvSlotType>()
{
InvSlotType.Any
}))
{
existingItems[0].Drop(user, createNetworkEvent);
}
swapSuccessful = stackedItems.Distinct().Any(stackedItem => TryPutItem(stackedItem, index, false, false, user, createNetworkEvent));
#if CLIENT
if (swapSuccessful)
{
SoundPlayer.PlayUISound(GUISoundType.DropItem);
if (otherInventory.visualSlots != null && otherIndex > -1)
{
otherInventory.visualSlots[otherIndex].ShowBorderHighlight(Color.Transparent, 0.1f, 0.1f);
}
}
#endif
}
}
//if the item in the slot can be moved to the slot of the moved item
if (swapSuccessful)
{
System.Diagnostics.Debug.Assert(slots[index].Contains(item), "Something when wrong when swapping items, item is not present in the inventory.");
System.Diagnostics.Debug.Assert(!existingItems.Any(it => !it.Prefab.AllowDroppingOnSwap && !otherInventory.Contains(it)), "Something when wrong when swapping items, item is not present in the other inventory.");
#if CLIENT
if (visualSlots != null)
{
for (int j = 0; j < capacity; j++)
{
if (slots[j].Contains(item))
{
visualSlots[j].ShowBorderHighlight(GUI.Style.Green, 0.1f, 0.9f);
}
}
for (int j = 0; j < otherInventory.capacity; j++)
{
if (otherInventory.slots[j].Contains(existingItems.FirstOrDefault()))
{
otherInventory.visualSlots[j].ShowBorderHighlight(GUI.Style.Green, 0.1f, 0.9f);
}
}
}
#endif
return(true);
}
else //swapping the items failed -> move them back to where they were
{
if (swapWholeStack)
{
foreach (Item stackedItem in stackedItems)
{
for (int j = 0; j < capacity; j++)
{
if (slots[j].Contains(stackedItem))
{
slots[j].RemoveItem(stackedItem);
}
;
}
}
foreach (Item existingItem in existingItems)
{
for (int j = 0; j < otherInventory.capacity; j++)
{
if (otherInventory.slots[j].Contains(existingItem))
{
otherInventory.slots[j].RemoveItem(existingItem);
}
}
}
}
else
{
for (int j = 0; j < capacity; j++)
{
if (slots[j].Contains(item))
{
slots[j].RemoveAllItems();
}
;
}
for (int j = 0; j < otherInventory.capacity; j++)
{
if (otherInventory.slots[j].Contains(existingItems.FirstOrDefault()))
{
otherInventory.slots[j].RemoveAllItems();
}
}
}
if (otherIsEquipped)
{
existingItems.ForEach(existingItem => TryPutItem(existingItem, index, false, false, user, createNetworkEvent));
stackedItems.ForEach(stackedItem => otherInventory.TryPutItem(stackedItem, otherIndex, false, false, user, createNetworkEvent));
}
else
{
stackedItems.ForEach(stackedItem => otherInventory.TryPutItem(stackedItem, otherIndex, false, false, user, createNetworkEvent));
existingItems.ForEach(existingItem => TryPutItem(existingItem, index, false, false, user, createNetworkEvent));
}
#if CLIENT
if (visualSlots != null)
{
for (int j = 0; j < capacity; j++)
{
if (slots[j].Contains(existingItems.FirstOrDefault()))
{
visualSlots[j].ShowBorderHighlight(GUI.Style.Red, 0.1f, 0.9f);
}
}
}
#endif
return(false);
}
}
public override void UpdatePlacing(Camera cam)
{
Vector2 position = Submarine.MouseToWorldGrid(cam, Submarine.MainSub);
if (PlayerInput.SecondaryMouseButtonClicked())
{
selected = null;
return;
}
var potentialContainer = MapEntity.GetPotentialContainer(position);
if (!ResizeHorizontal && !ResizeVertical)
{
if (PlayerInput.PrimaryMouseButtonClicked())
{
var item = new Item(new Rectangle((int)position.X, (int)position.Y, (int)(sprite.size.X * Scale), (int)(sprite.size.Y * Scale)), this, Submarine.MainSub)
{
Submarine = Submarine.MainSub
};
item.SetTransform(ConvertUnits.ToSimUnits(Submarine.MainSub == null ? item.Position : item.Position - Submarine.MainSub.Position), 0.0f);
item.FindHull();
item.Submarine = Submarine.MainSub;
if (PlayerInput.IsShiftDown())
{
if (potentialContainer?.OwnInventory?.TryPutItem(item, Character.Controlled) ?? false)
{
SoundPlayer.PlayUISound(GUISoundType.PickItem);
}
}
SubEditorScreen.StoreCommand(new AddOrDeleteCommand(new List <MapEntity> {
item
}, false));
placePosition = Vector2.Zero;
return;
}
}
else
{
Vector2 placeSize = size * Scale;
if (placePosition == Vector2.Zero)
{
if (PlayerInput.PrimaryMouseButtonHeld())
{
placePosition = position;
}
}
else
{
if (ResizeHorizontal)
{
placeSize.X = Math.Max(position.X - placePosition.X, size.X);
}
if (ResizeVertical)
{
placeSize.Y = Math.Max(placePosition.Y - position.Y, size.Y);
}
if (PlayerInput.PrimaryMouseButtonReleased())
{
var item = new Item(new Rectangle((int)placePosition.X, (int)placePosition.Y, (int)placeSize.X, (int)placeSize.Y), this, Submarine.MainSub);
placePosition = Vector2.Zero;
item.Submarine = Submarine.MainSub;
item.SetTransform(ConvertUnits.ToSimUnits(Submarine.MainSub == null ? item.Position : item.Position - Submarine.MainSub.Position), 0.0f);
item.FindHull();
//selected = null;
return;
}
position = placePosition;
}
}
if (potentialContainer != null)
{
potentialContainer.IsHighlighted = true;
}
//if (PlayerInput.GetMouseState.RightButton == ButtonState.Pressed) selected = null;
}
protected override void Update(float deltaTime)
{
if (!Visible)
{
return;
}
base.Update(deltaTime);
if (Rect.Contains(PlayerInput.MousePosition) && CanBeSelected && CanBeFocused && Enabled && GUI.IsMouseOn(this))
{
State = Selected ?
ComponentState.HoverSelected :
ComponentState.Hover;
if (PlayerInput.PrimaryMouseButtonDown())
{
OnButtonDown?.Invoke();
}
if (PlayerInput.PrimaryMouseButtonHeld())
{
if (OnPressed != null)
{
if (OnPressed())
{
State = ComponentState.Pressed;
}
}
else
{
State = ComponentState.Pressed;
}
}
else if (PlayerInput.PrimaryMouseButtonClicked())
{
SoundPlayer.PlayUISound(ClickSound);
if (OnClicked != null)
{
if (OnClicked(this, UserData))
{
State = ComponentState.Selected;
}
}
else
{
Selected = !Selected;
}
}
}
else
{
if (!ExternalHighlight)
{
State = Selected ? ComponentState.Selected : ComponentState.None;
}
else
{
State = ComponentState.Hover;
}
}
foreach (GUIComponent child in Children)
{
child.State = State;
}
if (Pulse)
{
pulseTimer += deltaTime;
if (pulseTimer > 1.0f)
{
if (!flashed)
{
flashed = true;
Frame.Flash(Color.White * 0.2f, 0.8f, true);
}
pulseExpand += deltaTime;
if (pulseExpand > 1.0f)
{
pulseTimer = 0.0f;
pulseExpand = 0.0f;
flashed = false;
}
}
}
}
/// <summary>
/// Update the selection logic in submarine editor
/// </summary>
public static void UpdateSelecting(Camera cam)
{
if (resizing)
{
if (selectedList.Count == 0)
{
resizing = false;
}
return;
}
foreach (MapEntity e in mapEntityList)
{
e.isHighlighted = false;
}
if (DisableSelect)
{
DisableSelect = false;
return;
}
if (GUI.MouseOn != null || !PlayerInput.MouseInsideWindow)
{
if (highlightedListBox == null ||
(GUI.MouseOn != highlightedListBox && !highlightedListBox.IsParentOf(GUI.MouseOn)))
{
UpdateHighlightedListBox(null, false);
return;
}
}
if (MapEntityPrefab.Selected != null)
{
selectionPos = Vector2.Zero;
selectedList.Clear();
return;
}
if (GUI.KeyboardDispatcher.Subscriber == null)
{
if (PlayerInput.KeyHit(Keys.Delete))
{
if (selectedList.Any())
{
SubEditorScreen.StoreCommand(new AddOrDeleteCommand(selectedList, true));
}
selectedList.ForEach(e => { if (!e.Removed)
{
e.Remove();
}
});
selectedList.Clear();
}
if (PlayerInput.IsCtrlDown())
{
#if DEBUG
if (PlayerInput.KeyHit(Keys.D))
{
bool terminate = false;
foreach (MapEntity entity in selectedList)
{
if (entity is Item item && item.GetComponent <Planter>() is { } planter)
{
planter.Update(1.0f, cam);
for (var i = 0; i < planter.GrowableSeeds.Length; i++)
{
Growable seed = planter.GrowableSeeds[i];
PlantSlot slot = planter.PlantSlots.ContainsKey(i) ? planter.PlantSlots[i] : Planter.NullSlot;
if (seed == null)
{
continue;
}
seed.CreateDebugHUD(planter, slot);
terminate = true;
break;
}
}
if (terminate)
{
break;
}
}
}
#endif
if (PlayerInput.KeyHit(Keys.C))
{
Copy(selectedList);
}
else if (PlayerInput.KeyHit(Keys.X))
{
Cut(selectedList);
}
else if (PlayerInput.KeyHit(Keys.V))
{
Paste(cam.WorldViewCenter);
}
else if (PlayerInput.KeyHit(Keys.G))
{
if (selectedList.Any())
{
if (SelectionGroups.ContainsKey(selectedList.Last()))
{
// Ungroup all selected
selectedList.ForEach(e => SelectionGroups.Remove(e));
}
else
{
foreach (var entity in selectedList)
{
// Remove the old group, if any
SelectionGroups.Remove(entity);
// Create a group that can be accessed with any member
SelectionGroups.Add(entity, selectedList);
}
}
}
}
}
}
Vector2 position = cam.ScreenToWorld(PlayerInput.MousePosition);
MapEntity highLightedEntity = null;
if (startMovingPos == Vector2.Zero)
{
List <MapEntity> highlightedEntities = new List <MapEntity>();
if (highlightedListBox != null && highlightedListBox.IsParentOf(GUI.MouseOn))
{
highLightedEntity = GUI.MouseOn.UserData as MapEntity;
}
else
{
foreach (MapEntity e in mapEntityList)
{
if (!e.SelectableInEditor)
{
continue;
}
if (e.IsMouseOn(position))
{
int i = 0;
while (i < highlightedEntities.Count &&
e.Sprite != null &&
(highlightedEntities[i].Sprite == null || highlightedEntities[i].SpriteDepth < e.SpriteDepth))
{
i++;
}
highlightedEntities.Insert(i, e);
if (i == 0)
{
highLightedEntity = e;
}
}
}
UpdateHighlighting(highlightedEntities);
}
if (highLightedEntity != null)
{
highLightedEntity.isHighlighted = true;
}
}
if (GUI.KeyboardDispatcher.Subscriber == null)
{
int up = PlayerInput.KeyDown(Keys.Up) ? 1 : 0,
down = PlayerInput.KeyDown(Keys.Down) ? -1 : 0,
left = PlayerInput.KeyDown(Keys.Left) ? -1 : 0,
right = PlayerInput.KeyDown(Keys.Right) ? 1 : 0;
int xKeysDown = (left + right);
int yKeysDown = (up + down);
if (xKeysDown != 0 || yKeysDown != 0)
{
keyDelay += (float)Timing.Step;
}
else
{
keyDelay = 0;
}
Vector2 nudgeAmount = Vector2.Zero;
if (keyDelay >= 0.5f)
{
nudgeAmount.Y = yKeysDown;
nudgeAmount.X = xKeysDown;
}
if (PlayerInput.KeyHit(Keys.Up))
{
nudgeAmount.Y = 1f;
}
if (PlayerInput.KeyHit(Keys.Down))
{
nudgeAmount.Y = -1f;
}
if (PlayerInput.KeyHit(Keys.Left))
{
nudgeAmount.X = -1f;
}
if (PlayerInput.KeyHit(Keys.Right))
{
nudgeAmount.X = 1f;
}
if (nudgeAmount != Vector2.Zero)
{
foreach (MapEntity entityToNudge in selectedList)
{
entityToNudge.Move(nudgeAmount);
}
}
}
else
{
keyDelay = 0;
}
bool isShiftDown = PlayerInput.IsShiftDown();
//started moving selected entities
if (startMovingPos != Vector2.Zero)
{
Item targetContainer = GetPotentialContainer(position, selectedList);
if (targetContainer != null)
{
targetContainer.IsHighlighted = true;
}
if (PlayerInput.PrimaryMouseButtonReleased())
{
//mouse released -> move the entities to the new position of the mouse
Vector2 moveAmount = position - startMovingPos;
if (!isShiftDown)
{
moveAmount.X = (float)(moveAmount.X > 0.0f ? Math.Floor(moveAmount.X / Submarine.GridSize.X) : Math.Ceiling(moveAmount.X / Submarine.GridSize.X)) * Submarine.GridSize.X;
moveAmount.Y = (float)(moveAmount.Y > 0.0f ? Math.Floor(moveAmount.Y / Submarine.GridSize.Y) : Math.Ceiling(moveAmount.Y / Submarine.GridSize.Y)) * Submarine.GridSize.Y;
}
if (Math.Abs(moveAmount.X) >= Submarine.GridSize.X || Math.Abs(moveAmount.Y) >= Submarine.GridSize.Y || isShiftDown)
{
if (!isShiftDown)
{
moveAmount = Submarine.VectorToWorldGrid(moveAmount);
}
//clone
if (PlayerInput.IsCtrlDown())
{
var clones = Clone(selectedList).Where(c => c != null).ToList();
selectedList = clones;
SubEditorScreen.StoreCommand(new AddOrDeleteCommand(clones, false));
selectedList.ForEach(c => c.Move(moveAmount));
}
else // move
{
var oldRects = selectedList.Select(e => e.Rect).ToList();
List <MapEntity> deposited = new List <MapEntity>();
foreach (MapEntity e in selectedList)
{
e.Move(moveAmount);
if (isShiftDown && e is Item item && targetContainer != null)
{
if (targetContainer.OwnInventory.TryPutItem(item, Character.Controlled))
{
SoundPlayer.PlayUISound(GUISoundType.DropItem);
deposited.Add(item);
}
else
{
SoundPlayer.PlayUISound(GUISoundType.PickItemFail);
}
}
}
SubEditorScreen.StoreCommand(new TransformCommand(new List <MapEntity>(selectedList), selectedList.Select(entity => entity.Rect).ToList(), oldRects, false));
if (deposited.Any() && deposited.Any(entity => entity is Item))
{
var depositedItems = deposited.Where(entity => entity is Item).Cast <Item>().ToList();
SubEditorScreen.StoreCommand(new InventoryPlaceCommand(targetContainer.OwnInventory, depositedItems, false));
}
deposited.ForEach(entity => { selectedList.Remove(entity); });
}
}
startMovingPos = Vector2.Zero;
}
}
//started dragging a "selection rectangle"
else if (selectionPos != Vector2.Zero)
{
selectionSize.X = position.X - selectionPos.X;
selectionSize.Y = selectionPos.Y - position.Y;
List <MapEntity> newSelection = new List <MapEntity>();// FindSelectedEntities(selectionPos, selectionSize);
if (Math.Abs(selectionSize.X) > Submarine.GridSize.X || Math.Abs(selectionSize.Y) > Submarine.GridSize.Y)
{
newSelection = FindSelectedEntities(selectionPos, selectionSize);
}
else
{
if (highLightedEntity != null)
{
if (SelectionGroups.TryGetValue(highLightedEntity, out List <MapEntity> group))
{
newSelection.AddRange(group);
}
else
{
newSelection.Add(highLightedEntity);
}
}
}
if (PlayerInput.PrimaryMouseButtonReleased())
{
if (PlayerInput.IsCtrlDown())
{
foreach (MapEntity e in newSelection)
{
if (selectedList.Contains(e))
{
RemoveSelection(e);
}
else
{
AddSelection(e);
}
}
}
else
{
selectedList = new List <MapEntity>(newSelection);
//selectedList.Clear();
//newSelection.ForEach(e => AddSelection(e));
foreach (var entity in newSelection)
{
HandleDoorGapLinks(entity,
onGapFound: (door, gap) =>
{
door.RefreshLinkedGap();
if (!selectedList.Contains(gap))
{
selectedList.Add(gap);
}
},
onDoorFound: (door, gap) =>
{
if (!selectedList.Contains(door.Item))
{
selectedList.Add(door.Item);
}
});
}
}
//select wire if both items it's connected to are selected
var selectedItems = selectedList.Where(e => e is Item).Cast <Item>().ToList();
foreach (Item item in selectedItems)
{
if (item.Connections == null)
{
continue;
}
foreach (Connection c in item.Connections)
{
foreach (Wire w in c.Wires)
{
if (w == null || selectedList.Contains(w.Item))
{
continue;
}
if (w.OtherConnection(c) != null && selectedList.Contains(w.OtherConnection(c).Item))
{
selectedList.Add(w.Item);
}
}
}
}
selectionPos = Vector2.Zero;
selectionSize = Vector2.Zero;
}
}
//default, not doing anything specific yet
else
{
if (PlayerInput.PrimaryMouseButtonHeld() &&
PlayerInput.KeyUp(Keys.Space) &&
(highlightedListBox == null || (GUI.MouseOn != highlightedListBox && !highlightedListBox.IsParentOf(GUI.MouseOn))))
{
//if clicking a selected entity, start moving it
foreach (MapEntity e in selectedList)
{
if (e.IsMouseOn(position))
{
startMovingPos = position;
}
}
selectionPos = position;
//stop camera movement to prevent accidental dragging or rect selection
Screen.Selected.Cam.StopMovement();
}
}
}
