Vitals.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Janus;
using System;
using System.Linq;
using System.Reflection;

public delegate void VitalsHitHandler (Vitals vitals, HitInfo hit);
public delegate void VitalsKilledHandler (Vitals vitals, HitInfo fatalHit);
public delegate void VitalsRevivedHandler (Vitals vitals);

[AddComponentMenu("Liberi/Vitals")]
public class Vitals : MonoBehaviour
{
    public event VitalsHitHandler Hit = delegate {};
    public event VitalsKilledHandler Killed = delegate {};
    public event VitalsRevivedHandler Revived = delegate {};

    public bool IsInvulnerable
    {
        get { return !_isVulnerable.LastValue; }
        set { _isVulnerable[0] = !value; }
    }

    public bool IsVulnerable
    {
        get { return _isVulnerable.LastValue; }
        set { _isVulnerable[0] = value; }
    }

    public float CurrentHealth
    {
        get { return Health.IsEmpty ? MaxHealth.LastValue : Health.LastValue; }
        set { Health[0] = Mathf.Clamp(value, 0, MaxHealth.LastValue); }
    }

    public float CurrentNormalizedHealth
    {
        get
        {
            if (MaxHealth.LastValue == 0)
                return 0;
            else
                return this.CurrentHealth / MaxHealth.LastValue;
        }
        set { this.CurrentHealth = value * MaxHealth.LastValue; }
    }

    public bool IsAlive
    {
        get { return this.CurrentHealth > 0f; }
    }

    public bool IsDead
    {
        get { return this.CurrentHealth <= 0f; }
    }

    public float BaseMaxHealth = 100f;
    public string VitalTag;
    public bool HealthRegenEnabled = false;
    public float HealthRegen = 0f;
    public float HealthRegenInterval = .5f;
    public float HitTimeout = 0f;
    public bool DespawnWhenKilled = false;
    public MeterSticker HealthMeter;
    public Vitals RedirectHitsTo;
    
    public Timeline<float> Health;
    public Timeline<float> MaxHealth;

    Timeline<bool> _isVulnerable;
    Timeline<GameMessage> _hits;
    Blinker _blinker;
    float _lastHitTime;

    void Awake ()
    {
        _blinker = GetComponent<Blinker>();

        _isVulnerable = Sync.CreateDiscreteState<bool>();

        Health = Sync.CreateDiscreteState<float>();
        Health.CacheSize = 1;

        MaxHealth = Sync.CreateDiscreteState<float>();
        MaxHealth.CacheSize = 1;

        _hits = Sync.CreateEvent<GameMessage>();
    }

    void OnSpawn ()
    {
        _hits.EntryPassed += OnHitMessage;
        Health.EntryPassed += OnHealthChange;

        if (Sync.IsLocal(gameObject))
        {
            _isVulnerable[0] = true;
            MaxHealth[0] = BaseMaxHealth;
            Health[0] = MaxHealth.LastValue;

            StartCoroutine(RegenHealth());
        }
    }

    void OnHealthChange (Timeline<float> timeline, TimelineEntry<float> entry)
    {
        if (entry.Prev != null && entry.Prev.Value <= 0 && entry.Value > 0)
            Revived(this);
        
        if (entry.Value <= 0 && DespawnWhenKilled)
            Sync.Despawn(this);
    }
    
    public static bool ApplyHit (Component targetObject, Vector3 location, float value = 0f,
        GameObject sourceObject = null, string hitTag = "", UJeli details = null)
    {
        return ApplyHit(targetObject.gameObject, location, value, sourceObject, hitTag, details);
    }

    public static bool ApplyHit (Component targetObject, Vector3 location, float value = 0f,
        Component sourceObject = null, string hitTag = "", UJeli details = null)
    {
        return ApplyHit(targetObject.gameObject, location, value, sourceObject.gameObject, hitTag, details);
    }

    public static bool ApplyHit (GameObject targetObject, Vector3 location, float value = 0f,
        Component sourceObject = null, string hitTag = "", UJeli details = null)
    {
        return ApplyHit(targetObject, location, value, sourceObject.gameObject, hitTag, details);
    }

    public static bool ApplyHit (GameObject targetObject, Vector3 location, float value = 0f,
        GameObject sourceObject = null, string hitTag = "", UJeli details = null)
    {
        var vitals = targetObject.GetComponent<Vitals>();

        if (vitals != null)
        {
            while (vitals.RedirectHitsTo != null)
            {
                vitals = vitals.RedirectHitsTo;
            }

            if (!vitals._isVulnerable.LastValue)
                return false;

            vitals.PropagateHit(false, location, value, false, sourceObject, hitTag, details);

            return true;
        }
        
        return false;
    }

