ГЛОБАЛ | Ивентовый детроит

Content.Client/Imperial/XxRaay/Android/AndroidDisguiseVisualizerSystem.cs

@@ -0,0 +1,94 @@
+using Content.Shared.Humanoid;
+using Content.Shared.Imperial.XxRaay.Android;
+using Robust.Client.GameObjects;
+using Robust.Shared.GameStates;
+
+namespace Content.Client.Imperial.XxRaay.Android;
+
+/// <summary>
+/// Клиентская визуализирующая система маскировки андроида
+///</summary>
+public sealed partial class AndroidDisguiseVisualizerSystem : EntitySystem
+{
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<AndroidDisguiseComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<AndroidDisguiseComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<AndroidDisguiseComponent, AfterAutoHandleStateEvent>(OnAfterState);
+    }
+
+    private void OnStartup(Entity<AndroidDisguiseComponent> ent, ref ComponentStartup args)
+    {
+        var uid = (EntityUid) ent;
+        UpdateVisuals(uid, ent.Comp);
+    }
+
+    private void OnShutdown(Entity<AndroidDisguiseComponent> ent, ref ComponentShutdown args)
+    {
+        if (!TryComp<SpriteComponent>(ent, out var sprite))
+            return;
+
+        var uid = (EntityUid) ent;
+
+        _sprite.LayerSetVisible((uid, sprite), ent.Comp.AndroidBaseLayer, true);
+        _sprite.LayerSetVisible((uid, sprite), ent.Comp.AndroidTransformLayer, false);
+        _sprite.LayerSetVisible((uid, sprite), ent.Comp.AndroidRetransformLayer, false);
+        SetHumanoidVisible((uid, sprite), visible: false);
+    }
+
+    private void OnAfterState(Entity<AndroidDisguiseComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        var uid = (EntityUid) ent;
+        UpdateVisuals(uid, ent.Comp);
+    }
+
+    private void UpdateVisuals(EntityUid uid, AndroidDisguiseComponent comp)
+    {
+        if (!TryComp<SpriteComponent>(uid, out var sprite))
+            return;
+
+
+        _sprite.LayerSetVisible((uid, sprite), comp.AndroidBaseLayer,
+            comp.State is AndroidDisguiseState.Android);
+
+        _sprite.LayerSetVisible((uid, sprite), comp.AndroidTransformLayer,
+            comp.State == AndroidDisguiseState.TransformingToHuman);
+        _sprite.LayerSetVisible((uid, sprite), comp.AndroidRetransformLayer,
+            comp.State == AndroidDisguiseState.TransformingToAndroid);
+
+        var humanoidVisible = comp.State != AndroidDisguiseState.Android;
+        SetHumanoidVisible((uid, sprite), humanoidVisible);
+    }
+
+    private void SetHumanoidVisible(Entity<SpriteComponent> ent, bool visible)
+    {
+        var spriteEnt = ent.AsNullable();
+
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.Chest, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.Head, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.Snout, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.Eyes, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.RArm, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.LArm, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.RLeg, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.LLeg, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.UndergarmentBottom, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.UndergarmentTop, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.LFoot, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.RFoot, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.LHand, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.RHand, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.SnoutCover, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.FacialHair, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.Hair, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.HeadSide, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.HeadTop, visible);
+        _sprite.LayerSetVisible(spriteEnt, HumanoidVisualLayers.Tail, visible);
+    }
+}
+
+

Content.Client/Imperial/XxRaay/Android/AndroidOverlaySystem.cs

@@ -0,0 +1,80 @@
+using Content.Shared.Imperial.XxRaay.Android;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Player;
+
+namespace Content.Client.Imperial.XxRaay.Android;
+
+/// <summary>
+/// Включает клиентский оверлей
+/// </summary>
+public sealed partial class AndroidOverlaySystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMgr = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+
+    private AndroidOverlay? _overlay;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<AndroidOverlayComponent, ComponentInit>(OnOverlayInit);
+        SubscribeLocalEvent<AndroidOverlayComponent, ComponentRemove>(OnOverlayRemove);
+        SubscribeLocalEvent<AndroidOverlayComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<AndroidOverlayComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        RemoveOverlay();
+    }
+
+    private void OnOverlayInit(Entity<AndroidOverlayComponent> ent, ref ComponentInit args)
+    {
+        var local = _player.LocalEntity;
+        if (local != ent)
+            return;
+
+        AddOverlay(ent);
+    }
+
+    private void OnOverlayRemove(Entity<AndroidOverlayComponent> ent, ref ComponentRemove args)
+    {
+        var local = _player.LocalEntity;
+        if (local != ent)
+            return;
+
+        RemoveOverlay();
+    }
+
+    private void OnPlayerAttached(Entity<AndroidOverlayComponent> ent, ref LocalPlayerAttachedEvent args)
+    {
+        AddOverlay(ent);
+    }
+
+    private void OnPlayerDetached(Entity<AndroidOverlayComponent> ent, ref LocalPlayerDetachedEvent args)
+    {
+        RemoveOverlay();
+    }
+
+    private void AddOverlay(Entity<AndroidOverlayComponent> ent)
+    {
+        if (_overlay != null)
+            return;
+
+        _overlay = new AndroidOverlay(ent.Comp.IconSprite, ent.Comp.IconScale);
+        _overlayMgr.AddOverlay(_overlay);
+    }
+
+    private void RemoveOverlay()
+    {
+        if (_overlay == null)
+            return;
+
+        _overlayMgr.RemoveOverlay(_overlay);
+        _overlay = null;
+    }
+}
+

