tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix pinpointer flicker (#15452)

Browse Source
This commit is contained in:
Slava0135
2023-05-07 11:20:43 +03:00
committed by GitHub
parent 7b5ad3ca83
commit dce7741b9d
6 changed files with 322 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
Content.Client/Pinpointer/PinpointerSystem.cs
View File

@@ -1,78 +1,41 @@
using Content.Shared.Pinpointer;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Shared.GameStates;
namespace Content.Client.Pinpointer
{
namespace Content.Client.Pinpointer;
public sealed class PinpointerSystem : SharedPinpointerSystem
{
[Dependency] private readonly IEyeManager _eyeManager = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
public override void Initialize()
public override void Update(float frameTime)
{
base.Initialize();
SubscribeLocalEvent<PinpointerComponent, ComponentHandleState>(HandleCompState);
}
public override void FrameUpdate(float frameTime)
{
base.FrameUpdate(frameTime);
base.Update(frameTime);
// we want to show pinpointers arrow direction relative
// to players eye rotation (like it was in SS13)
// because eye can change it rotation anytime
// we need to update this arrow in a update loop
foreach (var pinpointer in EntityQuery<PinpointerComponent>())
var query = EntityQueryEnumerator<PinpointerComponent, SpriteComponent>();
while (query.MoveNext(out var _, out var pinpointer, out var sprite))
{
UpdateAppearance(pinpointer.Owner, pinpointer);
UpdateEyeDir(pinpointer.Owner, pinpointer);
}
}
private void HandleCompState(EntityUid uid, PinpointerComponent pinpointer, ref ComponentHandleState args)
{
if (args.Current is not PinpointerComponentState state)
return;
pinpointer.IsActive = state.IsActive;
pinpointer.ArrowAngle = state.ArrowAngle;
pinpointer.DistanceToTarget = state.DistanceToTarget;
}
private void UpdateAppearance(EntityUid uid, PinpointerComponent? pinpointer = null,
AppearanceComponent? appearance = null)
{
if (!Resolve(uid, ref pinpointer, ref appearance))
return;
_appearance.SetData(uid, PinpointerVisuals.IsActive, pinpointer.IsActive, appearance);
_appearance.SetData(uid, PinpointerVisuals.TargetDistance, pinpointer.DistanceToTarget, appearance);
}
private void UpdateArrowAngle(EntityUid uid, Angle angle, PinpointerComponent? pinpointer = null,
AppearanceComponent? appearance = null)
{
if (!Resolve(uid, ref pinpointer, ref appearance))
return;
_appearance.SetData(uid, PinpointerVisuals.ArrowAngle, angle, appearance);
}
/// <summary>
/// Transform pinpointer arrow from world space to eye space
/// And send it to the appearance component
/// </summary>
private void UpdateEyeDir(EntityUid uid, PinpointerComponent? pinpointer = null)
{
if (!Resolve(uid, ref pinpointer) || !pinpointer.HasTarget)
return;
if (!pinpointer.HasTarget)
continue;
var eye = _eyeManager.CurrentEye;
var angle = pinpointer.ArrowAngle + eye.Rotation;
UpdateArrowAngle(uid, angle, pinpointer);
switch (pinpointer.DistanceToTarget)
{
case Distance.Close:
case Distance.Medium:
case Distance.Far:
sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
break;
default:
sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
break;
}
}
}
}

60
Content.Client/Pinpointer/PinpointerVisualizerSystem.cs
View File

@@ -1,60 +0,0 @@
using Content.Shared.Pinpointer;
using JetBrains.Annotations;
using Robust.Client.GameObjects;
namespace Content.Client.Pinpointer
{
[UsedImplicitly]
public sealed class PinpointerVisualizerSystem : VisualizerSystem<PinpointerComponent>
{
protected override void OnAppearanceChange(EntityUid uid, PinpointerComponent component, ref AppearanceChangeEvent args)
{
base.OnAppearanceChange(uid, component, ref args);
if (!TryComp(component.Owner, out SpriteComponent? sprite))
return;
// check if pinpointer screen is active
if (!AppearanceSystem.TryGetData<bool>(uid, PinpointerVisuals.IsActive, out var isActive, args.Component) || !isActive)
{
sprite.LayerSetVisible(PinpointerLayers.Screen, false);
return;
}
sprite.LayerSetVisible(PinpointerLayers.Screen, true);
// check distance and direction to target
if (!AppearanceSystem.TryGetData<Distance>(uid, PinpointerVisuals.TargetDistance, out var dis, args.Component) ||
!AppearanceSystem.TryGetData<Angle>(uid, PinpointerVisuals.ArrowAngle, out var angle, args.Component))
{
sprite.LayerSetState(PinpointerLayers.Screen, "pinonnull");
sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
return;
}
switch (dis)
{
case Distance.Reached:
sprite.LayerSetState(PinpointerLayers.Screen, "pinondirect");
sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
break;
case Distance.Close:
sprite.LayerSetState(PinpointerLayers.Screen, "pinonclose");
sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
break;
case Distance.Medium:
sprite.LayerSetState(PinpointerLayers.Screen, "pinonmedium");
sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
break;
case Distance.Far:
sprite.LayerSetState(PinpointerLayers.Screen, "pinonfar");
sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
break;
case Distance.Unknown:
sprite.LayerSetState(PinpointerLayers.Screen, "pinonnull");
sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
break;
}
}
}
}

52
Content.Server/Pinpointer/PinpointerSystem.cs
View File

@@ -4,11 +4,12 @@ using System.Linq;
using Robust.Shared.Utility;
using Content.Server.Shuttles.Events;
namespace Content.Server.Pinpointer
{
namespace Content.Server.Pinpointer;
public sealed class PinpointerSystem : SharedPinpointerSystem
{
[Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
public override void Initialize()
{
@@ -23,15 +24,35 @@ namespace Content.Server.Pinpointer
LocateTarget(uid, component);
}
public bool TogglePinpointer(EntityUid uid, PinpointerComponent? pinpointer = null)
{
if (!Resolve(uid, ref pinpointer))
return false;
var isActive = !pinpointer.IsActive;
SetActive(uid, isActive, pinpointer);
UpdateAppearance(uid, pinpointer);
return isActive;
}
private void UpdateAppearance(EntityUid uid, PinpointerComponent pinpointer, AppearanceComponent? appearance = null)
{
if (!Resolve(uid, ref appearance))
return;
_appearance.SetData(uid, PinpointerVisuals.IsActive, pinpointer.IsActive, appearance);
_appearance.SetData(uid, PinpointerVisuals.TargetDistance, pinpointer.DistanceToTarget, appearance);
}
private void OnLocateTarget(ref FTLCompletedEvent ev)
{
// This feels kind of expensive, but it only happens once per hyperspace jump
// todo: ideally, you would need to raise this event only on jumped entities
// this code update ALL pinpointers in game
foreach (var pinpointer in EntityQuery<PinpointerComponent>())
var query = EntityQueryEnumerator<PinpointerComponent>();
while (query.MoveNext(out var uid, out var pinpointer))
{
LocateTarget(pinpointer.Owner, pinpointer);
LocateTarget(uid, pinpointer);
}
}
@@ -58,9 +79,10 @@ namespace Content.Server.Pinpointer
// because target or pinpointer can move
// we need to update pinpointers arrow each frame
foreach (var pinpointer in EntityQuery<PinpointerComponent>())
var query = EntityQueryEnumerator<PinpointerComponent>();
while (query.MoveNext(out var uid, out var pinpointer))
{
UpdateDirectionToTarget(pinpointer.Owner, pinpointer);
UpdateDirectionToTarget(uid, pinpointer);
}
}
@@ -115,11 +137,8 @@ namespace Content.Server.Pinpointer
/// <summary>
/// Update direction from pinpointer to selected target (if it was set)
/// </summary>
private void UpdateDirectionToTarget(EntityUid uid, PinpointerComponent? pinpointer = null)
private void UpdateDirectionToTarget(EntityUid uid, PinpointerComponent pinpointer)
{
if (!Resolve(uid, ref pinpointer))
return;
if (!pinpointer.IsActive)
return;
@@ -131,17 +150,20 @@ namespace Content.Server.Pinpointer
}
var dirVec = CalculateDirection(uid, target.Value);
var oldDist = pinpointer.DistanceToTarget;
if (dirVec != null)
{
var angle = dirVec.Value.ToWorldAngle();
TrySetArrowAngle(uid, angle, pinpointer);
var dist = CalculateDistance(uid, dirVec.Value, pinpointer);
var dist = CalculateDistance(dirVec.Value, pinpointer);
SetDistance(uid, dist, pinpointer);
}
else
{
SetDistance(uid, Distance.Unknown, pinpointer);
}
if (oldDist != pinpointer.DistanceToTarget)
UpdateAppearance(uid, pinpointer);
}
/// <summary>
@@ -163,15 +185,12 @@ namespace Content.Server.Pinpointer
return null;
// get world direction vector
var dir = (_transform.GetWorldPosition(trg, xformQuery) - _transform.GetWorldPosition(pin, xformQuery));
var dir = _transform.GetWorldPosition(trg, xformQuery) - _transform.GetWorldPosition(pin, xformQuery);
return dir;
}
private Distance CalculateDistance(EntityUid uid, Vector2 vec, PinpointerComponent? pinpointer = null)
private static Distance CalculateDistance(Vector2 vec, PinpointerComponent pinpointer)
{
if (!Resolve(uid, ref pinpointer))
return Distance.Unknown;
var dist = vec.Length;
if (dist <= pinpointer.ReachedDistance)
return Distance.Reached;
@@ -183,4 +202,3 @@ namespace Content.Server.Pinpointer
return Distance.Far;
}
}
}

