Wrapper for Species and SpeciesLibrary

PkmnLibSharp/Library/Forme.cs

@@ -132,7 +132,7 @@ namespace PkmnLibSharp.Library
             }
         }
 
-        private Forme(IntPtr parent) : base(parent)
+        internal Forme(IntPtr parent) : base(parent)
         {
         }
 

PkmnLibSharp/Library/LibrarySettings.cs

@@ -1,4 +1,3 @@
-using System;
 using PkmnLibSharp.Utilities;
 
 namespace PkmnLibSharp.Library

PkmnLibSharp/Library/Species.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using Creatureliblibrary.Generated;
 using Pkmnlib.Generated;
 using PkmnLibSharp.Utilities;
 
@@ -6,8 +8,69 @@ namespace PkmnLibSharp.Library
 {
     public class Species : PointerWrapper
     {
-        // ReSharper disable once SuggestBaseTypeForParameter
-        private Species(IntPtr ptr) : base(ptr)
+        private string _name;
+        private string _growthRate;
+
+        private readonly Dictionary<string, Forme> _formes =
+            new Dictionary<string, Forme>(StringComparer.InvariantCultureIgnoreCase);
+
+        public ushort Id => CreatureSpecies.GetId(Ptr);
+        public float GenderRate => CreatureSpecies.GetGenderRate(Ptr);
+        public byte CaptureRate => CreatureSpecies.GetCaptureRate(Ptr);
+        public string Name => _name ??= CreatureSpecies.GetName(Ptr).PtrString();
+        public string GrowthRate => _growthRate ??= CreatureSpecies.GetGrowthRate(Ptr).PtrString();
+
+
+        public bool HasForme(string s)
+        {
+            return CreatureSpecies.HasVariant(Ptr, s.ToPtr()) == MarshalHelper.True;
+        }
+
+        public bool TryGetForme(string s, out Forme forme)
+        {
+            if (_formes.TryGetValue(s, out forme))
+                return true;
+            var ptr = IntPtr.Zero;
+            if (CreatureSpecies.TryGetVariant(Ptr, s.ToPtr(), ref ptr) == MarshalHelper.True)
+            {
+                if (TryResolvePointer(ptr, out forme))
+                {
+                    _formes.Add(s, forme);
+                    return true;
+                }
+
+                forme = new Forme(ptr);
+                _formes.Add(s, forme);
+                return true;
+            }
+
+            return false;
+        }
+
+        public Forme GetForme(string s)
+        {
+            if (_formes.TryGetValue(s, out var forme))
+                return forme;
+            var ptr = IntPtr.Zero;
+            CreatureSpecies.GetVariant(ref ptr, Ptr, s.ToPtr()).Assert();
+            if (TryResolvePointer(ptr, out forme))
+            {
+                _formes.Add(s, forme);
+                return forme;
+            }
+            forme = new Forme(ptr);
+            _formes.Add(s, forme);
+            return forme;
+        }
+        
+        public void SetForme(string s, Forme forme)
+        {
+            _formes.Add(s, forme);
+            CreatureSpecies.SetVariant(Ptr, s.ToPtr(), forme.Ptr).Assert();
+        }
+
+
+        internal Species(IntPtr ptr) : base(ptr)
         {
         }
 
@@ -17,7 +80,9 @@ namespace PkmnLibSharp.Library
             var ptr = IntPtr.Zero;
             PokemonSpecies.Construct(ref ptr, id, name.ToPtr(), defaultForme.Ptr, genderRatio,
                 growthRate.ToPtr(), captureRate, baseHappiness).Assert();
-            return new Species(ptr);
+            var s = new Species(ptr);
+            s._formes.Add("default", defaultForme);
+            return s;
         }
 
         protected override void DeletePtr()

PkmnLibSharp/Library/SpeciesLibrary.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using PkmnLibSharp.Utilities;
+
+namespace PkmnLibSharp.Library
+{
+    public class SpeciesLibrary : PointerWrapper
+    {
+        private readonly Dictionary<string, Species> _cache = new Dictionary<string, Species>(StringComparer.InvariantCultureIgnoreCase);
+        public ulong Count => Creatureliblibrary.Generated.SpeciesLibrary.GetCount(Ptr);
+
+        public void Insert(string key, Species species)
+        {
+            Creatureliblibrary.Generated.SpeciesLibrary.Insert(Ptr, key.ToPtr(), species.Ptr).Assert();
+            _cache.Add(key, species);
+        }
+
+        public void Delete(string key)
+        {
+            Creatureliblibrary.Generated.SpeciesLibrary.Delete(Ptr, key.ToPtr()).Assert();
+            _cache.Remove(key);
+        }
+
+        public bool TryGet(string key, out Species species)
+        {
+            if (_cache.TryGetValue(key, out species))
+                return true;
+            var ptr = IntPtr.Zero;
+            if (Creatureliblibrary.Generated.SpeciesLibrary.TryGet(Ptr, key.ToPtr(), ref ptr) != MarshalHelper.True) 
+                return false;
+            if (TryResolvePointer(ptr, out species))
+            {
+                _cache.Add(key, species);
+                return true;
+            }
+            species = new Species(ptr);
+            _cache.Add(key, species);
+            return true;
+        }
+
+        public Species Get(string key)
+        {
+            if (_cache.TryGetValue(key, out var species))
+                return species;
+            var ptr = IntPtr.Zero;
+            Creatureliblibrary.Generated.SpeciesLibrary.Get(Ptr, key.ToPtr(), ref ptr).Assert();
+            if (TryResolvePointer(ptr, out species))
+            {
+                _cache.Add(key, species);
+                return species;
+            }
+            species = new Species(ptr);
+            _cache.Add(key, species);
+            return species;
+        }
+
+        public SpeciesLibrary(ulong initialCapacity) : base(
+            Creatureliblibrary.Generated.SpeciesLibrary.Construct(initialCapacity))
+        {
+        }
+
+        protected override void DeletePtr()
+        {
+            Creatureliblibrary.Generated.SpeciesLibrary.Destruct(Ptr);
+        }
+    }
+}