Cartas........ denovo....! 🃏 (Cards Einstein Engines Patch)

Content.Client/_EstacaoPirata/Cards/Card/CardSystem.cs

@@ -0,0 +1,84 @@
+using System.Linq;
+using Content.Shared._EstacaoPirata.Cards.Card;
+using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
+
+namespace Content.Client._EstacaoPirata.Cards.Card;
+
+/// <summary>
+/// This handles...
+/// </summary>
+public sealed class CardSystem : EntitySystem
+{
+    [Dependency] private readonly SpriteSystem _spriteSystem = default!;
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<CardComponent, ComponentStartup>(OnComponentStartupEvent);
+        SubscribeNetworkEvent<CardFlipUpdatedEvent>(OnFlip);
+    }
+
+    private void OnComponentStartupEvent(EntityUid uid, CardComponent comp, ComponentStartup args)
+    {
+        if (!TryComp(uid, out SpriteComponent? spriteComponent))
+            return;
+
+        for (var i = 0; i < spriteComponent.AllLayers.Count(); i++)
+        {
+            if (!spriteComponent.TryGetLayer(i, out var layer) || layer.State.Name == null)
+                continue;
+
+            var rsi = layer.RSI ?? spriteComponent.BaseRSI;
+            if (rsi == null)
+                continue;
+
+            comp.FrontSprite.Add(new SpriteSpecifier.Rsi(rsi.Path, layer.State.Name));
+        }
+
+        comp.BackSprite ??= comp.FrontSprite;
+        Dirty(uid, comp);
+        UpdateSprite(uid, comp);
+    }
+
+    private void OnFlip(CardFlipUpdatedEvent args)
+    {
+        if (!TryComp(GetEntity(args.Card), out CardComponent? comp))
+            return;
+        UpdateSprite(GetEntity(args.Card), comp);
+    }
+
+    private void UpdateSprite(EntityUid uid, CardComponent comp)
+    {
+        var newSprite = comp.Flipped ? comp.BackSprite : comp.FrontSprite;
+        if (newSprite == null)
+            return;
+
+        if (!TryComp(uid, out SpriteComponent? spriteComponent))
+            return;
+
+        var layerCount = newSprite.Count();
+
+        //inserts Missing Layers
+        if (spriteComponent.AllLayers.Count() < layerCount)
+        {
+            for (var i = spriteComponent.AllLayers.Count(); i < layerCount; i++)
+            {
+                spriteComponent.AddBlankLayer(i);
+            }
+        }
+        //Removes extra layers
+        else if (spriteComponent.AllLayers.Count() > layerCount)
+        {
+            for (var i = spriteComponent.AllLayers.Count() - 1; i >= layerCount; i--)
+            {
+                spriteComponent.RemoveLayer(i);
+            }
+        }
+
+        for (var i = 0; i < newSprite.Count(); i++)
+        {
+            var layer = newSprite[i];
+            spriteComponent.LayerSetSprite(i, layer);
+        }
+    }
+}

Content.Client/_EstacaoPirata/Cards/CardSpriteSystem.cs

@@ -0,0 +1,84 @@
+using System.Linq;
+using Content.Shared._EstacaoPirata.Cards.Stack;
+using Robust.Client.GameObjects;
+
+namespace Content.Client._EstacaoPirata.Cards;
+
+/// <summary>
+/// This handles...
+/// </summary>
+public sealed class CardSpriteSystem : EntitySystem
+{
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+
+    }
+
+    public bool TryAdjustLayerQuantity(Entity<SpriteComponent, CardStackComponent> uid, int? cardLimit = null)
+    {
+        var sprite = uid.Comp1;
+        var stack = uid.Comp2;
+        var cardCount = cardLimit == null ? stack.Cards.Count : Math.Min(stack.Cards.Count, cardLimit.Value);
+
+        var layerCount = 0;
+        //Gets the quantity of layers
+        foreach (var card in stack.Cards.TakeLast(cardCount))
+        {
+            if (!TryComp(card, out SpriteComponent? cardSprite))
+                return false;
+
+            layerCount += cardSprite.AllLayers.Count();
+        }
+        //inserts Missing Layers
+        if (sprite.AllLayers.Count() < layerCount)
+        {
+            for (var i = sprite.AllLayers.Count(); i < layerCount; i++)
+            {
+                sprite.AddBlankLayer(i);
+            }
+        }
+        //Removes extra layers
+        else if (sprite.AllLayers.Count() > layerCount)
+        {
+            for (var i = sprite.AllLayers.Count() - 1; i >= layerCount; i--)
+            {
+                sprite.RemoveLayer(i);
+            }
+        }
+
+
+        return true;
+    }
+
+    public bool TryHandleLayerConfiguration(Entity<SpriteComponent, CardStackComponent> uid, int cardCount, Func<Entity<SpriteComponent>, int, int, bool> layerFunc)
+    {
+        var sprite = uid.Comp1;
+        var stack = uid.Comp2;
+
+        // int = index of what card it is from
+        List<(int, ISpriteLayer)> layers = [];
+
+        var i = 0;
+        foreach (var card in stack.Cards.TakeLast(cardCount))
+        {
+            if (!TryComp(card, out SpriteComponent? cardSprite))
+                return false;
+            layers.AddRange(cardSprite.AllLayers.Select(layer => (i, layer)));
+            i++;
+        }
+
+        var j = 0;
+        foreach (var obj in layers)
+        {
+            var (cardIndex, layer) = obj;
+            sprite.LayerSetVisible(j, true);
+            sprite.LayerSetTexture(j, layer.Texture);
+            sprite.LayerSetState(j, layer.RsiState.Name);
+            layerFunc.Invoke((uid, sprite), cardIndex, j);
+            j++;
+        }
+
+        return true;
+    }
+}

