Character.cs

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

[AddComponentMenu("Liberi/Character")]
public class Character: MonoBehaviour
{
    public bool IsSkillReady
    {
        get
        {
            return CanUseSkill && _energy >= 1f;
        }
    }

    public Persona ActivePersona
    {
        get
        {
            int index = _activePersonaIndex.LastValue;

            if (index < 0 || index >= Personas.Length)
                return null;

            return Personas[index];
        }
    }

    public string ActivePersonaID
    {
        get
        {
            var activePersona = this.ActivePersona;

            if (activePersona == null)
                return null;

            return activePersona.ID;
        }
    }

    public bool IsTurbo
    {
        get { return _isTurbo.LastValue; }
        set
        {
            if (!Sync.IsLocal(this))
                return;

            _isTurbo[0] = value;
        }
    }

    public float Energy
    {
        get { return _energy; }
    }

    const float _personaChangeCooldown = .5f;

    [NonSerialized]
    public bool CanUseSkill = true;
    public bool CanChargeEnergy = true;
    public CharacterTrait[] Traits;
    public Persona[] Personas;
    [SpawnDetail]
    public float BotTurboWarmup = 60f;

    Timeline<int> _activePersonaIndex;
    Timeline<bool> _isTurbo;
    Timeline<bool> _skillUses;
    float _energy;
    bool _isBot;

    void Awake ()
    {
        _activePersonaIndex = Sync.CreateDiscreteState<int>();
        _isTurbo = Sync.CreateDiscreteState<bool>();
        _skillUses = Sync.CreateEvent<bool>();

        foreach (var trait in Traits)
        {
            trait.Character = this;
        }

        foreach (var persona in Personas)
        {
            persona.Character = this;
        }
    }

    void OnSpawn (UJeli details)
    {
        _activePersonaIndex.EntryPassed += OnActivePersonaIndexMessage;
        _isTurbo.EntryPassed += OnTurboMessage;
        _skillUses.EntryPassed += OnSkillUseMessage;

        if (Sync.IsClientOwned(this))
        {
            var characterProfile = Game.GetPlayerProfile(Sync.GetOwner(this)).GetCharacter(name);   

            if (Sync.IsLocal(this))
            {
                if (characterProfile != null)
                    SetActivePersona(characterProfile.LastActivePersonaID);

                StartCoroutine(UpdateHumanPersonaAsync());
                StartCoroutine(UpdateHumanEnergyAsync());
                StartCoroutine(UpdateHumanTurboAsync());
                
                GUIStatusMeter.RegisterEnergyProvider(this);
                
                foreach (var trait in Traits)
                {
                    int traitPoints = 0;
                    characterProfile.TraitPoints.TryGetValue(trait.ID, out traitPoints);
                    trait.Points = traitPoints;
                }
            }
        }
        else
        {
            if (Sync.IsLocal(this))
            {
                UJeli personaJeli = details["Persona"];

                SetActivePersona(personaJeli.Value);

                StartCoroutine(UpdateBotEnergyAsync());
                StartCoroutine(UpdateBotTurboAsync());
            }

            UJeli traitsDetail = details["Traits"];

            if (traitsDetail != null)
            {
                foreach (var trait in Traits)
                {
                    UJeli traitDetail = traitsDetail[trait.ID];

                    if (traitDetail != null)
                        trait.Points = traitDetail.IntValue;
                }
            }
        }
    }

    public CharacterTrait GetTrait (string traitId)
    {
        return Traits.FirstOrDefault(t => t.ID == traitId);
    }

    public Persona GetPersona (string personaId)
    {
        return Personas.FirstOrDefault(p => p.ID == personaId);
    }

    public Persona GetPreviousPersona ()
    {
        return Personas[(_activePersonaIndex.LastValue + Personas.Length - 1) % Personas.Length];
    }

    public Persona GetNextPersona ()
    {
        return Personas[(_activePersonaIndex.LastValue + 1) % Personas.Length];
    }

    public void CyclePreviousPersona ()
    {
        SetActivePersona(GetPreviousPersona());
    }

    public void CycleNextPersona ()
    {
        SetActivePersona(GetNextPersona());
    }

    public void SetActivePersona (Persona persona)
    {
        SetActivePersona(Array.IndexOf(Personas, persona));
    }

