Supermatter crystal

Content.Client/SS220/Cartridges/SupermatterCartridgeObserverUI.cs

@@ -0,0 +1,57 @@
+// © SS220, An EULA/CLA with a hosting restriction, full text: https://raw.githubusercontent.com/SerbiaStrong-220/space-station-14/master/CLA.txt
+using Content.Client.UserInterface.Fragments;
+using Robust.Client.UserInterface;
+using Content.Shared.SS220.SuperMatter.Ui;
+
+namespace Content.Client.SS220.Cartridges;
+
+public sealed partial class SupermatterObserverUi : UIFragment
+{
+    public bool IsInitd => _isInitd;
+
+    private SupermatterObserverUiFragment? _fragment;
+    private bool _isInitd = true;
+
+    public override Control GetUIFragmentRoot()
+    {
+        return _fragment!;
+    }
+    public override void Setup(BoundUserInterface userInterface, EntityUid? fragmentOwner)
+    {
+        _fragment = new SupermatterObserverUiFragment();
+        _isInitd = false;
+
+        _fragment.OnServerButtonPressed += (args, observerComp) =>
+            {
+                if (args.Button.Pressed)
+                    _fragment.Observer = observerComp;
+                else
+                    _fragment.Observer = null;
+                _fragment.CrystalKey = null;
+                _fragment.LoadCrystal();
+            };
+        _fragment.OnCrystalButtonPressed += (args, crystalKey) =>
+            {
+                if (args.Button.Pressed)
+                    _fragment.CrystalKey = crystalKey;
+                else
+                    _fragment.CrystalKey = null;
+                _fragment.LoadCachedData();
+            };
+        _fragment.OnRefreshButton += (_) =>
+            _isInitd = false;
+    }
+    public override void UpdateState(BoundUserInterfaceState state)
+    {
+        switch (state)
+        {
+            case SuperMatterObserverInitState msg:
+                _fragment?.LoadState(msg.ObserverEntity);
+                _isInitd = true;
+                break;
+            case SuperMatterObserverUpdateState msg:
+                _fragment?.UpdateState(msg);
+                break;
+        }
+    }
+}

Content.Client/SS220/Cartridges/SupermatterObserverUiFragment.xaml

@@ -0,0 +1,44 @@
+ <!-- © SS220, An EULA/CLA with a hosting restriction, full text: https://raw.githubusercontent.com/SerbiaStrong-220/space-station-14/master/CLA.txt -->
+<cartridges:SupermatterObserverUiFragment
+    xmlns="https://spacestation14.io"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:pda="clr-namespace:Content.Client.PDA"
+    xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+    xmlns:cartridges="clr-namespace:Content.Client.SS220.Cartridges"
+    xmlns:plot="clr-namespace:Content.Client.SS220.UserInterface.PlotFigure"
+    xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls" VerticalExpand="True" Margin="1 0 2 0">
+    <Control HorizontalExpand="True">
+        <PanelContainer>
+            <PanelContainer.PanelOverride>
+                <gfx:StyleBoxFlat BackgroundColor="#1B1B1E"/>
+            </PanelContainer.PanelOverride>
+        </PanelContainer>
+        <BoxContainer Name="ContentHolderContainer" Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True">
+            <BoxContainer Orientation="Horizontal" VerticalAlignment="Center" HorizontalExpand="True">
+                <BoxContainer Name="ServerNavigationBar" HorizontalAlignment="Left" VerticalAlignment="Center" HorizontalExpand="True" MinHeight="24" MaxHeight="24" Margin="2 2 6 2">
+                <!-- Here goes all avaible "Servers" with SM data -->
+                </BoxContainer>
+                <pda:PdaNavigationButton Name="RefreshButton" SetWidth="32" CurrentTabBorderThickness="0 0 2 0" IsCurrent="True"/>
+            </BoxContainer>
+            <PanelContainer StyleClasses="LowDivider" Margin="2 0 2 0"/>
+            <BoxContainer Name="CrystalNavigationBar" VerticalAlignment="Center" HorizontalExpand="True" MinHeight="24" MaxHeight="24" Margin="2 2 6 2">
+            <!-- Here goes all avaible "Servers" with SM data -->
+            </BoxContainer>
+            <PanelContainer StyleClasses="LowDivider" Margin="2 0 2 0"/>
+            <ScrollContainer VerticalExpand="True" HorizontalExpand="True">
+                <BoxContainer Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True">
+                    <plot:PlotSequencedView Name="PlotValueOverTime" HorizontalExpand="True" MinSize="168 232" MouseFilter="Stop" Margin="2 4 20 4"/>
+                    <PanelContainer StyleClasses="LowDivider" Margin="2 0 2 0"/>
+                    <plot:Pseudo3DColoredView Name="ColorState" HorizontalExpand="True" MouseFilter="Stop" MinSize="168 232"
+                        Margin="2 4 20 4" Offsets="1 1" Sizes="100 100" Steps="25 100"/>
+                </BoxContainer>
+            </ScrollContainer>
+            <BoxContainer Orientation="Vertical">
+                <PanelContainer StyleClasses="LowDivider" />
+                <BoxContainer Orientation="Horizontal" Margin="10 2 5 0" VerticalAlignment="Bottom">
+                    <Label Text="{Loc 'smObserver-cartridge-footer-left'}" StyleClasses="WindowFooterText" />
+                </BoxContainer>
+            </BoxContainer>
+        </BoxContainer>
+    </Control>
+</cartridges:SupermatterObserverUiFragment>

