746 lines
33 KiB
C#
746 lines
33 KiB
C#
using Barotrauma.Networking;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using Microsoft.Xna.Framework.Input;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace Barotrauma.Items.Components
|
|
{
|
|
partial class Wire : ItemComponent, IDrawableComponent, IServerSerializable, IClientSerializable
|
|
{
|
|
private readonly struct ClientEventData : IEventData
|
|
{
|
|
public readonly int NodeCount;
|
|
|
|
public ClientEventData(int nodeCount)
|
|
{
|
|
NodeCount = nodeCount;
|
|
}
|
|
}
|
|
|
|
public static Color higlightColor = Color.LightGreen;
|
|
public static Color editorHighlightColor = Color.Yellow;
|
|
public static Color editorSelectedColor = Color.Red;
|
|
|
|
public partial class WireSection
|
|
{
|
|
public VertexPositionColorTexture[] vertices;
|
|
public VertexPositionColorTexture[] shiftedVertices;
|
|
|
|
private float cachedWidth = 0f;
|
|
|
|
private void RecalculateVertices(Sprite wireSprite, float width)
|
|
{
|
|
if (MathUtils.NearlyEqual(cachedWidth, width)) { return; }
|
|
cachedWidth = width;
|
|
|
|
vertices = new VertexPositionColorTexture[4];
|
|
|
|
Vector2 expandDir = start-end;
|
|
expandDir.Normalize();
|
|
float temp = expandDir.X;
|
|
expandDir.X = -expandDir.Y;
|
|
expandDir.Y = -temp;
|
|
|
|
Rectangle srcRect = wireSprite.SourceRect;
|
|
|
|
expandDir *= width * srcRect.Height * 0.5f;
|
|
|
|
Vector2 rectLocation = srcRect.Location.ToVector2();
|
|
Vector2 rectSize = srcRect.Size.ToVector2();
|
|
Vector2 textureSize = new Vector2(wireSprite.Texture.Width, wireSprite.Texture.Height);
|
|
|
|
Vector2 topLeftUv = rectLocation / textureSize;
|
|
Vector2 bottomRightUv = (rectLocation + rectSize) / textureSize;
|
|
|
|
Vector2 invStart = new Vector2(start.X, -start.Y);
|
|
Vector2 invEnd = new Vector2(end.X, -end.Y);
|
|
|
|
vertices[0] = new VertexPositionColorTexture(new Vector3(invStart + expandDir, 0f), Color.White, topLeftUv);
|
|
vertices[2] = new VertexPositionColorTexture(new Vector3(invEnd + expandDir, 0f), Color.White, new Vector2(bottomRightUv.X, topLeftUv.Y));
|
|
vertices[1] = new VertexPositionColorTexture(new Vector3(invStart - expandDir, 0f), Color.White, new Vector2(topLeftUv.X, bottomRightUv.Y));
|
|
vertices[3] = new VertexPositionColorTexture(new Vector3(invEnd - expandDir, 0f), Color.White, bottomRightUv);
|
|
|
|
shiftedVertices = (VertexPositionColorTexture[])vertices.Clone();
|
|
}
|
|
|
|
public void Draw(ISpriteBatch spriteBatch, Sprite wireSprite, Color color, Vector2 offset, float depth, float width = 0.3f)
|
|
{
|
|
if (width <= 0f) { return; }
|
|
RecalculateVertices(wireSprite, width);
|
|
|
|
for (int i = 0; i < vertices.Length; i++)
|
|
{
|
|
shiftedVertices[i].Color = color;
|
|
shiftedVertices[i].Position = vertices[i].Position;
|
|
shiftedVertices[i].Position.X += offset.X;
|
|
shiftedVertices[i].Position.Y -= offset.Y;
|
|
}
|
|
spriteBatch.Draw(
|
|
wireSprite.Texture,
|
|
shiftedVertices,
|
|
depth);
|
|
}
|
|
|
|
public static void Draw(ISpriteBatch spriteBatch, Sprite wireSprite, Vector2 start, Vector2 end, Color color, float depth, float width = 0.3f)
|
|
{
|
|
start.Y = -start.Y;
|
|
end.Y = -end.Y;
|
|
|
|
spriteBatch.Draw(wireSprite.Texture,
|
|
start, wireSprite.SourceRect, color,
|
|
MathUtils.VectorToAngle(end - start),
|
|
new Vector2(0.0f, wireSprite.size.Y / 2.0f),
|
|
new Vector2((Vector2.Distance(start, end)) / wireSprite.size.X, width),
|
|
SpriteEffects.None,
|
|
depth);
|
|
}
|
|
}
|
|
private static Sprite defaultWireSprite;
|
|
private Sprite overrideSprite;
|
|
private Sprite wireSprite;
|
|
|
|
private static Wire draggingWire;
|
|
private static int? selectedNodeIndex;
|
|
private static int? highlightedNodeIndex;
|
|
|
|
[Serialize(0.3f, IsPropertySaveable.No)]
|
|
public float Width
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Vector2 DrawSize
|
|
{
|
|
get { return sectionExtents; }
|
|
}
|
|
|
|
public readonly record struct VisualSignal(
|
|
float TimeSent,
|
|
Color Color,
|
|
int Direction);
|
|
|
|
private VisualSignal lastReceivedSignal;
|
|
|
|
public static Wire DraggingWire
|
|
{
|
|
get => draggingWire;
|
|
}
|
|
|
|
public static Sprite ExtractWireSprite(ContentXElement element)
|
|
{
|
|
defaultWireSprite ??=
|
|
new Sprite("Content/Items/Electricity/signalcomp.png", new Rectangle(970, 47, 14, 16), new Vector2(0.5f, 0.5f))
|
|
{
|
|
Depth = 0.855f
|
|
};
|
|
|
|
Sprite overrideSprite = null;
|
|
foreach (var subElement in element.Elements())
|
|
{
|
|
if (subElement.Name.ToString().Equals("wiresprite", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
overrideSprite = new Sprite(subElement);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return overrideSprite ?? defaultWireSprite;
|
|
}
|
|
|
|
partial void InitProjSpecific(ContentXElement element)
|
|
{
|
|
wireSprite = ExtractWireSprite(element);
|
|
if (wireSprite != defaultWireSprite) { overrideSprite = wireSprite; }
|
|
}
|
|
|
|
public void RegisterSignal(Signal signal, Connection source)
|
|
{
|
|
lastReceivedSignal = new VisualSignal(
|
|
(float)Timing.TotalTimeUnpaused,
|
|
GetSignalColor(signal),
|
|
Direction: source == connections[0] ? 1 : -1);
|
|
}
|
|
|
|
private static readonly Color[] dataSignalColors = new Color[] { Color.White, Color.LightBlue, Color.CornflowerBlue, Color.Blue, Color.BlueViolet, Color.Violet };
|
|
|
|
private static Color GetSignalColor(Signal signal)
|
|
{
|
|
if (signal.value == "0")
|
|
{
|
|
return Color.Red;
|
|
}
|
|
else if (signal.value == "1")
|
|
{
|
|
return Color.LightGreen;
|
|
}
|
|
else if (float.TryParse(signal.value, out float floatValue))
|
|
{
|
|
//convert numeric values to a color (guessing the value might be somewhere in the range of 0-200)
|
|
//so a player with a keen eye can get some info out of the color of the signal
|
|
return ToolBox.GradientLerp(Math.Abs(floatValue / 200.0f), dataSignalColors);
|
|
}
|
|
return Color.LightBlue;
|
|
}
|
|
|
|
public void Draw(SpriteBatch spriteBatch, bool editing, float itemDepth = -1, Color? overrideColor = null)
|
|
{
|
|
Draw(spriteBatch, editing, Vector2.Zero, itemDepth, overrideColor);
|
|
}
|
|
|
|
public void Draw(SpriteBatch spriteBatch, bool editing, Vector2 offset, float itemDepth = -1, Color? overrideColor = null)
|
|
{
|
|
if (sections.Count == 0 && !IsActive || Hidden)
|
|
{
|
|
Drawable = false;
|
|
return;
|
|
}
|
|
|
|
Vector2 drawOffset = GetDrawOffset() + offset;
|
|
|
|
float baseDepth = UseSpriteDepth ? item.SpriteDepth : wireSprite.Depth;
|
|
float depth = item.IsSelected ? 0.0f : SubEditorScreen.IsWiringMode() ? 0.02f : baseDepth + (item.ID % 100) * 0.000001f;// item.GetDrawDepth(wireSprite.Depth, wireSprite);
|
|
|
|
if (item.IsHighlighted)
|
|
{
|
|
foreach (WireSection section in sections)
|
|
{
|
|
section.Draw(spriteBatch, wireSprite,
|
|
Screen.Selected == GameMain.GameScreen ? higlightColor : editorHighlightColor,
|
|
drawOffset, depth + 0.00001f, Width * 2.0f);
|
|
}
|
|
}
|
|
else if (item.IsSelected)
|
|
{
|
|
foreach (WireSection section in sections)
|
|
{
|
|
section.Draw(spriteBatch, wireSprite, editorSelectedColor, drawOffset, depth + 0.00001f, Width * 2.0f);
|
|
}
|
|
}
|
|
|
|
foreach (WireSection section in sections)
|
|
{
|
|
section.Draw(spriteBatch, wireSprite, overrideColor ?? item.Color, drawOffset, depth, Width);
|
|
}
|
|
|
|
if (nodes.Count > 0)
|
|
{
|
|
if (!IsActive)
|
|
{
|
|
if (connections[0] == null) { DrawHangingWire(spriteBatch, nodes[0] + drawOffset, depth); }
|
|
if (connections[1] == null) { DrawHangingWire(spriteBatch, nodes.Last() + drawOffset, depth); }
|
|
}
|
|
if (IsActive && item.ParentInventory?.Owner is Character user && user == Character.Controlled)// && Vector2.Distance(newNodePos, nodes[nodes.Count - 1]) > nodeDistance)
|
|
{
|
|
if (user.CanInteract && currLength < MaxLength)
|
|
{
|
|
Vector2 gridPos = Character.Controlled.Position;
|
|
Vector2 roundedGridPos = new Vector2(
|
|
MathUtils.RoundTowardsClosest(Character.Controlled.Position.X, Submarine.GridSize.X),
|
|
MathUtils.RoundTowardsClosest(Character.Controlled.Position.Y, Submarine.GridSize.Y));
|
|
//Vector2 attachPos = GetAttachPosition(user);
|
|
|
|
if (item.Submarine == null)
|
|
{
|
|
Structure attachTarget = Structure.GetAttachTarget(item.WorldPosition);
|
|
if (attachTarget != null)
|
|
{
|
|
if (attachTarget.Submarine != null)
|
|
{
|
|
//set to submarine-relative position
|
|
gridPos += attachTarget.Submarine.Position;
|
|
roundedGridPos += attachTarget.Submarine.Position;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gridPos += item.Submarine.Position;
|
|
roundedGridPos += item.Submarine.Position;
|
|
}
|
|
|
|
if (!SubEditorScreen.IsSubEditor() || !SubEditorScreen.ShouldDrawGrid)
|
|
{
|
|
Submarine.DrawGrid(spriteBatch, 14, gridPos, roundedGridPos, alpha: 0.25f);
|
|
}
|
|
|
|
WireSection.Draw(
|
|
spriteBatch, wireSprite,
|
|
nodes[^1] + drawOffset,
|
|
new Vector2(newNodePos.X, newNodePos.Y) + drawOffset,
|
|
overrideColor ?? item.Color, 0.0f, Width);
|
|
|
|
WireSection.Draw(
|
|
spriteBatch, wireSprite,
|
|
new Vector2(newNodePos.X, newNodePos.Y) + drawOffset,
|
|
item.DrawPosition,
|
|
overrideColor ?? item.Color, itemDepth, Width);
|
|
|
|
GUI.DrawRectangle(spriteBatch, new Vector2(newNodePos.X + drawOffset.X, -(newNodePos.Y + drawOffset.Y)) - Vector2.One * 3, Vector2.One * 6, item.Color);
|
|
}
|
|
else
|
|
{
|
|
WireSection.Draw(
|
|
spriteBatch, wireSprite,
|
|
nodes[^1] + drawOffset,
|
|
item.DrawPosition,
|
|
overrideColor ?? item.Color, 0.0f, Width);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (ConnectionPanel.ShouldDebugDrawWiring)
|
|
{
|
|
DebugDraw(spriteBatch, alpha: 0.2f);
|
|
}
|
|
|
|
if (!editing || !GameMain.SubEditorScreen.WiringMode) { return; }
|
|
|
|
for (int i = 0; i < nodes.Count; i++)
|
|
{
|
|
Vector2 drawPos = nodes[i];
|
|
if (item.Submarine != null) drawPos += item.Submarine.Position + item.Submarine.HiddenSubPosition;
|
|
drawPos.Y = -drawPos.Y;
|
|
|
|
if ((highlightedNodeIndex == i && item.IsHighlighted) || (selectedNodeIndex == i && item.IsSelected))
|
|
{
|
|
GUI.DrawRectangle(spriteBatch, drawPos + new Vector2(-10, -10), new Vector2(20, 20), editorHighlightColor, false, 0.0f);
|
|
}
|
|
|
|
if (item.IsSelected)
|
|
{
|
|
GUI.DrawRectangle(spriteBatch, drawPos + new Vector2(-5, -5), new Vector2(10, 10), item.Color, true, 0.0f);
|
|
|
|
}
|
|
else
|
|
{
|
|
GUI.DrawRectangle(spriteBatch, drawPos + new Vector2(-3, -3), new Vector2(6, 6), item.Color, true, 0.015f);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DebugDraw(SpriteBatch spriteBatch, float alpha = 1.0f)
|
|
{
|
|
if (sections.Count == 0 || Hidden)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const float PowerPulseSpeedLow = 5.0f;
|
|
const float PowerPulseSpeedHigh = 10.0f;
|
|
const float PowerHighlightScaleLow = 1.5f;
|
|
const float PowerHighlightScaleHigh = 2.5f;
|
|
|
|
const float SignalIndicatorInterval = 15.0f;
|
|
const float SignalIndicatorSpeed = 100.0f;
|
|
|
|
Vector2 drawOffset = GetDrawOffset();
|
|
|
|
Color currentHighlightColor = Color.Transparent;
|
|
float highlightScale = 0.0f;
|
|
if (connections[0] != null && connections[1] != null)
|
|
{
|
|
float voltage = Math.Max(GetVoltage(0), GetVoltage(1));
|
|
float GetVoltage(int connectionIndex)
|
|
{
|
|
var connection1 = connections[connectionIndex];
|
|
var connection2 = connections[1 - connectionIndex];
|
|
if (connection1.IsOutput && connection1.Grid is { Power: > 0.01f } grid1)
|
|
{
|
|
if (connection2.Item.GetComponent<Powered>() is Powered powered &&
|
|
(powered.GetCurrentPowerConsumption(connection2) > 0 || powered is PowerTransfer))
|
|
{
|
|
return grid1.Voltage;
|
|
}
|
|
}
|
|
return 0.0f;
|
|
}
|
|
if (voltage > 0.0f)
|
|
{
|
|
//pulse faster when there's overvoltage
|
|
float pulseSpeed = voltage > 1.2f ? PowerPulseSpeedHigh : PowerPulseSpeedLow;
|
|
float pulseAmount = (MathF.Sin((float)Timing.TotalTimeUnpaused * pulseSpeed) + 1.5f) / 2.5f;
|
|
voltage = Math.Min(voltage, 1.0f);
|
|
highlightScale = MathHelper.Lerp(PowerHighlightScaleLow, PowerHighlightScaleHigh, voltage);
|
|
currentHighlightColor = Color.Red * voltage * pulseAmount;
|
|
}
|
|
}
|
|
if (highlightScale > 0.0f)
|
|
{
|
|
foreach (WireSection section in sections)
|
|
{
|
|
section.Draw(spriteBatch, wireSprite, currentHighlightColor * alpha, drawOffset, 0.0f, Width * highlightScale);
|
|
}
|
|
}
|
|
|
|
float signalDuration = (float)Timing.TotalTimeUnpaused - lastReceivedSignal.TimeSent;
|
|
if (ConnectionPanel.ShouldDebugDrawWiring && signalDuration < 1.0f)
|
|
{
|
|
//make some wires "off sync" so it's easier to differentiate signals on overlapping wires
|
|
float offset = item.ID % 2 == 1 ? SignalIndicatorInterval / 2 : 0.0f;
|
|
float signalProgress = ((float)(Timing.TotalTimeUnpaused * SignalIndicatorSpeed + offset) % SignalIndicatorInterval) * lastReceivedSignal.Direction;
|
|
foreach (WireSection section in sections)
|
|
{
|
|
for (float x = 0; x < section.Length; x += SignalIndicatorInterval)
|
|
{
|
|
Vector2 dir = (section.End - section.Start) / section.Length;
|
|
float posOnSection = x + signalProgress;
|
|
if (posOnSection < 0 || posOnSection > section.Length) { continue; }
|
|
Vector2 signalPos = section.Start + drawOffset + dir * posOnSection;
|
|
float a = 1.0f - Vector2.Distance(Screen.Selected.Cam.WorldViewCenter, signalPos) / 500.0f;
|
|
if (a < 0) { continue; }
|
|
signalPos.Y = -signalPos.Y;
|
|
GUI.DrawRectangle(spriteBatch, signalPos - Vector2.One * 2.5f, Vector2.One * 5, lastReceivedSignal.Color * a * (1.0f - signalDuration) * alpha, isFilled: true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Vector2 GetDrawOffset()
|
|
{
|
|
Submarine sub = item.Submarine;
|
|
if (IsActive && sub == null) // currently being rewired, we need to get the sub from the connections in case the wire has been taken outside
|
|
{
|
|
if (connections[0] != null && connections[0].Item.Submarine != null) { sub = connections[0].Item.Submarine; }
|
|
if (connections[1] != null && connections[1].Item.Submarine != null) { sub = connections[1].Item.Submarine; }
|
|
}
|
|
|
|
if (sub == null)
|
|
{
|
|
return Vector2.Zero;
|
|
}
|
|
else
|
|
{
|
|
return sub.DrawPosition + sub.HiddenSubPosition;
|
|
}
|
|
}
|
|
|
|
private void DrawHangingWire(SpriteBatch spriteBatch, Vector2 start, float depth)
|
|
{
|
|
float angle = (float)Math.Sin(GameMain.GameScreen.GameTime * 2.0f + item.ID) * 0.2f;
|
|
Vector2 endPos = start + new Vector2((float)Math.Sin(angle), -(float)Math.Cos(angle)) * 50.0f;
|
|
|
|
WireSection.Draw(
|
|
spriteBatch, wireSprite,
|
|
start, endPos,
|
|
GUIStyle.Orange, depth + 0.00001f, 0.2f);
|
|
|
|
WireSection.Draw(
|
|
spriteBatch, wireSprite,
|
|
start, start + (endPos - start) * 0.7f,
|
|
item.Color, depth, 0.3f);
|
|
}
|
|
|
|
public static void UpdateEditing(List<Wire> wires)
|
|
{
|
|
var doubleClicked = PlayerInput.DoubleClicked();
|
|
|
|
Wire equippedWire = Character.Controlled.HeldItems.FirstOrDefault(it => it.GetComponent<Wire>() != null)?.GetComponent<Wire>();
|
|
if (equippedWire != null && GUI.MouseOn == null)
|
|
{
|
|
if (PlayerInput.PrimaryMouseButtonClicked() && Character.Controlled.SelectedItem == null)
|
|
{
|
|
equippedWire.Use(1.0f, Character.Controlled);
|
|
}
|
|
return;
|
|
}
|
|
|
|
//dragging a node of some wire
|
|
if (draggingWire != null && !doubleClicked)
|
|
{
|
|
if (Character.Controlled != null)
|
|
{
|
|
Character.Controlled.FocusedItem = null;
|
|
Character.Controlled.DisableInteract = true;
|
|
Character.Controlled.ClearInputs();
|
|
}
|
|
//cancel dragging
|
|
if (!PlayerInput.PrimaryMouseButtonHeld())
|
|
{
|
|
draggingWire = null;
|
|
selectedNodeIndex = null;
|
|
}
|
|
//update dragging
|
|
else
|
|
{
|
|
MapEntity.DisableSelect = true;
|
|
|
|
Submarine sub = draggingWire.item.Submarine;
|
|
if (draggingWire.connections[0] != null && draggingWire.connections[0].Item.Submarine != null) sub = draggingWire.connections[0].Item.Submarine;
|
|
if (draggingWire.connections[1] != null && draggingWire.connections[1].Item.Submarine != null) sub = draggingWire.connections[1].Item.Submarine;
|
|
|
|
Vector2 nodeWorldPos = GameMain.SubEditorScreen.Cam.ScreenToWorld(PlayerInput.MousePosition);
|
|
if (sub != null)
|
|
{
|
|
nodeWorldPos = nodeWorldPos - sub.HiddenSubPosition - sub.Position;
|
|
}
|
|
|
|
if (selectedNodeIndex.HasValue && selectedNodeIndex.Value >= draggingWire.nodes.Count) { selectedNodeIndex = null; }
|
|
if (highlightedNodeIndex.HasValue && highlightedNodeIndex.Value >= draggingWire.nodes.Count) { highlightedNodeIndex = null; }
|
|
|
|
if (selectedNodeIndex.HasValue)
|
|
{
|
|
if (!PlayerInput.IsShiftDown())
|
|
{
|
|
nodeWorldPos.X = MathUtils.Round(nodeWorldPos.X, Submarine.GridSize.X / 2.0f);
|
|
nodeWorldPos.Y = MathUtils.Round(nodeWorldPos.Y, Submarine.GridSize.Y / 2.0f);
|
|
}
|
|
|
|
draggingWire.nodes[(int)selectedNodeIndex] = nodeWorldPos;
|
|
draggingWire.UpdateSections();
|
|
}
|
|
else
|
|
{
|
|
float dragDistance = Submarine.GridSize.X * Submarine.GridSize.Y;
|
|
dragDistance *= 0.5f;
|
|
if ((highlightedNodeIndex.HasValue && Vector2.DistanceSquared(nodeWorldPos, draggingWire.nodes[(int)highlightedNodeIndex]) >= dragDistance) ||
|
|
PlayerInput.IsShiftDown())
|
|
{
|
|
selectedNodeIndex = highlightedNodeIndex;
|
|
}
|
|
}
|
|
|
|
MapEntity.SelectEntity(draggingWire.item);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
bool updateHighlight = true;
|
|
|
|
//a wire has been selected -> check if we should start dragging one of the nodes
|
|
float nodeSelectDist = 10, sectionSelectDist = 5;
|
|
highlightedNodeIndex = null;
|
|
if (MapEntity.SelectedList.Count == 1 && MapEntity.SelectedList.FirstOrDefault() is Item selectedItem)
|
|
{
|
|
Wire selectedWire = selectedItem.GetComponent<Wire>();
|
|
|
|
if (selectedWire != null)
|
|
{
|
|
Vector2 mousePos = GameMain.SubEditorScreen.Cam.ScreenToWorld(PlayerInput.MousePosition);
|
|
if (selectedWire.item.Submarine != null) mousePos -= (selectedWire.item.Submarine.Position + selectedWire.item.Submarine.HiddenSubPosition);
|
|
|
|
//left click while holding ctrl -> check if the cursor is on a wire section,
|
|
//and add a new node if it is
|
|
if (PlayerInput.KeyDown(Keys.RightControl) || PlayerInput.KeyDown(Keys.LeftControl))
|
|
{
|
|
if (PlayerInput.PrimaryMouseButtonClicked())
|
|
{
|
|
if (Character.Controlled != null)
|
|
{
|
|
Character.Controlled.DisableInteract = true;
|
|
Character.Controlled.ClearInputs();
|
|
}
|
|
int closestSectionIndex = selectedWire.GetClosestSectionIndex(mousePos, sectionSelectDist, out _);
|
|
if (closestSectionIndex > -1)
|
|
{
|
|
selectedWire.nodes.Insert(closestSectionIndex + 1, mousePos);
|
|
selectedWire.UpdateSections();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//check if close enough to a node
|
|
int closestIndex = selectedWire.GetClosestNodeIndex(mousePos, nodeSelectDist, out _);
|
|
if (closestIndex > -1)
|
|
{
|
|
highlightedNodeIndex = closestIndex;
|
|
|
|
Vector2 nudge = MapEntity.GetNudgeAmount(doHold: false);
|
|
if (nudge != Vector2.Zero && closestIndex < selectedWire.nodes.Count)
|
|
{
|
|
selectedWire.MoveNode(closestIndex, nudge);
|
|
}
|
|
|
|
//start dragging the node
|
|
if (PlayerInput.PrimaryMouseButtonHeld())
|
|
{
|
|
if (Character.Controlled != null)
|
|
{
|
|
Character.Controlled.DisableInteract = true;
|
|
Character.Controlled.ClearInputs();
|
|
}
|
|
draggingWire = selectedWire;
|
|
//selectedNodeIndex = closestIndex;
|
|
return;
|
|
}
|
|
//remove the node
|
|
else if (PlayerInput.SecondaryMouseButtonClicked() && closestIndex > 0 && closestIndex < selectedWire.nodes.Count - 1)
|
|
{
|
|
selectedWire.nodes.RemoveAt(closestIndex);
|
|
selectedWire.UpdateSections();
|
|
}
|
|
// if only one end of the wire is disconnect pick it back up with double click
|
|
else if (doubleClicked && equippedWire == null && Character.Controlled != null && selectedWire.connections.Any(conn => conn != null))
|
|
{
|
|
if (selectedWire.connections[0] == null && closestIndex == 0 || selectedWire.connections[1] == null && closestIndex == selectedWire.nodes.Count - 1)
|
|
{
|
|
selectedWire.IsActive = true;
|
|
selectedWire.nodes.RemoveAt(closestIndex);
|
|
selectedWire.UpdateSections();
|
|
|
|
// flip the wire
|
|
if (closestIndex == 0)
|
|
{
|
|
selectedWire.nodes.Reverse();
|
|
selectedWire.connections[0] = selectedWire.connections[1];
|
|
selectedWire.connections[1] = null;
|
|
}
|
|
|
|
selectedWire.shouldClearConnections = false;
|
|
Character.Controlled.Inventory.TryPutItem(selectedWire.item, Character.Controlled, new List<InvSlotType> { InvSlotType.LeftHand, InvSlotType.RightHand });
|
|
foreach (var entity in MapEntity.MapEntityList)
|
|
{
|
|
if (entity is Item item)
|
|
{
|
|
item.GetComponent<ConnectionPanel>()?.DisconnectedWires.Remove(selectedWire);
|
|
}
|
|
}
|
|
MapEntity.SelectedList.Clear();
|
|
selectedWire.shouldClearConnections = true;
|
|
updateHighlight = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Wire highlighted = null;
|
|
|
|
//check which wire is highlighted with the cursor
|
|
if (GUI.MouseOn == null)
|
|
{
|
|
float closestDist = float.PositiveInfinity;
|
|
foreach (Wire w in wires)
|
|
{
|
|
Vector2 mousePos = GameMain.SubEditorScreen.Cam.ScreenToWorld(PlayerInput.MousePosition);
|
|
if (w.item.Submarine != null) { mousePos -= (w.item.Submarine.Position + w.item.Submarine.HiddenSubPosition); }
|
|
|
|
int highlightedNode = w.GetClosestNodeIndex(mousePos, highlighted == null ? nodeSelectDist : closestDist, out float dist);
|
|
if (highlightedNode > -1)
|
|
{
|
|
if (dist < closestDist)
|
|
{
|
|
highlightedNodeIndex = highlightedNode;
|
|
highlighted = w;
|
|
closestDist = dist;
|
|
}
|
|
}
|
|
|
|
if (w.GetClosestSectionIndex(mousePos, highlighted == null ? sectionSelectDist : closestDist, out dist) > -1)
|
|
{
|
|
//prefer nodes over sections
|
|
if (dist + nodeSelectDist * 0.5f < closestDist)
|
|
{
|
|
highlightedNodeIndex = null;
|
|
highlighted = w;
|
|
closestDist = dist + nodeSelectDist * 0.5f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (highlighted != null && updateHighlight)
|
|
{
|
|
highlighted.item.IsHighlighted = true;
|
|
if (PlayerInput.PrimaryMouseButtonClicked())
|
|
{
|
|
MapEntity.DisableSelect = true;
|
|
MapEntity.SelectEntity(highlighted.item);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Move(Vector2 amount, bool ignoreContacts = false)
|
|
{
|
|
//only used in the sub editor, hence only in the client project
|
|
if (!item.IsSelected) { return; }
|
|
|
|
Vector2 wireNodeOffset = item.Submarine == null ? Vector2.Zero : item.Submarine.HiddenSubPosition + amount;
|
|
for (int i = 0; i < nodes.Count; i++)
|
|
{
|
|
if (i == 0 || i == nodes.Count - 1)
|
|
{
|
|
if (connections[0]?.Item != null && !connections[0].Item.IsSelected &&
|
|
(Submarine.RectContains(connections[0].Item.Rect, nodes[i] + wireNodeOffset) || Submarine.RectContains(connections[0].Item.Rect, nodes[i] + wireNodeOffset - amount)))
|
|
{
|
|
continue;
|
|
}
|
|
else if (connections[1]?.Item != null && !connections[1].Item.IsSelected &&
|
|
(Submarine.RectContains(connections[1].Item.Rect, nodes[i] + wireNodeOffset) || Submarine.RectContains(connections[1].Item.Rect, nodes[i] + wireNodeOffset - amount)))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
nodes[i] += amount;
|
|
}
|
|
UpdateSections();
|
|
}
|
|
public bool IsMouseOn()
|
|
{
|
|
if (GUI.MouseOn == null)
|
|
{
|
|
Vector2 mousePos = GameMain.SubEditorScreen.Cam.ScreenToWorld(PlayerInput.MousePosition);
|
|
if (item.Submarine != null) { mousePos -= (item.Submarine.Position + item.Submarine.HiddenSubPosition); }
|
|
|
|
if (GetClosestNodeIndex(mousePos, 10, out _) > -1) { return true; }
|
|
if (GetClosestSectionIndex(mousePos, 10, out _) > -1) { return true; }
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void ClientEventRead(IReadMessage msg, float sendingTime)
|
|
{
|
|
int eventIndex = msg.ReadRangedInteger(0, (int)Math.Ceiling(MaxNodeCount / (float)MaxNodesPerNetworkEvent));
|
|
int nodeCount = msg.ReadRangedInteger(0, MaxNodesPerNetworkEvent);
|
|
int nodeStartIndex = eventIndex * MaxNodesPerNetworkEvent;
|
|
|
|
Vector2[] nodePositions = new Vector2[nodeStartIndex + nodeCount];
|
|
for (int i = 0; i < nodes.Count && i < nodePositions.Length; i++)
|
|
{
|
|
nodePositions[i] = nodes[i];
|
|
}
|
|
|
|
for (int i = 0; i < nodeCount; i++)
|
|
{
|
|
nodePositions[nodeStartIndex + i] = new Vector2(msg.ReadSingle(), msg.ReadSingle());
|
|
}
|
|
|
|
if (nodePositions.Any(n => !MathUtils.IsValid(n)))
|
|
{
|
|
nodes.Clear();
|
|
return;
|
|
}
|
|
|
|
nodes = nodePositions.ToList();
|
|
UpdateSections();
|
|
Drawable = nodes.Any();
|
|
IsActive =
|
|
(connections[0] == null ^ connections[1] == null) &&
|
|
(item.ParentInventory is CharacterInventory characterInventory && ((characterInventory.Owner as Character)?.HasEquippedItem(item) ?? false));
|
|
}
|
|
|
|
public override bool ValidateEventData(NetEntityEvent.IData data)
|
|
=> TryExtractEventData<ClientEventData>(data, out _);
|
|
|
|
public void ClientEventWrite(IWriteMessage msg, NetEntityEvent.IData extraData = null)
|
|
{
|
|
var eventData = ExtractEventData<ClientEventData>(extraData);
|
|
int nodeCount = eventData.NodeCount;
|
|
msg.WriteByte((byte)nodeCount);
|
|
if (nodeCount > 0)
|
|
{
|
|
msg.WriteSingle(nodes.Last().X);
|
|
msg.WriteSingle(nodes.Last().Y);
|
|
}
|
|
}
|
|
}
|
|
}
|