    public void SetActivePersona (string personaId)
    {
        SetActivePersona(Array.FindIndex(Personas, p => p.ID == personaId));
    }

    private void SetActivePersona (int personaIndex)
    {
        if (!Sync.IsLocal(this))
            return;

        _energy = 0f;

        if (personaIndex != -1)
        {
            // TODO: Log persona change.
            _activePersonaIndex[0] = personaIndex;
        }
        else _activePersonaIndex[0] = 0;
    }

    public void UseSkill ()
    {
        if (!this.IsSkillReady)
            return;
        
        if (Sync.IsClient)
            Study.LogEvent(SkillLogEvent.UsePrimary, ActivePersona.ID);

        _skillUses[0] = true;
        _energy = 0f;
    }

    void OnActivePersonaIndexMessage (Timeline<int> timeline, TimelineEntry<int> entry)
    {
        Sync.SendEnabledMessage(this, "OnActivePersonaChanged", this.ActivePersona);
    }

    void OnTurboMessage (Timeline<bool> timeline, TimelineEntry<bool> entry)
    {
        if (entry.Value)
            Sync.SendEnabledMessage(this, "OnGotTurbo");
        else Sync.SendEnabledMessage(this, "OnLostTurbo");
    }

    void OnSkillUseMessage (Timeline<bool> timeline, TimelineEntry<bool> entry)
    {
        Sync.SendEnabledMessage(this, "OnSkillUsed", this, this.ActivePersona);
    }

    private IEnumerator UpdateHumanPersonaAsync ()
    {
        while (true)
        {
            if (CanUseSkill)
            {
                var activePersona = this.ActivePersona;

                if (activePersona != null)
                {
                    if (activePersona.AutoFireSkill)
                    {
                        if (Controls.GetAction(ControlsAction.Primary))
                            UseSkill();
                    }
                    else
                    {
                        if (Controls.GetActionDown(ControlsAction.Primary))
                            UseSkill();
                    }
                }
            }

            if (_activePersonaIndex.LastValueDuration >= _personaChangeCooldown)
            {  
                if (Controls.GetActionDown(ControlsAction.CycleNext))
                    CycleNextPersona();
                else if (Controls.GetActionDown(ControlsAction.CyclePrevious))
                    CyclePreviousPersona();
            }

            yield return null;
        }
    }

    private IEnumerator UpdateHumanEnergyAsync ()
    {
        while (true)
        {
            if (CanUseSkill)
            {
                Persona activePersona = this.ActivePersona;

                if (activePersona != null)
                {
                    if (Controls.Power >= .1f && CanChargeEnergy)
                    {
                        float prevEnergy = _energy;
                        _energy = Mathf.Min(1, _energy + Controls.Power / activePersona.SkillChargeTime * Time.deltaTime);
                        
                        if (_energy == 1 && prevEnergy != 1)
                            this.PlayPooledSound("get_action");
                    }
                    else _energy = Mathf.Max(0, _energy - 1 / activePersona.SkillChargeTime * Time.deltaTime);
                }
                else _energy = 0f;
            }
            else _energy = 0f;

            yield return null;
        }
    }

    private IEnumerator UpdateBotEnergyAsync ()
    {
        while (true)
        {
            if (CanUseSkill)
            {
                Persona activePersona = this.ActivePersona;

                if (activePersona != null)
                {
                    _energy += 1 / activePersona.SkillChargeTime * Time.deltaTime;
                }
                else _energy = 0f;
            }
            else _energy = 0f;

            yield return null;
        }
    }

    private IEnumerator UpdateHumanTurboAsync ()
    {
        while (true)
        {
            if (_isTurbo.LastValue)
            {
                if (Heart.Tier != HeartTier.Target)
                {
                    if (_isTurbo.LastValue)
                    {
                        _isTurbo[0] = false;
                    }
                }
            }
            else
            {
                if (Heart.Tier == HeartTier.Target)
                {
                    if (!_isTurbo.LastValue)
                    {
                        _isTurbo[0] = true;
                    }
                }
            }

            yield return null;
        }
    }

    private IEnumerator UpdateBotTurboAsync ()
    {
        yield return new WaitForSeconds(Mathf.Max(0f, BotTurboWarmup + UnityEngine.Random.Range(-15f, 15f)));
        _isTurbo[0] = true;
    }
}