Content.Client/SS220/Cartridges/SupermatterObserverUiFragment.xaml.cs

@@ -0,0 +1,133 @@
+// © SS220, An EULA/CLA with a hosting restriction, full text: https://raw.githubusercontent.com/SerbiaStrong-220/space-station-14/master/CLA.txt
+using System.Linq;
+using System.Numerics;
+using Content.Client.SS220.SuperMatter.Observer;
+using Content.Client.SS220.UserInterface.PlotFigure;
+using Content.Shared.SS220.SuperMatter.Functions;
+using Content.Shared.SS220.SuperMatter.Ui;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Utility;
+
+namespace Content.Client.SS220.Cartridges;
+
+[GenerateTypedNameReferences]
+public sealed partial class SupermatterObserverUiFragment : BoxContainer
+{
+    [Dependency] private readonly ILocalizationManager _localization = default!;
+
+    public event Action<BaseButton.ButtonEventArgs, SuperMatterObserverComponent>? OnServerButtonPressed;
+    public event Action<BaseButton.ButtonEventArgs, int>? OnCrystalButtonPressed;
+    public event Action<BaseButton.ButtonEventArgs>? OnRefreshButton;
+
+    public SuperMatterObserverComponent? Observer;
+    public int? CrystalKey;
+
+    public const int MAX_DATA_LENGTH = 120;
+
+    public SupermatterObserverUiFragment()
+    {
+        IoCManager.InjectDependencies(this);
+        RobustXamlLoader.Load(this);
+
+        RefreshButton.IconTexture = new SpriteSpecifier.Texture(new("/Textures/Interface/VerbIcons/refresh.svg.192dpi.png"));
+        RefreshButton.IconScale = new Vector2(0.3f); //convert 192px to 32px... but weird
+        RefreshButton.OnPressed += args =>
+            OnRefreshButton?.Invoke(args);
+
+        PlotValueOverTime.SetLabels(_localization.GetString("smObserver-plotXLabel-integrity"), _localization.GetString("smObserver-plotYLabel-integrity"), _localization.GetString("smObserver-plotTitle-integrity"));
+
+        ColorState.EvalFunctionOnMeshgrid(GetIntegrityDamageMap);
+        ColorState.SetLabels(_localization.GetString("smObserver-plotXLabel-colorState"), _localization.GetString("smObserver-plotYLabel-colorState"), _localization.GetString("smObserver-plotTitle-colorState"));
+    }
+
+    private float GetIntegrityDamageMap(float matter, float internalEnergy)
+    {
+        return SuperMatterFunctions.EnergyToMatterDamageFactorFunction(internalEnergy
+                - SuperMatterFunctions.SafeInternalEnergyToMatterFunction(matter / SuperMatterFunctions.MatterNondimensionalization),
+            matter / SuperMatterFunctions.MatterNondimensionalization);
+    }
+    public void LoadCrystal()
+    {
+        CrystalNavigationBar.RemoveAllChildren();
+        if (Observer == null)
+            return;
+        foreach (var (crystalKey, name) in Observer.Names)
+        {
+            var crystalButton = new CrystalButton
+            {
+                Text = name,
+                StyleBoxOverride = new StyleBoxFlat(Color.DarkGray),
+                CrystalKey = crystalKey,
+                ToggleMode = true,
+                Margin = new Thickness(2, 0, 2, 0),
+                StyleClasses = { "OpenBoth" }
+            };
+
+            crystalButton.OnPressed += args =>
+            {
+                OnCrystalButtonPressed?.Invoke(args, crystalButton.CrystalKey);
+            };
+            CrystalNavigationBar.AddChild(crystalButton);
+        }
+    }
+    public void LoadCachedData()
+    {
+        if (Observer == null
+            || CrystalKey == null)
+            return;
+        PlotValueOverTime.LoadPlot2DTimePoints(new PlotPoints2D(MAX_DATA_LENGTH, Observer.Integrities[CrystalKey.Value],
+                                                        -1f, Observer.Integrities[CrystalKey.Value].Count));
+        ColorState.LoadMovingPoint(new Vector2(Observer.Matters[CrystalKey.Value].Last().Value, Observer.InternalEnergy[CrystalKey.Value].Last().Value),
+                                     new Vector2(Observer.Matters[CrystalKey.Value].Last().Derv, Observer.InternalEnergy[CrystalKey.Value].Last().Derv));
+    }
+    public void UpdateState(SuperMatterObserverUpdateState msg)
+    {
+        if (Disposed)
+            return;
+
+        if (Observer == null
+            || CrystalKey == null)
+            return;
+        if (msg.Id != CrystalKey)
+            return;
+
+        PlotValueOverTime.AddPointToPlot(new Vector2(PlotValueOverTime.GetLastAddedPointX() + 1f, msg.Integrity));
+        ColorState.LoadMovingPoint(new Vector2(msg.Matter.Value, msg.InternalEnergy.Value), new Vector2(msg.Matter.Derivative, msg.InternalEnergy.Derivative));
+    }
+    public void LoadState(List<Entity<SuperMatterObserverComponent>> observerEntities)
+    {
+        if (Disposed)
+            return;
+
+        ServerNavigationBar.RemoveAllChildren();
+        foreach (var (observerUid, observerComp) in observerEntities)
+        {
+            var serverButton = new ServerButton
+            {
+                Text = observerUid.ToString(),
+                StyleBoxOverride = new StyleBoxFlat(Color.DarkGray),
+                ObserverComponent = observerComp,
+                Margin = new Thickness(2, 0, 2, 0),
+                ToggleMode = true,
+                StyleClasses = { "OpenBoth" }
+            };
+
+            serverButton.OnPressed += args =>
+            {
+                OnServerButtonPressed?.Invoke(args, serverButton.ObserverComponent);
+            };
+            ServerNavigationBar.AddChild(serverButton);
+        }
+    }
+    private sealed class ServerButton : Button
+    {
+        public SuperMatterObserverComponent? ObserverComponent;
+    }
+    private sealed class CrystalButton : Button
+    {
+        public int CrystalKey;
+    }
+}

