PKHeX/PKHeX.Core/Legality/Moves/LearnLookup.cs

using System;
using System.Collections.Generic;
using System.Linq;
using static PKHeX.Core.Legal;

namespace PKHeX.Core
{
    /// <summary>
    /// Level-Up Lookup object
    /// </summary>
    public sealed class LearnLookup
    {
        private readonly GameVersion Version;
        private readonly PersonalTable Table;
        private readonly Learnset[] Learn;

        public LearnLookup(PersonalTable table, Learnset[] learn, GameVersion version)
        {
            Version = version;
            Table = table;
            Learn = learn;
        }

        public List<int> AddMovesIndex(List<int> moves, int index, int max, int min)
        {
            if (index <= 0)
                return moves;
            return Learn[index].AddMoves(moves, max, min);
        }

        public List<int> AddMoves(List<int> moves, int species, int form, int max, int min = 0)
        {
            int index = Table.GetFormIndex(species, form);
            return AddMovesIndex(moves, index, max, min);
        }

        public List<int> AddMoves1(List<int> moves, int species, int form, int max, int min)
        {
            int index = Table.GetFormIndex(species, form);
            return AddMovesIndex1(moves, index, max, min);
        }

        public List<int> AddMovesIndex1(List<int> moves, int index, int max, int min)
        {
            if (min == 1)
                moves.AddRange(((PersonalInfoG1)Table[index]).Moves);
            return AddMovesIndex(moves, index, max, min);
        }

        public List<int> GetMoves(int species, int form, int min, int max)
        {
            int index = Table.GetFormIndex(species, form);
            return Learn[index].GetMoveList(max, min);
        }

        public LearnVersion GetIsLevelUp(int species, int form, int move)
        {
            int index = Table.GetFormIndex(species, form);
            if (index <= 0)
                return LearnNONE;
            var lv = Learn[index].GetLevelLearnMove(move);
            if (lv >= 0)
                return new LearnVersion(lv, Version);
            return LearnNONE;
        }

        public LearnVersion GetIsLevelUp(int species, int form, int move, int max)
        {
            int index = Table.GetFormIndex(species, form);
            if (index <= 0)
                return LearnNONE;
            var lv = Learn[index].GetLevelLearnMove(move);
            if (lv >= 0 && lv <= max)
                return new LearnVersion(lv, Version);
            return LearnNONE;
        }

        public LearnVersion GetIsLevelUpMin(int species, int move, int max, int min, int form)
        {
            int index = Table.GetFormIndex(species, form);
            if (index <= 0)
                return LearnNONE;
            var lv = Learn[index].GetLevelLearnMove(move, min);
            if (lv >= min && lv <= max)
                return new LearnVersion(lv, Version);
            return LearnNONE;
        }

        public LearnVersion GetIsLevelUpG1(int species, int form, int move, int max, int min = 0)
        {
            int index = PersonalTable.RB.GetFormIndex(species, form);
            if (index == 0)
                return LearnNONE;

            // No Move re-learner -- have to be learned on level-up
            var lv = Learn[index].GetLevelLearnMove(move, min);
            if (lv >= 0 && lv <= max)
                return new LearnVersion(lv, Version);

            if (min >= 1)
                return LearnNONE;

            var pi = (PersonalInfoG1)Table[index];
            var i = Array.IndexOf(pi.Moves, move);

            // Check if move was not overwritten by higher level moves before it was encountered
            if (i >= 0)
            {
                var unique = Learn[index].GetUniqueMovesLearned(pi.Moves.Where(z => z != 0), max);
                if (unique.Count - i <= 4)
                    return new LearnVersion(0, Version);
            }
            return LearnNONE;
        }
    }
}