PlayerProfile.cs

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

public enum PlayerProfileOperationType : byte
{
    InventoryUpdate,
    StylesUpdate
}

public class PlayerProfile
{
    public delegate void StylesUpdateHandler (string avatarType, string slotType);
    public event StylesUpdateHandler StylesUpdated = delegate { };
    
    public PlayerDailyStatistics TotalDailyStatistics
    {
        get
        {
            PlayerDailyStatistics stats = null;
            DailyStatistics.TryGetValue("*", out stats);
            return stats;
        }
    }

    public string PlayerID;
    public PlayerBasicProfile Basic;
    public PlayerLocationProfile Location;
    public PlayerHealthProfile Health;
    public UJeli Inventory;
    public UJeli Styles;
    public Dictionary<string, PlayerCharacterProfile> Characters = new Dictionary<string, PlayerCharacterProfile>();
    public Dictionary<string, PlayerDailyStatistics> DailyStatistics = new Dictionary<string, PlayerDailyStatistics>();

    public PlayerProfile (string playerId, UJeli jeli)
    {
        PlayerID = playerId;

        Basic = new PlayerBasicProfile(jeli["Basic"], playerId);
        Location = new PlayerLocationProfile(jeli["Location"]);
        Health = new PlayerHealthProfile(jeli["Health"]);
        Inventory = jeli["Inventory"];
        Styles = jeli["Styles"];

        UJeli charactersJeli = jeli["Characters"];

        if (charactersJeli != null)
        {
            foreach (var charJeli in charactersJeli.Children)
            {
                try { Characters[charJeli.Name] = new PlayerCharacterProfile(charJeli); }
                catch { }
            }
        }

        UJeli dailyStatsJeli = jeli["DailyStatistics"];

        if (dailyStatsJeli != null)
        {
            foreach (var dailyMapStatsJeli in dailyStatsJeli.Children)
            {
                try { DailyStatistics[dailyMapStatsJeli.Name] = new PlayerDailyStatistics(dailyMapStatsJeli); }
                catch { }
            }
        }
    }
    
    public override string ToString() 
    {
        UJeli jeli = new UJeli();
        
        jeli.AddChild(Basic.ToJeli());
        jeli.AddChild(Styles);
        
        return jeli.ToString();
    }

    public PlayerCharacterProfile GetCharacter (string avatarId)
    {
        PlayerCharacterProfile character = null;
        Characters.TryGetValue(avatarId, out character);
        return character;
    }

    internal void ProcessIncomingOperation (GameMessage op)
    {
        var opType = (PlayerProfileOperationType)op.ReadByte();
        
        if (opType == PlayerProfileOperationType.InventoryUpdate)
        {
            string path = op.ReadString();
            string value = op.ReadString();     
            string property = SetJeliProperty(Inventory, path, value);
            
            if (property == "libi")
                GUILibiCounter.Text = value;
        }
        
        else if (opType == PlayerProfileOperationType.StylesUpdate)
        {
            string avatarType = op.ReadString();
            string slotType = op.ReadString();
            string value = op.ReadString();
            
            if (!Styles[avatarType].HasChild(slotType))
                Styles[avatarType].AddChild(slotType);
            
            Styles[avatarType][slotType].Value = value;
            
            if (Game.IsClient)
                StylesUpdated(avatarType, slotType.ToString().ToLower());
        }
    }
    
    private string SetJeliProperty (UJeli jeli, string path, string value)
    {
        List<string> pathTokens = path.Split('/').ToList();
        
        while (pathTokens.Count != 0)
        {
            string childName = pathTokens[0];
            
            if (jeli.HasChild(childName))
                jeli = jeli.GetChild(childName);
            else
                jeli = jeli.AddChild(childName);
            
            pathTokens.RemoveAt(0);
        }
        
        jeli.Value = value;
        return jeli.Name;
    }
}

public class PlayerBasicProfile
{
    public string Nickname;
    public bool IsMonitor;

    public PlayerBasicProfile (UJeli jeli, string id)
    {
        try { Nickname = jeli["Nickname"].Value; } catch { }

        if (string.IsNullOrEmpty(Nickname))
            Nickname = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(id);
            
        try { IsMonitor = jeli["IsMonitor"].BoolValue; } catch { }
    }
    
    public UJeli ToJeli ()
    {
        UJeli jeli = new UJeli("Basic");
        
        jeli.AddChild("Nickname", Nickname);
        jeli.AddChild("IsMonitor", IsMonitor);
        
        return jeli;
    }

    public override string ToString ()
    {
        return ToJeli().ToString();
    }
}

public class PlayerLocationProfile
{
    public string LastZoneMapID;
    public string LastCheckpointID;

    public PlayerLocationProfile (UJeli jeli)
    {
        try { LastZoneMapID = jeli["LastZone"].Value; } catch { }
        try { LastCheckpointID = jeli["LastCheckpoint"].Value; } catch { }
    }
}

public class PlayerCharacterProfile
{
    public Dictionary<string, int> TraitPoints = new Dictionary<string, int>();
    public string LastActivePersonaID;

    public PlayerCharacterProfile (UJeli jeli)
    {
        UJeli traitsJeli = jeli["Traits"];

        if (traitsJeli != null)
            TraitPoints = traitsJeli.GetChildDictionaryStringNames<int>(int.Parse);
        
        UJeli lastActivePersonaJeli = jeli["LastActivePersona"];

        if (lastActivePersonaJeli != null)
            LastActivePersonaID = lastActivePersonaJeli.Value;
    }

    public int GetTraitPoints (string traitId)
    {
        int traitPoints = 0;
        TraitPoints.TryGetValue(traitId, out traitPoints);
        return traitPoints;
    }
}