Content.Client/_EstacaoPirata/Cards/Deck/CardDeckSystem.cs

@@ -0,0 +1,149 @@
+using System.Linq;
+using System.Numerics;
+using Content.Shared._EstacaoPirata.Cards.Deck;
+using Content.Shared._EstacaoPirata.Cards.Stack;
+using Robust.Client.GameObjects;
+
+namespace Content.Client._EstacaoPirata.Cards.Deck;
+
+/// <summary>
+/// This handles...
+/// </summary>
+public sealed class CardDeckSystem : EntitySystem
+{
+    private readonly Dictionary<Entity<CardDeckComponent>, int> _notInitialized = [];
+    [Dependency] private readonly CardSpriteSystem _cardSpriteSystem = default!;
+
+
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        UpdatesOutsidePrediction = false;
+        SubscribeLocalEvent<CardDeckComponent, ComponentStartup>(OnComponentStartupEvent);
+        SubscribeNetworkEvent<CardStackInitiatedEvent>(OnStackStart);
+        SubscribeNetworkEvent<CardStackQuantityChangeEvent>(OnStackUpdate);
+        SubscribeNetworkEvent<CardStackReorderedEvent>(OnReorder);
+        SubscribeNetworkEvent<CardStackFlippedEvent>(OnStackFlip);
+        SubscribeLocalEvent<CardDeckComponent, AppearanceChangeEvent>(OnAppearanceChanged);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        // Lazy way to make sure the sprite starts correctly
+        foreach (var kv in _notInitialized)
+        {
+            var ent = kv.Key;
+
+            if (kv.Value >= 5)
+            {
+                _notInitialized.Remove(ent);
+                continue;
+            }
+
+            _notInitialized[ent] = kv.Value + 1;
+
+            if (!TryComp(ent.Owner, out CardStackComponent? stack) || stack.Cards.Count <= 0)
+                continue;
+
+
+            // If the card was STILL not initialized, we skip it
+            if (!TryGetCardLayer(stack.Cards.Last(), out var _))
+                continue;
+
+            // If cards were correctly initialized, we update the sprite
+            UpdateSprite(ent.Owner, ent.Comp);
+            _notInitialized.Remove(ent);
+        }
+
+    }
+
+
+    private bool TryGetCardLayer(EntityUid card, out SpriteComponent.Layer? layer)
+    {
+        layer = null;
+        if (!TryComp(card, out SpriteComponent? cardSprite))
+            return false;
+
+        if (!cardSprite.TryGetLayer(0, out var l))
+            return false;
+
+        layer = l;
+        return true;
+    }
+
+    private void UpdateSprite(EntityUid uid, CardDeckComponent comp)
+    {
+        if (!TryComp(uid, out SpriteComponent? sprite))
+            return;
+
+        if (!TryComp(uid, out CardStackComponent? cardStack))
+            return;
+
+
+        // Prevents error appearing at spawnMenu
+        if (cardStack.Cards.Count <= 0 || !TryGetCardLayer(cardStack.Cards.Last(), out var cardlayer) ||
+            cardlayer == null)
+        {
+            _notInitialized[(uid, comp)] = 0;
+            return;
+        }
+
+        _cardSpriteSystem.TryAdjustLayerQuantity((uid, sprite, cardStack), comp.CardLimit);
+
+        _cardSpriteSystem.TryHandleLayerConfiguration(
+            (uid, sprite, cardStack),
+            comp.CardLimit,
+            (_, cardIndex, layerIndex) =>
+            {
+                sprite.LayerSetRotation(layerIndex, Angle.FromDegrees(90));
+                sprite.LayerSetOffset(layerIndex, new Vector2(0, (comp.YOffset * cardIndex)));
+                sprite.LayerSetScale(layerIndex, new Vector2(comp.Scale, comp.Scale));
+                return true;
+            }
+        );
+    }
+
+    private void OnStackUpdate(CardStackQuantityChangeEvent args)
+    {
+        if (!TryComp(GetEntity(args.Stack), out CardDeckComponent? comp))
+            return;
+        UpdateSprite(GetEntity(args.Stack), comp);
+    }
+
+    private void OnStackFlip(CardStackFlippedEvent args)
+    {
+        if (!TryComp(GetEntity(args.CardStack), out CardDeckComponent? comp))
+            return;
+        UpdateSprite(GetEntity(args.CardStack), comp);
+    }
+
+    private void OnReorder(CardStackReorderedEvent args)
+    {
+        if (!TryComp(GetEntity(args.Stack), out CardDeckComponent? comp))
+            return;
+        UpdateSprite(GetEntity(args.Stack), comp);
+    }
+
+    private void OnAppearanceChanged(EntityUid uid, CardDeckComponent comp, AppearanceChangeEvent args)
+    {
+        UpdateSprite(uid, comp);
+    }
+    private void OnComponentStartupEvent(EntityUid uid, CardDeckComponent comp, ComponentStartup args)
+    {
+
+        UpdateSprite(uid, comp);
+    }
+
+
+    private void OnStackStart(CardStackInitiatedEvent args)
+    {
+        var entity = GetEntity(args.CardStack);
+        if (!TryComp(entity, out CardDeckComponent? comp))
+            return;
+
+        UpdateSprite(entity, comp);
+    }
+
+}