stat.v.2.0

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

    public virtual Type StatType { get { return typeof(Value); } }

    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 virtual T ModifyAndUse(T t, int count=1)
    {
        Modify(t);
        return Use(count);
    }
}

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
{
    public virtual T MaxValue { get; }
    public virtual T MinValue { get; }

    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 virtual T Add(T amount)
    {
        return Modify(amount);
    }

    public virtual T Subtract(T amount)
    {
        return Add(-amount);
    }

    public virtual T Set(T amount)
    {
        return Add(amount - Value);
    }
}

public class DecimalStat : NumericStat<decimal> { }
public class DoubleStat : NumericStat<double> { }
public class FloatStat : NumericStat<float> { }
public class ByteStat : NumericStat<byte> { }
public class SByteStat : NumericStat<sbyte> { }
public class ShortStat : NumericStat<short> { }
public class UShortStat : NumericStat<ushort> { }
public class IntStat : NumericStat<int> { }
public class UIntStat : NumericStat<uint> { }
public class LongStat : NumericStat<long> { }
public class ULongStat : NumericStat<ulong> { }

public abstract class HybridStat<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 UnsignedHybridStat : HybridStat<ulong>
{
    public static readonly byte MaxDecimals = 19;

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

public class SignedHybridStat : HybridStat<long>
{
    public static readonly byte MaxDecimals = 20;
}

//------------------
//These will go in a mod
//------------------

public class ResourceStat<T,U> : FloatStat
    where T : UnsignedHybridStat
    where U : UnsignedHybridStat
{
    protected T BaseStat { get; set; }
    public U CurrentStat { get; protected set; }

    public override ulong Value
    {
        get { return BaseStat.Value; }
        protected set { BaseStat.Set(value);}
    }

    public ulong Current
    {
        get { return CurrentStat.Value; }
        protected set { CurrentStat.Set(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);
    }
}

//------------------
//These will go in a Renegade-specific mod
//------------------

public class EVStat : UnsignedHybridStat
{
    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;
    }
}