/**
                        * CollisionNotifier.cs
                        * Useful if the function that triggers on collision is not on the GameObject with the Collider.
                        * NicholusHuber@gmail.com
                        */
                        using System;
                        using UnityEngine;
                        using JetBrains.Annotations;

                        public class CollisionNotifier : MonoBehaviour
                        {
                            /// <summary>
                            /// Function to be called when a collision occurs.
                            /// Function must take 2 GameObject arguments.
                            /// GO1: the touched GO. GO2: The other GO.
                            /// EX: s.GetComponent<CollisionNotifier>().OnCollisionDelegate = MyFunction;
                            /// </summary>
                            [HideInInspector] public Action<GameObject, GameObject> OnCollisionDelegate;

                            /// <summary>
                            /// Function to be called when an exit occurs.
                            /// Function must take 2 GameObject arguments.
                            /// GO1: the touched GO. GO2: The other GO.
                            /// EX: s.GetComponent<CollisionNotifier>().OnCollisionDelegate = MyFunction;
                            /// </summary>
                            [HideInInspector] public Action<GameObject, GameObject> OnExitDelegate;

                            [UsedImplicitly]  private void OnTriggerEnter(Collider other)        { Collision(other.gameObject); }
                            [UsedImplicitly]  private void OnCollisionEnter(Collision collision) { Collision(collision.gameObject); }
                            [UsedImplicitly]  private void OnTriggerExit(Collider other)         { Exit(other.gameObject); }
                            [UsedImplicitly]  private void OnCollisionExit(Collision collision)  { Exit(collision.gameObject); }

                            private void Collision(GameObject other) { if (OnCollisionDelegate != null) OnCollisionDelegate(gameObject, other); }
                            private void Exit(GameObject other)      { if (OnExitDelegate != null)      OnExitDelegate(gameObject, other); }
                        }
                    

                        /**
                        * Skill.cs
                        * Base abstract class for all Player Skills.
                        * NicholusHuber@gmail.com
                        */
                        using System.Collections;
                        using UnityEngine;

                        /// <summary>
                        /// A list of all player skills.
                        /// </summary>
                        public enum SkillID { GravityField, SpectrumShift, GammaPulse, Ignite, Fireball, Singularity,
                        IcyTrail, CleansingWaters, Dispersion }

                        /// <summary>
                        /// Contains all info for the player skill.
                        /// </summary>
                        public abstract class Skill : MonoBehaviour
                        {
                            public SkillID SkillID            { get; protected set; }
                            public string  Name               { get; protected set; }
                            public float   CooldownMax        { get; protected set; }
                            public float   CooldownCurrent    { get; protected set; }
                            public string  DescriptionActive  { get; protected set; }
                            public string  DescriptionPassive { get; protected set; }

                            protected readonly UILabel CooldownLabel;
                            protected PlayerClass Player;

                            protected Skill()
                            {
                                CooldownCurrent = 0;
                            }

                            /// <summary>
                            /// Used for the local player skill activation.
                            /// The publicly exposed skill activation method.
                            /// Checks the skill CD, if ready it will use the ability, if not, does nothing.
                            /// </summary>
                            public void TrySkill(Vector2 pos)
                            {
                                if (!CooldownReady()) return;
                                ActiveSkill(pos).StartN();
                                GPGMP.Player.ParticleManager.ActiveParticle(true);
                                GPGMP.SendSkillPak(pos);
                            }

                            /// <summary>
                            /// Called when a skill packet is received from another player.
                            /// </summary>
                            public void RemoteSkill(PlayerClass pc, SkillPak pak)
                            {
                                pc.Movement.Reposition(new Vector2(pak.PosX, pak.PosY));
                                // activate skill
                                ActiveSkill(new Vector2(pak.TargetX, pak.TargetY)).StartN(false);
                                // activate particles
                                GPGMP.Player.ParticleManager.ActiveParticle(true);
                            }

                            protected abstract IEnumerator ActiveSkill(Vector2 targetPos);

                            /// <summary>
                            /// Called when a projectile hits another player.
                            /// Send a packet to let others know. Can trigger a secondary effect (explosion)
                            /// or directly app debuffs when this packet is received, depending on the skill.
                            /// </summary>
                            public virtual void ProjectileStop()
                            {
                                if (Player == GPGMP.Player) GPGMP.SendProjectileStopPak();
                            }

                            /// <summary>
                            /// Called when another player is struck by this Skill.
                            /// </summary>
                            public virtual void HitPlayer(PlayerClass hitPC)
                            {
                                if (Player != GPGMP.Player) return;
                                if (!hitPC.CompareTag("OtherPlayers")) return;
                                Debug.Log("Explosion hit: " + hitPC.name);
                                hitPC.HitByAbility(Player);
                                GPGMP.SendHitPak(hitPC);
                            }

                            // Applies this skill's debuffs to the hitPC.
                            public virtual void ApplyDebuffs(PlayerClass hitPC){}

                            // Applies this skill's buffs to this PC.
                            public virtual void ApplyBuffs(PlayerClass hitPC){}


                            protected IEnumerator Cooldown()
                            {
                                GPGMP.Player.ParticleManager.ActiveParticle(false);
                                while (CooldownCurrent > 0)
                                {
                                    CooldownCurrent -= Time.deltaTime;
                                    GPGMP.Player.PlayerUI.Cooldown(CooldownCurrent);
                                    yield return null;
                                }
                                GPGMP.Player.PlayerUI.Cooldown(0);
                            }

                            /// <summary>
                            /// Returns false if the cool down is greater than 0, else sets the cool down to the CoolDownMax and returns true.
                            /// </summary>
                            protected bool CooldownReady()
                            {
                                if (CooldownCurrent > 0) return false;
                                CooldownCurrent += CooldownMax;
                                return true;
                            }

                            /// <summary>
                            /// Called by any derived classes that have a stun effect on hit.
                            /// </summary>
                            protected static IEnumerator Stun(PlayerClass hitPC, float duration)
                            {
                                float t = 0;
                                hitPC.Movement.AllowInput = false;
                                if (hitPC != GPGMP.Player) hitPC.PlayerUI.ShowBars(true);
                                while (t <= duration)
                                {
                                    t += Time.deltaTime;
                                    hitPC.PlayerUI.Stunned(t, duration);
                                    yield return null;
                                }
                                if (hitPC != GPGMP.Player) hitPC.PlayerUI.ShowBars(false);
                                hitPC.Movement.AllowInput = true;
                            }

                        }