43
Content.Shared/Pinpointer/PinpointerComponent.cs
View File

@@ -1,48 +1,52 @@
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
namespace Content.Shared.Pinpointer
{
namespace Content.Shared.Pinpointer;
/// <summary>
/// Displays a sprite on the item that points towards the target component.
/// </summary>
[RegisterComponent]
[NetworkedComponent]
[RegisterComponent, NetworkedComponent]
[AutoGenerateComponentState]
[Access(typeof(SharedPinpointerSystem))]
public sealed class PinpointerComponent : Component
public sealed partial class PinpointerComponent : Component
{
// TODO: Type serializer oh god
[DataField("component")]
public string? Component;
[DataField("mediumDistance")]
[DataField("mediumDistance"), ViewVariables(VVAccess.ReadWrite)]
public float MediumDistance = 16f;
[DataField("closeDistance")]
[DataField("closeDistance"), ViewVariables(VVAccess.ReadWrite)]
public float CloseDistance = 8f;
[DataField("reachedDistance")]
[DataField("reachedDistance"), ViewVariables(VVAccess.ReadWrite)]
public float ReachedDistance = 1f;
/// <summary>
/// Pinpointer arrow precision in radians.
/// </summary>
[DataField("precision")]
[DataField("precision"), ViewVariables(VVAccess.ReadWrite)]
public double Precision = 0.09;
[ViewVariables]
public EntityUid? Target = null;
public bool IsActive = false;
public Angle ArrowAngle;
public Distance DistanceToTarget = Distance.Unknown;
public bool HasTarget => DistanceToTarget != Distance.Unknown;
}
[Serializable, NetSerializable]
public sealed class PinpointerComponentState : ComponentState
{
public bool IsActive;
[ViewVariables]
[AutoNetworkedField]
public bool IsActive = false;
[ViewVariables]
[AutoNetworkedField]
public Angle ArrowAngle;
public Distance DistanceToTarget;
[ViewVariables]
[AutoNetworkedField]
public Distance DistanceToTarget = Distance.Unknown;
[ViewVariables]
public bool HasTarget => DistanceToTarget != Distance.Unknown;
}
[Serializable, NetSerializable]
@@ -54,4 +58,3 @@ namespace Content.Shared.Pinpointer
Medium,
Far
}
}