Content.Client/SS220/Hallucination/HallucinationComponent.cs

@@ -0,0 +1,16 @@
+// © SS220, An EULA/CLA with a hosting restriction, full text: https://raw.githubusercontent.com/SerbiaStrong-220/space-station-14/master/CLA.txt
+using Content.Shared.SS220.Hallucination;
+
+namespace Content.Client.SS220.Hallucination;
+/// <summary>
+/// lmaoooooo??
+/// </summary>
+[RegisterComponent]
+public sealed partial class HallucinationComponent : SharedHallucinationComponent
+{
+    // yeah yeah make it to client only
+    /// <summary>
+    /// used only if it is localEntity of the client
+    /// </summary>
+    public List<TimeSpan> HallucinationSpawnerTimers = [];
+}

Content.Client/SS220/Hallucination/HallucinationSystem.cs

@@ -0,0 +1,99 @@
+// © SS220, An EULA/CLA with a hosting restriction, full text: https://raw.githubusercontent.com/SerbiaStrong-220/space-station-14/master/CLA.txt
+using System.Linq;
+using Content.Shared.Random.Helpers;
+using Content.Shared.SS220.Hallucination;
+using Robust.Client.GameObjects;
+using Robust.Client.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Spawners;
+using System.Numerics;
+using Robust.Shared.Timing;
+using Robust.Shared.GameStates;
+using Robust.Shared.Utility;
+namespace Content.Client.SS220.Hallucination;
+
+public sealed class HallucinationSystem : EntitySystem
+{
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly TransformSystem _transformSystem = default!;
+    [Dependency] private readonly IGameTiming _gameTiming = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HallucinationComponent, ComponentHandleState>(HandleState);
+    }
+    public override void FrameUpdate(float frameTime)
+    {
+        base.FrameUpdate(frameTime);
+
+        if (!TryComp<HallucinationComponent>(_playerManager.LocalEntity, out var hallucinationComponent))
+            return;
+
+        for (int i = 0; i < hallucinationComponent.HallucinationSpawnerTimers.Count; i++)
+        {
+            var nextHallucinationSpawnTime = hallucinationComponent.HallucinationSpawnerTimers[i];
+            if (_gameTiming.CurTime > nextHallucinationSpawnTime)
+            {
+                var hallucination = hallucinationComponent.Hallucinations[i];
+                MakeHallucination(hallucination);
+
+                var timeBetweenHallucination = TimeSpan.FromSeconds(hallucination.TimeParams.BetweenHallucinations);
+                hallucinationComponent.HallucinationSpawnerTimers[i] = _gameTiming.CurTime + timeBetweenHallucination;
+            }
+        }
+    }
+    /// <summary>
+    /// Specific handler for hallucination due to bound between timer and hallucinationSettings. Probably saving the same order as in server
+    /// </summary>
+    private void HandleState(Entity<HallucinationComponent> entity, ref ComponentHandleState args)
+    {
+        if (args.Current is not HallucinationComponentState state)
+            return;
+
+        var hallucinationSymmetricDifference = new List<HallucinationSetting>(entity.Comp.Hallucinations.Union(state.Hallucinations).
+                                            Except(entity.Comp.Hallucinations.Intersect(state.Hallucinations)));
+        var index = -1;
+
+        foreach (var hallucination in hallucinationSymmetricDifference)
+        {
+            // handle deleting hallucination in client
+            index = entity.Comp.Hallucinations.IndexOf(hallucination);
+            if (index != -1)
+            {
+                entity.Comp.Hallucinations.RemoveAt(index);
+                entity.Comp.HallucinationSpawnerTimers.RemoveAt(index);
+            }
+            //handle adding hallucination to client
+            index = state.Hallucinations.IndexOf(hallucination);
+            if (index != -1)
+            {
+                entity.Comp.Hallucinations.Add(hallucination);
+                entity.Comp.HallucinationSpawnerTimers.Add(_gameTiming.CurTime);
+            }
+        }
+        // some self-checks in case of my mistake
+        DebugTools.Assert(entity.Comp.Hallucinations.Count == state.Hallucinations.Count);
+        DebugTools.Assert(entity.Comp.Hallucinations.Count == entity.Comp.HallucinationSpawnerTimers.Count);
+    }
+    private void MakeHallucination(HallucinationSetting hallucination)
+    {
+        var randomWeightedPrototypes = _prototypeManager.Index(hallucination.RandomEntities);
+        if (!_prototypeManager.TryIndex<EntityPrototype>(randomWeightedPrototypes.Pick(_random), out var randomProto))
+            return;
+
+        var spawnedEntityUid = EntityManager.SpawnAtPosition(randomProto.ID,
+                                                            Transform(_playerManager.LocalEntity!.Value).Coordinates);
+        var randomCoordinates = _transformSystem.GetWorldPosition(_playerManager.LocalEntity!.Value)
+                                + new Vector2(_random.NextFloat(-6f, 6f), _random.NextFloat(-6f, 6f));
+        _transformSystem.SetWorldPosition(spawnedEntityUid, randomCoordinates);
+
+        var lifeTime = _random.NextFloat(hallucination.TimeParams.HallucinationMinTime, hallucination.TimeParams.HallucinationMaxTime);
+        var timedDespawnComp = EnsureComp<TimedDespawnComponent>(spawnedEntityUid);
+        timedDespawnComp.Lifetime = lifeTime;
+    }
+}