Content.Client/Imperial/XxRaay/Android/Overlays/AndroidOverlay.cs

@@ -0,0 +1,142 @@
+using System.Numerics;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Imperial.XxRaay.Android;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Imperial.XxRaay.Android;
+
+/// <summary>
+/// Оверлей, рисующий иконку над всеми сущностями с <see cref="AndroidStressComponent"/>.
+/// </summary>
+public sealed partial class AndroidOverlay : Overlay
+{
+    [Dependency] private readonly IEntitySystemManager _systems = default!;
+    [Dependency] private readonly IEntityManager _entManager = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly IEyeManager _eye = default!;
+    [Dependency] private readonly IResourceCache _resources = default!;
+
+    private readonly SpriteSystem _sprites;
+    private readonly SharedTransformSystem _xforms;
+    private readonly MapSystem _maps;
+
+    private readonly string _iconSprite;
+    private readonly float _iconScale;
+    private readonly Font _font;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
+
+    public AndroidOverlay(string iconSprite, float iconScale)
+    {
+        IoCManager.InjectDependencies(this);
+
+        _sprites = _systems.GetEntitySystem<SpriteSystem>();
+        _xforms = _systems.GetEntitySystem<SharedTransformSystem>();
+        _maps = _systems.GetEntitySystem<MapSystem>();
+        _iconSprite = iconSprite;
+        _iconScale = iconScale;
+        _font = new VectorFont(_resources.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 9);
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (args.Viewport.Eye == null)
+            return;
+
+        switch (args.Space)
+        {
+            case OverlaySpace.WorldSpace:
+                DrawWorld(args);
+                break;
+            case OverlaySpace.ScreenSpace:
+                DrawScreen(args);
+                break;
+        }
+    }
+
+    private void DrawWorld(in OverlayDrawArgs args)
+    {
+        if (!_maps.TryGetMap(args.MapId, out var mapUid))
+            return;
+
+        var worldHandle = args.WorldHandle;
+        var texture = _sprites.Frame0(ParseSpriteSpecifier(_iconSprite));
+
+        var worldMatrix = _xforms.GetWorldMatrix(mapUid.Value);
+        var invMatrix = _xforms.GetInvWorldMatrix(mapUid.Value);
+
+        var query = _entManager.EntityQueryEnumerator<AndroidStressComponent>();
+        while (query.MoveNext(out var uid, out _))
+        {
+            if (_player.LocalEntity == uid)
+                continue;
+
+            var coords = _xforms.GetMapCoordinates(uid);
+            if (coords.MapId != args.MapId)
+                continue;
+
+            if (!_entManager.TryGetComponent(uid, out AndroidDiodeComponent? diode) || !diode.HasDiode)
+                continue;
+
+            var localPos = Vector2.Transform(coords.Position, invMatrix);
+            var halfSize = 0.5f * _iconScale;
+
+            var aabb = new Box2(
+                localPos - new Vector2(halfSize, halfSize),
+                localPos + new Vector2(halfSize, halfSize));
+
+            var box = new Box2Rotated(aabb, Angle.Zero, localPos);
+
+            worldHandle.SetTransform(worldMatrix);
+            worldHandle.DrawTextureRect(texture, box, Color.White);
+            worldHandle.SetTransform(Matrix3x2.Identity);
+        }
+    }
+
+    private void DrawScreen(in OverlayDrawArgs args)
+    {
+        var screenHandle = args.ScreenHandle;
+
+        var query = _entManager.EntityQueryEnumerator<AndroidStressComponent>();
+        while (query.MoveNext(out var uid, out _))
+        {
+            if (_player.LocalEntity == uid)
+                continue;
+
+            var coords = _xforms.GetMapCoordinates(uid);
+            if (coords.MapId != args.MapId)
+                continue;
+
+            if (!_entManager.TryGetComponent(uid, out AndroidDiodeComponent? diode) || !diode.HasDiode)
+                continue;
+
+            var worldPos = _xforms.GetWorldPosition(uid);
+            var screenPos = _eye.WorldToScreen(worldPos);
+            var name = Identity.Name(uid, _entManager);
+            var textOffset = new Vector2(16f, -6f);
+            screenHandle.DrawString(_font, screenPos + textOffset, name, Color.Cyan);
+        }
+    }
+
+    private static SpriteSpecifier ParseSpriteSpecifier(string value)
+    {
+        var split = value.Split('/', StringSplitOptions.RemoveEmptyEntries);
+        if (split.Length >= 2)
+        {
+            var state = split[^1];
+            var path = string.Join('/', split[..^1]);
+            return new SpriteSpecifier.Rsi(new ResPath(path), state);
+        }
+
+        return new SpriteSpecifier.Texture(new ResPath(value));
+    }
+}
+