Alerts System and UI (#2529)

* #272 add bordered panel for effects bar

* #272 avoid mouse overlapping tooltip when near edges,
change tooltip colors to match mockups

* #272 WIP defining status effect states as YML and
sending them as encoded integers

* #272 refactor to use new alert system

* #272 refactor to use new alert system

* #272 fix various bugs with new alert system and update
alerts to have color

* #272 WIP

* #272 rename status effects to alerts

* #272 WIP reworking alert internals to avoid code dup
and eliminate enum

* #272 refactor alerts to use
categories and fix various bugs

* #272 more alert bugfixes

* #272 alert ordering

* #272 callback-based approach for alert clicks

* #272 add debug commands for alerts

* #272 utilize new GridContainer capabilities for sizing of alerts tab

* #272 scale alerts height based on
window size

* #272 fix tooltip flicker

* #272 transparent alert panel

* #272 adjust styles to match injazz mockups more, add cooldown info in tooltip

* #272 adjust styles to match injazz mockups more, add cooldown info in tooltip

* #272 alert prototype tests

* #272 alert manager tests

* #272 alert order tests

* #272 simple unit test for alerts component

* #272 integration test for alerts

* #272 rework alerts to use enums instead
of id / category

* #272 various cleanups for PR

* #272 use byte for more compact alert messages

* #272 rename StatusEffects folder to Alerts,
add missing NetSerializable

Content.Tests/Shared/Alert/AlertManagerTests.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using Content.Shared.Alert;
+using NUnit.Framework;
+using Robust.Shared.Interfaces.Log;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+using Robust.UnitTesting;
+using YamlDotNet.RepresentationModel;
+
+namespace Content.Tests.Shared.Alert
+{
+    [TestFixture, TestOf(typeof(AlertManager))]
+    public class AlertManagerTests : RobustUnitTest
+    {
+        const string PROTOTYPES = @"
+- type: alert
+  alertType: LowPressure
+  icon: /Textures/Interface/Alerts/Pressure/lowpressure.png
+
+- type: alert
+  alertType: HighPressure
+  icon: /Textures/Interface/Alerts/Pressure/highpressure.png
+";
+
+        [Test]
+        public void TestAlertManager()
+        {
+            var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
+            prototypeManager.RegisterType(typeof(AlertPrototype));
+            prototypeManager.LoadFromStream(new StringReader(PROTOTYPES));
+            IoCManager.RegisterInstance<AlertManager>(new AlertManager());
+            var alertManager = IoCManager.Resolve<AlertManager>();
+            alertManager.Initialize();
+
+            Assert.That(alertManager.TryGet(AlertType.LowPressure, out var lowPressure));
+            Assert.That(lowPressure.IconPath, Is.EqualTo("/Textures/Interface/Alerts/Pressure/lowpressure.png"));
+            Assert.That(alertManager.TryGet(AlertType.HighPressure, out var highPressure));
+            Assert.That(highPressure.IconPath, Is.EqualTo("/Textures/Interface/Alerts/Pressure/highpressure.png"));
+
+            Assert.That(alertManager.TryGetWithEncoded(AlertType.LowPressure, out lowPressure, out var encodedLowPressure));
+            Assert.That(lowPressure.IconPath, Is.EqualTo("/Textures/Interface/Alerts/Pressure/lowpressure.png"));
+            Assert.That(alertManager.TryGetWithEncoded(AlertType.HighPressure, out highPressure, out var encodedHighPressure));
+            Assert.That(highPressure.IconPath, Is.EqualTo("/Textures/Interface/Alerts/Pressure/highpressure.png"));
+
+            Assert.That(alertManager.TryEncode(lowPressure, out var encodedLowPressure2));
+            Assert.That(encodedLowPressure2, Is.EqualTo(encodedLowPressure));
+            Assert.That(alertManager.TryEncode(highPressure, out var encodedHighPressure2));
+            Assert.That(encodedHighPressure2, Is.EqualTo(encodedHighPressure));
+            Assert.That(encodedLowPressure, Is.Not.EqualTo(encodedHighPressure));
+
+            Assert.That(alertManager.TryDecode(encodedLowPressure, out var decodedLowPressure));
+            Assert.That(decodedLowPressure, Is.EqualTo(lowPressure));
+            Assert.That(alertManager.TryDecode(encodedHighPressure, out var decodedHighPressure));
+            Assert.That(decodedHighPressure, Is.EqualTo(highPressure));
+
+            Assert.False(alertManager.TryEncode(AlertType.Debug1, out _));
+            Assert.False(alertManager.TryGetWithEncoded(AlertType.Debug1, out _, out _));
+
+        }
+    }
+}

Content.Tests/Shared/Alert/AlertOrderPrototypeTests.cs

@@ -0,0 +1,96 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Content.Shared.Alert;
+using NUnit.Framework;
+using Robust.Shared.IoC;
+using Robust.Shared.Prototypes;
+using Robust.UnitTesting;
+
+namespace Content.Tests.Shared.Alert
+{
+    [TestFixture, TestOf(typeof(AlertOrderPrototype))]
+    public class AlertOrderPrototypeTests : RobustUnitTest
+    {
+        const string PROTOTYPES = @"
+- type: alertOrder
+  order:
+    - alertType: Handcuffed
+    - category: Pressure
+    - category: Hunger
+    - alertType: Hot
+    - alertType: Stun
+    - alertType: LowPressure
+    - category: Temperature
+
+- type: alert
+  category: Pressure
+  alertType: LowPressure
+
+- type: alert
+  category: Hunger
+  alertType: Overfed
+
+- type: alert
+  category: Pressure
+  alertType: HighPressure
+
+- type: alert
+  category: Hunger
+  alertType: Peckish
+
+- type: alert
+  alertType: Stun
+
+- type: alert
+  alertType: Handcuffed
+
+- type: alert
+  category: Temperature
+  alertType: Hot
+
+- type: alert
+  category: Temperature
+  alertType: Cold
+
+- type: alert
+  alertType: Weightless
+
+- type: alert
+  alertType: PilotingShuttle
+";
+
+        [Test]
+        public void TestAlertOrderPrototype()
+        {
+            var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
+            prototypeManager.RegisterType(typeof(AlertPrototype));
+            prototypeManager.RegisterType(typeof(AlertOrderPrototype));
+            prototypeManager.LoadFromStream(new StringReader(PROTOTYPES));
+
+            var alertOrder = prototypeManager.EnumeratePrototypes<AlertOrderPrototype>().FirstOrDefault();
+
+            var alerts = prototypeManager.EnumeratePrototypes<AlertPrototype>();
+
+            // ensure they sort according to our expected criteria
+            var expectedOrder = new List<AlertType>();
+            expectedOrder.Add(AlertType.Handcuffed);
+            expectedOrder.Add(AlertType.HighPressure);
+            // stuff with only category + same category ordered by enum value
+            expectedOrder.Add(AlertType.Overfed);
+            expectedOrder.Add(AlertType.Peckish);
+            expectedOrder.Add(AlertType.Hot);
+            expectedOrder.Add(AlertType.Stun);
+            expectedOrder.Add(AlertType.LowPressure);
+            expectedOrder.Add(AlertType.Cold);
+            // stuff at end of list ordered by enum value
+            expectedOrder.Add(AlertType.Weightless);
+            expectedOrder.Add(AlertType.PilotingShuttle);
+
+            var actual = alerts.ToList();
+            actual.Sort(alertOrder);
+
+            Assert.That(actual.Select(a => a.AlertType).ToList(), Is.EqualTo(expectedOrder));
+        }
+    }
+}

Content.Tests/Shared/Alert/AlertPrototypeTests.cs

@@ -0,0 +1,62 @@
+using System.IO;
+using Content.Shared.Alert;
+using NUnit.Framework;
+using Robust.Shared.Interfaces.Log;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Utility;
+using Robust.UnitTesting;
+using YamlDotNet.RepresentationModel;
+
+namespace Content.Tests.Shared.Alert
+{
+    [TestFixture, TestOf(typeof(AlertPrototype))]
+    public class AlertPrototypeTests : RobustUnitTest
+    {
+        private const string PROTOTYPE = @"- type: alert
+  alertType: HumanHealth
+  category: Health
+  icon: /Textures/Interface/Alerts/Human/human.rsi/human.png
+  name: Health
+  description: ""[color=green]Green[/color] good. [color=red]Red[/color] bad.""
+  minSeverity: 0
+  maxSeverity: 6";
+
+
+        [Test]
+        public void TestAlertKey()
+        {
+            Assert.That(new AlertKey(AlertType.HumanHealth, null), Is.Not.EqualTo(AlertKey.ForCategory(AlertCategory.Health)));
+            Assert.That((new AlertKey(null, AlertCategory.Health)), Is.EqualTo(AlertKey.ForCategory(AlertCategory.Health)));
+            Assert.That((new AlertKey(AlertType.Buckled, AlertCategory.Health)), Is.EqualTo(AlertKey.ForCategory(AlertCategory.Health)));
+        }
+
+
+        [TestCase(0, "/Textures/Interface/Alerts/Human/human.rsi/human0.png")]
+        [TestCase(null, "/Textures/Interface/Alerts/Human/human.rsi/human0.png")]
+        [TestCase(1, "/Textures/Interface/Alerts/Human/human.rsi/human1.png")]
+        [TestCase(6, "/Textures/Interface/Alerts/Human/human.rsi/human6.png")]
+        [TestCase(7, "/Textures/Interface/Alerts/Human/human.rsi/human6.png")]
+        public void GetsIconPath(short? severity, string expected)
+        {
+
+            var alert = GetTestPrototype();
+            Assert.That(alert.GetIconPath(severity), Is.EqualTo(expected));
+        }
+
+        private AlertPrototype GetTestPrototype()
+        {
+            using (TextReader stream = new StringReader(PROTOTYPE))
+            {
+                var yamlStream = new YamlStream();
+                yamlStream.Load(stream);
+                var document = yamlStream.Documents[0];
+                var rootNode = (YamlSequenceNode) document.RootNode;
+                var proto = (YamlMappingNode) rootNode[0];
+                var newReagent = new AlertPrototype();
+                newReagent.LoadFrom(proto);
+                return newReagent;
+            }
+        }
+    }
+}