Hitter.cs

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

[AddComponentMenu("Liberi/Hitter")]
[Script(ScriptRole.Logic)]
[RequireComponent(typeof(Collider))]
public class Hitter : MonoBehaviour
{
    public GameObject Shooter
    {
        get { return _shooter; }
    }

    public bool IsContinuous;
    public float HitInterval = .5f;
    public float HitValue;
    public List<string> TargetVitalTags;
    public string HitTag;
    public TriggerHitLocationMode TriggerHitLocationMode;
    public float ShooterProtectionDuration;
    public UJeli HitDetails;
        
    Dictionary<Collider, Vector3> _continuousContacts;
    float _shooterProtectionTimeLeft;
    GameObject _shooter;

    void Awake ()
    {
        _continuousContacts = new Dictionary<Collider, Vector3>();

        HitDetails = new UJeli();
    }

    void OnSpawn (UJeli details)
    {
        if (details.HasChild("HitValue"))
        {
            HitValue = details["HitValue"].FloatValue;
        }
    
        if (details.HasChild("Shooter"))
        {
            _shooter = details["Shooter"].GameObjectValue;

            HitDetails = details;

            _shooterProtectionTimeLeft = ShooterProtectionDuration;
        }
    }

    private void ApplyHit (Collider other, Vector3 location)
    {
        Vitals.ApplyHit(other, location, HitValue, this, HitTag, HitDetails);
    }

    IEnumerator ApplyContinuousHit (Collider other)
    {
        while (other != null && _continuousContacts.ContainsKey(other))
        {
            if (!collider.enabled)
            {
                _continuousContacts.Remove(other);
                break;
            }
        
            if (other.enabled == false)
            {
                _continuousContacts.Remove(other);
                yield break;
            }
        
            ApplyHit(other, _continuousContacts[other]);

            yield return new WaitForSeconds(HitInterval);
        }

        yield break;
    }

    void Update ()
    {
        if (_shooterProtectionTimeLeft != float.PositiveInfinity && _shooterProtectionTimeLeft > 0f)
            _shooterProtectionTimeLeft = Mathf.Max(0f, _shooterProtectionTimeLeft - Time.deltaTime);
    }

    void OnCollisionEnter (Collision collision)
    {
        if (!enabled)
            return;

        if (_shooter != null && collision.collider == _shooter.collider && _shooterProtectionTimeLeft > 0f)
            return;

        var targetVitals = collision.collider.GetComponent<Vitals>();

        if (targetVitals == null)
            return;

        if (TargetVitalTags.Count != 0 && !TargetVitalTags.Contains(targetVitals.VitalTag))
            return;

        if (IsContinuous)
        {
            _continuousContacts.Add(collision.collider, collision.contacts[0].point);
            StartCoroutine(ApplyContinuousHit(collision.collider));
        }
        else ApplyHit(collision.collider, collision.contacts[0].point);
    }

    void OnCollisionStay (Collision collision)
    {
        if (!enabled)
            return;

        if (_shooter != null && collision.collider == _shooter.collider && _shooterProtectionTimeLeft > 0f)
            return;

        if (IsContinuous)
        {
            if (_continuousContacts.ContainsKey(collision.collider))
                _continuousContacts[collision.collider] = collision.contacts[0].point;
        }
    }

    void OnCollisionExit (Collision collision)
    {
        if (!enabled)
            return;

        if (IsContinuous)
            _continuousContacts.Remove(collision.collider);
    }

    void OnTriggerEnter (Collider other)
    {   
        if (!enabled)
            return;

        if (_shooter != null && other == _shooter.collider && _shooterProtectionTimeLeft > 0f)
            return;

        var targetVitals = other.GetComponent<Vitals>();

        if (targetVitals == null)
            return;

        if (TargetVitalTags.Count != 0 && !TargetVitalTags.Contains(targetVitals.VitalTag))
            return;

        if (IsContinuous)
        {
            _continuousContacts.Add(other, PhysicsUtils.GetTriggerHitLocation(collider, other, TriggerHitLocationMode));
            StartCoroutine(ApplyContinuousHit(other));
        }
        else ApplyHit(other, PhysicsUtils.GetTriggerHitLocation(collider, other, TriggerHitLocationMode));
    }

    void OnTriggerStay (Collider other)
    {
        if (!enabled)
            return;

        if (_shooter != null && other == _shooter.collider && _shooterProtectionTimeLeft > 0f)
            return;

        if (IsContinuous)
        {
            if (_continuousContacts.ContainsKey(other))
                _continuousContacts[other] = PhysicsUtils.GetTriggerHitLocation(collider, other, TriggerHitLocationMode);
        }
    }

    void OnTriggerExit (Collider other)
    {
        if (!enabled)
            return;

        if (IsContinuous)
            _continuousContacts.Remove(other);
    }
}