public class PlayerHealthProfile
{
    public float HeartRateReserve
    {
        get { return MaxHeartRate - RestingHeartRate; }
    }

    public float TargetHeartRate
    {
        get { return Mathf.Ceil(RestingHeartRate + HeartRateReserve * TargetHeartRateRatio); }
    }

    public float VigorousHeartRate
    {
        get { return Mathf.Ceil(RestingHeartRate + HeartRateReserve * VigorousHeartRateRatio); }
    }

    public float ExtremeHeartRate
    {
        get { return Mathf.Ceil(RestingHeartRate + HeartRateReserve * ExtremeHeartRateRatio); }
    }

    public float RestingHeartRate = 70;
    public float MaxHeartRate = 190;
    public float TargetHeartRateRatio = .6f;
    public float VigorousHeartRateRatio = .8f;
    public float ExtremeHeartRateRatio = 1f;
    public float EffortBalanceCadenceCap = 60;
    public float GenericBalanceCadenceCap = 60;
    public float MaxDailyTimePlayed = float.PositiveInfinity;
    public float MaxDailyTimePedaled = float.PositiveInfinity;
    public float MaxDailyTimeAboveTarget = 3600;
    public float MaxDailyTimeAboveVigorous = 600;
    public float VigorousWarningRaiseTime = 30;
    public float VigorousWarningDropTime = 30;
    public float WarmupDuration = 180;
    public float CooldownDuration = 180;
    public bool NoRestrictions = false;

    public PlayerHealthProfile (UJeli jeli)
    {
        try { RestingHeartRate              = jeli["RestingHeartRate"].FloatValue; } catch { }
        try { MaxHeartRate                  = jeli["MaxHeartRate"].FloatValue; } catch { }
        try { TargetHeartRateRatio          = jeli["TargetHeartRateRatio"].FloatValue; } catch { }
        try { VigorousHeartRateRatio        = jeli["VigorousHeartRateRatio"].FloatValue; } catch { }
        try { ExtremeHeartRateRatio         = jeli["ExtremeHeartRateRatio"].FloatValue; } catch { }
        try { EffortBalanceCadenceCap       = jeli["EffortBalanceCadenceCap"].FloatValue; } catch { }
        try { GenericBalanceCadenceCap      = jeli["GenericBalanceCadenceCap"].FloatValue; } catch { }
        try { MaxDailyTimePlayed            = jeli["MaxDailyTimePlayed"].FloatValue; } catch { }
        try { MaxDailyTimePedaled           = jeli["MaxDailyTimePedaled"].FloatValue; } catch { }
        try { MaxDailyTimeAboveTarget       = jeli["MaxDailyTimeAboveTarget"].FloatValue; } catch { }
        try { MaxDailyTimeAboveVigorous     = jeli["MaxDailyTimeAboveVigorous"].FloatValue; } catch { }
        try { VigorousWarningRaiseTime      = jeli["VigorousWarningRaiseTime"].FloatValue; } catch { }
        try { VigorousWarningDropTime       = jeli["VigorousWarningDropTime"].FloatValue; } catch { }
        try { WarmupDuration                = jeli["WarmupDuration"].FloatValue; } catch { }
        try { CooldownDuration              = jeli["CooldownDuration"].FloatValue; } catch { }
        try { NoRestrictions                = jeli["NoRestrictions"].BoolValue; } catch { }
    }

    public HeartTier GetHeartTier (float heartRate)
    {
        if (heartRate >= ExtremeHeartRate)
            return HeartTier.Extreme;
        else if (heartRate >= VigorousHeartRate)
            return HeartTier.Vigorous;
        else if (heartRate >= TargetHeartRate)
            return HeartTier.Target;
        else return HeartTier.Normal;
    }

    public float CadenceCap
    {
        get
        {
            BalanceCondition balanceAlgorithm = GameClient.Instance.Config.Study.BalanceAlgorithm;

            if (balanceAlgorithm == BalanceCondition.GenericBalance)
                return Mathf.Max(1, GenericBalanceCadenceCap);
            else if (balanceAlgorithm == BalanceCondition.EffortBalance)
                return Mathf.Max(1, EffortBalanceCadenceCap);
            else
                return 1;
        }
    }
}

public class PlayerDailyStatistics
{
    public DateTime LastTimePlayed = DateTime.Parse("2001/01/01");
    public float TimePlayed = 0f;
    public float TimePedaled = 0f;
    public float TimeAboveTarget = 0f;
    public float TimeAboveVigorous = 0f;

    public PlayerDailyStatistics (UJeli jeli)
    {
        try { LastTimePlayed = jeli["LastTimePlayed"].TimeValue; } catch { }
        try { TimePlayed = jeli["TimePlayed"].FloatValue; } catch { }
        try { TimePedaled = jeli["TimePedaled"].FloatValue; } catch { }
        try { TimeAboveTarget = jeli["TimeAboveTarget"].FloatValue; } catch { }
        try { TimeAboveVigorous = jeli["TimeAboveVigorous"].FloatValue; } catch { }
    }

    public void Reset (DateTime now)
    {
        LastTimePlayed = now;
        TimePlayed = 0f;
        TimePedaled = 0f;
        TimeAboveTarget = 0f;
        TimeAboveVigorous = 0f;
    }

    public bool AnyDailyLimitReached (PlayerHealthProfile healthProfile)
    {
        if (healthProfile.NoRestrictions)
            return false;

        return TimePedaled >= healthProfile.MaxDailyTimePedaled ||
            TimeAboveTarget >= healthProfile.MaxDailyTimeAboveTarget ||
            TimeAboveVigorous >= healthProfile.MaxDailyTimeAboveVigorous;
    }
}