    void PropagateHit (bool isFinal, Vector3 location, float value, bool isFatal, GameObject sourceObject, string hitTag, UJeli details)
    {
        int sourceObjectIndex = sourceObject != null ? Sync.GetObjectIndex(sourceObject) : -1;

        string detailsString = details != null ? details.ToString() : "";

        var hitMsg = new GameMessage();
        hitMsg.Write(isFinal);
        hitMsg.Write(location);
        hitMsg.Write(value);
        hitMsg.Write(isFatal);
        hitMsg.Write(sourceObjectIndex);
        hitMsg.Write(hitTag);
        hitMsg.Write(detailsString);

        _hits[0] = hitMsg;
    }

    void Update ()
    {
        if (HealthMeter != null)
            HealthMeter.Value = CurrentNormalizedHealth;
    }

    IEnumerator RegenHealth ()
    {
        while (true)
        {
            if (HealthRegenEnabled && Health.LastValue < MaxHealth.LastValue)
                this.CurrentHealth += HealthRegen * HealthRegenInterval;

            yield return new WaitForSeconds(HealthRegenInterval);
        }
    }

    void OnHitMessage (Timeline<GameMessage> timeline, TimelineEntry<GameMessage> entry)
    {
        var hitMsg = entry.Value;

        bool isFinal = hitMsg.ReadBoolean();
        Vector3 location = hitMsg.ReadVector3();
        float value = hitMsg.ReadFloat();
        bool isFatal = hitMsg.ReadBoolean();
        int sourceObjectIndex = hitMsg.ReadInt32();
        GameObject sourceObject = sourceObjectIndex != -1 ? Sync.GetObject(sourceObjectIndex) : null;
        string hitTag = hitMsg.ReadString();
        string detailsString = hitMsg.ReadString();
        UJeli details = UJeli.Parse(detailsString);
        hitMsg.FinishReading();

        if (sourceObjectIndex != -1 && sourceObject == null)
            return;

        var hit = new HitInfo()
        {
            TargetVitals = this,
            Location = location,
            IsFatal = isFatal,
            Value = value,
            SourceObject = sourceObject,
            HitTag = hitTag,
            Details = details
        };
        
        if (isFinal)
        {
            if (_blinker != null)
                _blinker.Blink(HitTimeout);

            Sync.SendEnabledMessage(this, "OnHit", hit);

            Hit(this, hit);

            if (hit.SourceObject != null)
                Sync.SendEnabledMessage(hit.SourceObject, "OnOutgoingHit", gameObject, hit);

            if (hit.IsFatal)
            {
                Killed(this, hit);

                if (Sync.IsServer)
                    return;

                GameObject shooter = null;

                if (hit.Details.HasChild("Shooter"))
                    shooter = hit.Details["Shooter"].GameObjectValue;

                var trueSourceObject = shooter ?? hit.SourceObject;

                if (Sync.IsLocal(this))
                {
                    // This is a local Vitals dying (ie, a player's avatar)
                    // If it's an Avatar killing this, log the Nickname of the avatar owner, else log the object's name
                    if (trueSourceObject.CompareTag("Avatar"))
                    {
                        string playerName = Game.GetPlayerNickname(Sync.GetOwner(trueSourceObject));
                        Study.LogEvent(VitalsLogEvent.KilledBy, playerName);
                    }
                    else
                        Study.LogEvent(VitalsLogEvent.KilledBy, trueSourceObject.name);
                }
                else if (Sync.IsLocal(trueSourceObject))
                {
                    // The sourceObject or shooter is local (ie, the player killed something)
                    // If it's an Avatar being killed, log the Nickname of the victim, else log the object's name
                    if (gameObject.CompareTag("Avatar"))
                    {
                        string playerName = Game.GetPlayerNickname(Sync.GetOwner(this));
                        Study.LogEvent(VitalsLogEvent.Killed, playerName);
                    }
                    else
                        Study.LogEvent(VitalsLogEvent.Killed, name);
                }
                

            }
        }
        else
        {       
            if (Sync.IsLocal(gameObject) && _isVulnerable.LastValue)
            {
                if (Time.time - _lastHitTime > HitTimeout)
                {
                    Sync.SendEnabledMessage(this, "PreHit", hit);
                    
                    if (!hit.Cancel)
                    {
                        if (hit.Value != 0)
                        {
                            bool wasAlive = this.IsAlive;

                            Health[0] = Mathf.Clamp(Health.LastValue - hit.Value, 0, MaxHealth.LastValue);

                            if (wasAlive && !this.IsAlive)
                                hit.IsFatal = true;
                        }

                        _lastHitTime = Time.time;

                        PropagateHit(true, location, value, hit.IsFatal, sourceObject, hitTag, details);
                    }
                }
            }
        }
    }
}