Content.Client/SS220/SuperMatter/Emitter/SuperMatterEmitterBoltSystem.cs

@@ -0,0 +1,32 @@
+// © SS220, An EULA/CLA with a hosting restriction, full text: https://raw.githubusercontent.com/SerbiaStrong-220/space-station-14/master/CLA.txt
+using System.Numerics;
+using Robust.Client.GameObjects;
+using Content.Shared.SS220.SuperMatter.Emitter;
+using Content.Client.SS220.UserInterface.PlotFigure;
+using Content.Shared.Projectiles;
+
+namespace Content.Client.SS220.SuperMatter.Emitter;
+
+public sealed class SuperMatterEmitterSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<SuperMatterEmitterBoltComponent, ComponentInit>(OnComponentInit);
+    }
+
+    private void OnComponentInit(Entity<SuperMatterEmitterBoltComponent> entity, ref ComponentInit args)
+    {
+        if (!TryComp<SpriteComponent>(entity.Owner, out var spriteComponent))
+            return;
+        if (!TryComp<ProjectileComponent>(entity.Owner, out var projectileComponent))
+            return;
+        var shootAuthorUid = projectileComponent.Shooter;
+        if (!TryComp<SuperMatterEmitterExtensionComponent>(shootAuthorUid, out var superMatterEmitter))
+            return;
+
+        spriteComponent.Color = Colormaps.SMEmitter.GetCorrespondingColor(superMatterEmitter.EnergyToMatterRatio / 100f);
+        spriteComponent.Scale = new Vector2(MathF.Sqrt(superMatterEmitter.PowerConsumption / (float)SuperMatterEmitterExtensionConsts.BaseEnergyConsumption));
+    }
+}