Species Component (#130)

* Fix this
fug
oksure
Creates the initial species component, damage states, and threshold templates and hooks them into the damageable component

* More rebase fixes

* test

* Pre future rebase

* Please

* Lol

* Lol2

* SHADERS

* Update Engine

* yml file

* Fix an initialization issue, injects dependencies

* Fix error in loading shaders

* Makes a master character ui controller component added upon client attachment to entity and remove upon client detachment from entity

* Fixes just about everytrhing

* Address PJB's comments

* geeze

* Make overlays work in worldspace instead of screen space and not cover user interfaces

* update submodule

Content.Server/GameObjects/Components/Mobs/DamageStates.cs

@@ -0,0 +1,104 @@
+using Content.Server.GameObjects.EntitySystems;
+using SS14.Server.GameObjects;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Maths;
+
+namespace Content.Server.GameObjects
+{
+    /// <summary>
+    /// Defines the blocking effect of each damage state, and what effects to apply upon entering or exiting the state
+    /// </summary>
+    public interface DamageState : IActionBlocker
+    {
+        void EnterState(IEntity entity);
+
+        void ExitState(IEntity entity);
+    }
+
+    /// <summary>
+    /// Standard state that a species is at with no damage or negative effect
+    /// </summary>
+    public struct NormalState : DamageState
+    {
+        public void EnterState(IEntity entity){}
+
+        public void ExitState(IEntity entity){}
+
+        bool IActionBlocker.CanInteract()
+        {
+            return true;
+        }
+
+        bool IActionBlocker.CanMove()
+        {
+            return true;
+        }
+
+        bool IActionBlocker.CanUse()
+        {
+            return true;
+        }
+    }
+
+    /// <summary>
+    /// A state in which you are disabled from acting due to damage
+    /// </summary>
+    public struct CriticalState : DamageState
+    {
+        public void EnterState(IEntity entity) { }
+
+        public void ExitState(IEntity entity) { }
+
+        bool IActionBlocker.CanInteract()
+        {
+            return false;
+        }
+
+        bool IActionBlocker.CanMove()
+        {
+            return false;
+        }
+
+        bool IActionBlocker.CanUse()
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// A damage state which will allow ghosting out of mobs
+    /// </summary>
+    public struct DeadState : DamageState
+    {
+        public void EnterState(IEntity entity)
+        {
+            if(entity.TryGetComponent(out SpriteComponent sprite))
+            {
+                sprite.Rotation = sprite.Rotation + Angle.FromDegrees(90);
+            }
+        }
+
+        public void ExitState(IEntity entity)
+        {
+            if (entity.TryGetComponent(out SpriteComponent sprite))
+            {
+                sprite.Rotation = sprite.Rotation - Angle.FromDegrees(90);
+            }
+        }
+
+        bool IActionBlocker.CanInteract()
+        {
+            return false;
+        }
+
+        bool IActionBlocker.CanMove()
+        {
+            return false;
+        }
+
+        bool IActionBlocker.CanUse()
+        {
+            return false;
+        }
+    }
+}

Content.Server/GameObjects/Components/Mobs/DamageThresholdTemplates/DamageThresholdTemplates.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using Content.Shared.GameObjects;
+
+namespace Content.Server.GameObjects
+{
+    /// <summary>
+    /// Defines the threshold values for each damage state for any kind of species
+    /// </summary>
+    public abstract class DamageTemplates
+    {
+        public abstract List<DamageThreshold> HealthHudThresholds { get; }
+
+        /// <summary>
+        /// Changes the hud state when a threshold is reached
+        /// </summary>
+        /// <param name="state"></param>
+        /// <param name="damage"></param>
+        /// <returns></returns>
+        public abstract HudStateChange ChangeHudState(DamageableComponent damage);
+
+        //public abstract ResistanceSet resistanceset { get; }
+
+        /// <summary>
+        /// Shows allowed states, ordered by priority, closest to last value to have threshold reached is preferred
+        /// </summary>
+        public abstract List<(DamageType, int, ThresholdType)> AllowedStates { get; }
+
+        /// <summary>
+        /// Map of ALL POSSIBLE damage states to the threshold enum value that will trigger them, normal state wont be triggered by this value but is a default that is fell back onto
+        /// </summary>
+        public static Dictionary<ThresholdType, DamageState> StateThresholdMap = new Dictionary<ThresholdType, DamageState>()
+        {
+            { ThresholdType.None, new NormalState() },
+            { ThresholdType.Critical, new CriticalState() },
+            { ThresholdType.Death, new DeadState() }
+        };
+
+        public List<DamageThreshold> DamageThresholds
+        {
+            get
+            {
+                List<DamageThreshold> thresholds = new List<DamageThreshold>();
+                foreach (var element in AllowedStates)
+                {
+                    thresholds.Add(new DamageThreshold(element.Item1, element.Item2, element.Item3));
+                }
+                return thresholds;
+            }
+        }
+
+        public ThresholdType CalculateDamageState(DamageableComponent damage)
+        {
+            ThresholdType healthstate = ThresholdType.None;
+            foreach(var element in AllowedStates)
+            {
+                if(damage.CurrentDamage[element.Item1] >= element.Item2)
+                {
+                    healthstate = element.Item3;
+                }
+            }
+
+            return healthstate;
+        }
+    }
+}

Content.Server/GameObjects/Components/Mobs/DamageThresholdTemplates/HumanTemplate.cs

@@ -0,0 +1,66 @@
+using Content.Shared.GameObjects;
+using System.Collections.Generic;
+
+namespace Content.Server.GameObjects
+{
+    public class Human : DamageTemplates
+    {
+        int critvalue = 200;
+        int normalstates = 6;
+        //string startsprite = "human0";
+
+        public override List<(DamageType, int, ThresholdType)> AllowedStates => new List<(DamageType, int, ThresholdType)>()
+        {
+            (DamageType.Total, critvalue, ThresholdType.Critical),
+            (DamageType.Total, 300, ThresholdType.Death),
+        };
+
+        public override List<DamageThreshold> HealthHudThresholds
+        {
+            get
+            {
+                List<DamageThreshold> thresholds = new List<DamageThreshold>();
+                thresholds.Add(new DamageThreshold(DamageType.Total, 1, ThresholdType.HUDUpdate));
+                for (var i = 1; i <= normalstates; i++)
+                {
+                    thresholds.Add(new DamageThreshold(DamageType.Total, i * critvalue / normalstates, ThresholdType.HUDUpdate));
+                }
+                return thresholds; //we don't need to respecify the state damage thresholds since we'll update hud on damage state changes as well
+            }
+        }
+
+        public override HudStateChange ChangeHudState(DamageableComponent damage)
+        {
+            ThresholdType healthstate = CalculateDamageState(damage);
+            switch (healthstate)
+            {
+                case ThresholdType.None:
+                    var totaldamage = damage.CurrentDamage[DamageType.Total];
+                    if (totaldamage > critvalue)
+                    {
+                        throw new System.InvalidOperationException(); //these should all be below the crit value, possibly going over multiple thresholds at once?
+                    }
+                    var modifier = totaldamage / (critvalue / normalstates); //integer division floors towards zero
+                    return new HudStateChange()
+                    {
+                        StateSprite = "Mob/UI/Human/human" + modifier.ToString() + ".png",
+                        effect = ScreenEffects.None
+                    };
+                case ThresholdType.Critical:
+                    return new HudStateChange()
+                    {
+                        StateSprite = "Mob/UI/Human/humancrit-0.png", //TODO: display as gif or alternate with -0 and -1 as frames
+                        effect = ScreenEffects.GradientCircleMask
+                    };
+                case ThresholdType.Death:
+                    return new HudStateChange()
+                    {
+                        StateSprite = "Mob/UI/Human/humandead.png",
+                        effect = ScreenEffects.CircleMask
+                    };
+                default:
+                    throw new System.InvalidOperationException();
+            }
+        }
+    }
+}

Content.Server/GameObjects/Components/Mobs/SpeciesComponent.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces;
+using Content.Shared.GameObjects;
+using SS14.Server.GameObjects;
+using SS14.Shared.ContentPack;
+using SS14.Shared.GameObjects;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.Network;
+using SS14.Shared.Serialization;
+
+namespace Content.Server.GameObjects
+{
+    public class SpeciesComponent : Component, IActionBlocker, IOnDamageBehavior
+    {
+        public override string Name => "Species";
+
+        public override uint? NetID => ContentNetIDs.SPECIES;
+
+        /// <summary>
+        /// Damagestates are reached by reaching a certain damage threshold, they will block actions after being reached
+        /// </summary>
+        public DamageState CurrentDamageState { get; private set; } = new NormalState();
+
+        /// <summary>
+        /// Damage state enum for current health, set only via change damage state //TODO: SETTER
+        /// </summary>
+        private ThresholdType currentstate = ThresholdType.None;
+
+        /// <summary>
+        /// Holds the damage template which controls the threshold and resistance settings for this species type
+        /// </summary>
+        private DamageTemplates DamageTemplate;
+
+        /// <summary>
+        /// Variable for serialization
+        /// </summary>
+        private string templatename;
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref templatename, "Template", "Human");
+
+            Type type = AppDomain.CurrentDomain.GetAssemblyByName("Content.Server").GetType("Content.Server.GameObjects." + templatename);
+            DamageTemplate = (DamageTemplates)Activator.CreateInstance(type);
+        }
+
+        public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
+        {
+            switch (message)
+            {
+                case PlayerAttachedMsg _:
+                    var hudstatechange = DamageTemplate.ChangeHudState(Owner.GetComponent<DamageableComponent>());
+                    SendNetworkMessage(hudstatechange);
+                    break;
+            }
+        }
+
+        bool IActionBlocker.CanMove()
+        {
+            return CurrentDamageState.CanMove();
+        }
+
+        bool IActionBlocker.CanInteract()
+        {
+            return CurrentDamageState.CanInteract();
+        }
+
+        bool IActionBlocker.CanUse()
+        {
+            return CurrentDamageState.CanUse();
+        }
+
+        List<DamageThreshold> IOnDamageBehavior.GetAllDamageThresholds()
+        {
+            var thresholdlist = DamageTemplate.DamageThresholds;
+            thresholdlist.AddRange(DamageTemplate.HealthHudThresholds);
+            return thresholdlist;
+        }
+
+        void IOnDamageBehavior.OnDamageThresholdPassed(object damageable, DamageThresholdPassedEventArgs e)
+        {
+            DamageableComponent damage = (DamageableComponent)damageable;
+
+            if(e.DamageThreshold.ThresholdType != ThresholdType.HUDUpdate)
+            {
+                ChangeDamageState(DamageTemplate.CalculateDamageState(damage));
+            }
+
+            if (Owner.TryGetComponent(out BasicActorComponent actor)) //specifies if we have a client to update the hud for
+            {
+                var hudstatechange = DamageTemplate.ChangeHudState(damage);
+                SendNetworkMessage(hudstatechange);
+            }
+        }
+
+        private void ChangeDamageState(ThresholdType threshold)
+        {
+            if(threshold == currentstate)
+            {
+                return;
+            }
+
+            CurrentDamageState.ExitState(Owner);
+            CurrentDamageState = DamageTemplates.StateThresholdMap[threshold];
+            CurrentDamageState.EnterState(Owner);
+
+            currentstate = threshold;
+        }
+    }
+}