36
Content.Shared/Pinpointer/SharedPinpointerSystem.cs
View File

@@ -1,25 +1,7 @@
using Robust.Shared.GameStates;
namespace Content.Shared.Pinpointer;
namespace Content.Shared.Pinpointer
{
public abstract class SharedPinpointerSystem : EntitySystem
{
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<PinpointerComponent, ComponentGetState>(GetCompState);
}
private void GetCompState(EntityUid uid, PinpointerComponent pinpointer, ref ComponentGetState args)
{
args.State = new PinpointerComponentState
{
IsActive = pinpointer.IsActive,
ArrowAngle = pinpointer.ArrowAngle,
DistanceToTarget = pinpointer.DistanceToTarget
};
}
/// <summary>
/// Manually set distance from pinpointer to target
/// </summary>
@@ -67,20 +49,4 @@ namespace Content.Shared.Pinpointer
pinpointer.IsActive = isActive;
Dirty(pinpointer);
}
/// <summary>
/// Toggle Pinpointer screen. If it has target it will start tracking it.
/// </summary>
/// <returns>True if pinpointer was activated, false otherwise</returns>
public bool TogglePinpointer(EntityUid uid, PinpointerComponent? pinpointer = null)
{
if (!Resolve(uid, ref pinpointer))
return false;
var isActive = !pinpointer.IsActive;
SetActive(uid, isActive, pinpointer);
return isActive;
}
}
}

17
Resources/Prototypes/Entities/Objects/Devices/pinpointer.yml
View File

@@ -8,7 +8,6 @@
- type: Transform
noRot: True
- type: Sprite
netsync: false
noRot: True
sprite: Objects/Devices/pinpointer.rsi
layers:
@@ -16,10 +15,26 @@
map: ["enum.PinpointerLayers.Base"]
- state: pinonnull
map: ["enum.PinpointerLayers.Screen"]
shader: unshaded
visible: false
- type: Item
sprite: Objects/Devices/pinpointer.rsi
- type: Pinpointer
- type: Appearance
- type: GenericVisualizer
visuals:
enum.PinpointerVisuals.IsActive:
enum.PinpointerLayers.Screen:
True: { visible: True }
False: { visible: False }
enum.PinpointerVisuals.TargetDistance:
enum.PinpointerLayers.Screen:
Unknown: { state: pinonnull }
Reached: { state: pinondirect }
Close: { state: pinonclose }
Medium: { state: pinonmedium }
Far: { state: pinonfar }
- type: AnimationPlayer
- type: entity
name: pinpointer