using System;

using System.Collections.Generic;

public class Program

{

    public static NiftyHat.LevelTableTest test = new NiftyHat.LevelTableTest();

    public static void Main()

    {

        Random rand = new Random();

        //ulong testAmount = (ulong)rand.Next(0,1500);

        //Console.WriteLine($"exp amount {testAmount}");

        //test.Debug(testAmount);

        ulong[] testAmounts = new ulong[] {1,11,50,51,250,1500, (ulong)rand.Next(0,1500), (ulong)rand.Next(0,1500)};

        foreach (ulong amount in testAmounts)

        {

            test.Debug(amount);

        }

    }

}

​

namespace NiftyHat

{

     public struct ValueRange<TValue> where TValue : IComparable<TValue>

    {

        public TValue Min => _min;

        public TValue Max => _max;

​

        private readonly TValue _min;

        private readonly TValue _max;

​

        public ValueRange(TValue min, TValue max)

        {

            _min = min;

            _max = max;

        }

​

        public bool Contains(TValue value)

        {

            return _min.CompareTo(value) <= 0 && _max.CompareTo(value) >= 0;

        }

    }

public interface ILevelEntry

{

    uint Level {get;}

    ValueRange<ulong> ExpRange {get;}

}

​

public class LevelTableTest

{

    public struct Entry : ILevelEntry

    {

        public uint Level {get; internal set;}

        public ValueRange<ulong> ExpRange {get; internal set;}

    }

    private int _index = 0;

    private Entry _cache;

    readonly IList<ulong> _expAmounts;

    public LevelTableTest ()

    {

        _expAmounts = new List<ulong> () {50,150,300,500,1000};

        _cache.Level = 1;

        _cache.ExpRange = new ValueRange<ulong>(0,_expAmounts[0]);

    }

    public void Debug(ulong amount)

    {

        if (_cache.ExpRange.Contains(amount))

        {

            Console.WriteLine($"Cache Level:{_cache.Level} Exp:{amount}/{_cache.ExpRange.Max}");

        }

        else

        {

            for (int i = 1; i < _expAmounts.Count; i++)

            {

                ulong requiredForLevel = _expAmounts[i];

                if (amount > requiredForLevel)

                {

                    continue;

                }

                _cache.Level = (uint)i + 1;

                _cache.ExpRange = new ValueRange<ulong>(_expAmounts[i],requiredForLevel);

            }

        }

        Console.WriteLine($"Current Level:{_cache.Level} Exp:{amount}/{_cache.ExpRange.Max}");

    }

}

}

​

​