Stat

public abstract class Stat<T>
{
    public string Name { get; }
    public string Description { get; }
    public string Notes { get; }

    public abstract T Value { get; protected set; }

    public virtual T Use() { return Value; }
    public virtual T Use(T amount) { return Value; }

    public abstract T Modify(T t);
}

public abstract class SimpleStat<T> : Stat<T>
{
    public override T Value { get; protected set; }

    public override T Modify(T t)
    {
        Value = t;
        return t;
    }
}

public class StringStat : SimpleStat<string> { }

public class BoolStat : SimpleStat<bool> { }

public abstract class NumericStat<T> : Stat<T>
    where T : struct
{
    //readonly properties, set during constructor and nowhere else
    public T Ceiling { get; }
    public T Floor { get; }

    //these might need cached since Decimals never changes
    public virtual T MaxValue { get { return Ceiling == 0 ? T.MaxValue : Ceiling; } }
    public virtual T MinValue { get { return Floor == 0 ? T.MinValue : Floor; } }

    public virtual T Value { get; protected set; }

    public override T Modify(T amount)
    {
        Value = Value + amount;
        ClampValue();
        return Value;
    }

    protected virtual void ClampValue()
    {
        Value = (Value < MinValue) ? MinValue : ((Value > MaxValue) ? MaxValue : Value);
    }
}

public abstract class IntegerStat<T> : NumericStat<T>
{
    public byte Decimals { get; }

    public virtual T RawValue { get; protected set; }

    //these might need cached since Decimals never changes
    public override T MaxValue { get { return (T)(Ceiling / DecimalFactor); } }
    public override T MinValue { get { return (T)(Floor / DecimalFactor); } }
    public virtual double DecimalFactor { get { return Math.Pow(10, Decimals); } }

    public virtual double DecimalPart { get { return (RawValue % DecimalFactor) / DecimalFactor; } }

    public override T Value
    {
        get { return (T)(RawValue / DecimalFactor); }
        protected set
        {

            RawValue = (T)(value / DecimalFactor);
            ClampValue();
        }
    }

    protected override void ClampValue()
    {
        RawValue = (RawValue < MinValue) ? MinValue : ((RawValue > MaxValue) ? MaxValue : RawValue);
    }
}

public class DecimalStat : NumericStat<decimal> { }

public class ULongStat : IntegerStat<ulong>
{
    public static readonly byte MaxDecimals = 19;

    public virtual ulong Modify(long amount)
    {
        Value = Value + amount;
        return Value;
    }
}

public class LongStat : IntegerStat<long>
{
    public static readonly byte MaxDecimals = 20;
}

public class EVStat : ULongStat
{
    public float ExcerciseAmount { get; }
    public ulong UsageThreshold { get; }

    public override ulong Use()
    {
        return Use(1L);
    }

    public override ulong Use(ulong u)
    {
        ulong oldValue = Value;
        int count = Math.Max(u / UsageThreshold, 1);
        Value = oldValue + (ExcerciseAmount * count);
        return oldValue;
    }
}

public class ResourceStat : Stat<ulong>
{
    protected EVStat BaseStat { get; set; }
    public ULongStat CurrentStat { get; protected set; }

    public override ulong Value
    {
        get { return BaseStat.Value; }
        protected set { BaseStat.Value = value;}
    }

    public ulong Current
    {
        get { return CurrentStat.Value; }
        protected set { CurrentStat.Value = value; }
    }

    public override ulong Use()
    {
        return BaseStat.Use();
    }

    public override ulong Use(ulong amount)
    {
        return BaseStat.Use(u);
    }

    public override ulong Modify(ulong u)
    {
        return BaseStat.Modify(u)
    }

    public virtual ulong Add(long amount)
    {
        CurrentStat.Modify(amount);
        BaseStat.Use(amount);
    }

    public virtual ulong Subtract(long amount)
    {
        Add(-amount);
    }

    public virtual ulong Set(ulong amount)
    {
        Add(amount - CurrentStat.Value);
    }
}