PkmnLibRSharp/PkmnLibRSharp/StaticData/GrowthRate.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using PkmnLibSharp.Utils;
using Interface = PkmnLibSharp.FFI.StaticData.GrowthRate;

namespace PkmnLibSharp.StaticData
{
    public abstract class GrowthRate : ExternPointer<object>
    {
        protected internal GrowthRate()
        {
        }

        protected internal GrowthRate(IntPtr ptr, bool isOwner) : base(ptr, isOwner)
        {
        }

        public LevelInt CalculateLevel(uint experience)
        {
            return Interface.growth_rate_calculate_level(Ptr, experience);
        }

        public uint CalculateExperience(LevelInt level)
        {
            Debug.Assert(level >= 1);
            return Interface.growth_rate_calculate_experience(Ptr, level);
        }

        protected override void Destructor()
        {
            Interface.growth_rate_lookup_drop(Ptr);
        }
    }

    public class LookupGrowthRate : GrowthRate
    {
        public LookupGrowthRate(uint[] experienceArray)
        {
            var arrayPtr = experienceArray.ArrayPtr();
            var ptr = Interface.growth_rate_lookup_new(arrayPtr, (ulong)experienceArray.Length);
            InitializePointer(ptr, true);
        }

        protected override object CreateCache()
        {
            return new object();
        }

        ~LookupGrowthRate()
        {
            Dispose();
        }
    }

    /// <summary>
    /// A collection of the growth rates that have been used since generation 5.
    /// </summary>
    public static class CommonGrowthRates
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static uint Power2(uint i)
        {
            return i * i;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static uint Power3(uint i)
        {
            return i * i * i;
        }

        public static LookupGrowthRate Fast(LevelInt maxLevel)
        {
            var arr = new uint[maxLevel];
            arr[0] = 0;
            for (uint i = 2; i < maxLevel + 1; i++)
            {
                arr[i - 1] = 4 * Power3(i) / 5;
            }

            return new LookupGrowthRate(arr);
        }
        
        public static LookupGrowthRate MediumFast(LevelInt maxLevel)
        {
            var arr = new uint[maxLevel];
            arr[0] = 0;
            for (uint i = 2; i < maxLevel + 1; i++)
            {
                arr[i - 1] = Power3(i);
            }

            return new LookupGrowthRate(arr);
        }
        
        public static LookupGrowthRate MediumSlow(LevelInt maxLevel)
        {
            var arr = new uint[maxLevel];
            arr[0] = 0;
            for (uint i = 2; i < maxLevel + 1; i++)
            {
                arr[i - 1] = 6 * Power3(i) / 5 - 15 * Power2(i) + 100 * i - 140;
            }

            return new LookupGrowthRate(arr);
        }
        
        public static LookupGrowthRate Slow(LevelInt maxLevel)
        {
            var arr = new uint[maxLevel];
            arr[0] = 0;
            for (uint i = 2; i < maxLevel + 1; i++)
            {
                arr[i - 1] = 5 * Power3(i) / 4;
            }
            return new LookupGrowthRate(arr);
        }

        public static LookupGrowthRate Erratic(LevelInt maxLevel)
        {
            var arr = new uint[maxLevel];
            arr[0] = 0;
            uint i = 2;
            for (; i < 50; i++)
            {
                arr[i - 1] = Power3(i) * (100 - i) / 50;
            }

            for (; i < 68; i++)
            {
                arr[i - 1] = Power3(i) * (150 - i) / 100;
            }

            for (; i < 98; i++)
            {
                arr[i - 1] = Power3(i) * (uint)((1911 - 10 * i) / 3.0) / 500;
            }

            for (; i < maxLevel + 1; i++)
            {
                arr[i - 1] = Power3(i) * (160 - i) / 100;
            }

            return new LookupGrowthRate(arr);
        }
        
        public static LookupGrowthRate Fluctuating(LevelInt maxLevel)
        {
            var arr = new uint[maxLevel];
            arr[0] = 0;
            uint i = 2;
            for (; i < 15; i++)
            {
                arr[i - 1] = Power3(i) * (uint)((Math.Floor((i + 1) / 3.0) + 24) / 50.0);
            }

            for (; i < 36; i++)
            {
                arr[i - 1] = Power3(i) * (i + 14) / 50;
            }

            for (; i < maxLevel + 1; i++)
            {
                arr[i - 1] = Power3(i) * (i / 2 + 32) / 50;
            }

            return new LookupGrowthRate(arr);
        }
    }
}