diff --git a/PkmnLibSharp/Battling/LearnedMove.cs b/PkmnLibSharp/Battling/LearnedMove.cs
index 6da86e1..4f57238 100644
--- a/PkmnLibSharp/Battling/LearnedMove.cs
+++ b/PkmnLibSharp/Battling/LearnedMove.cs
@@ -11,10 +11,15 @@ namespace PkmnLibSharp.Battling
         internal LearnedMove(IntPtr ptr) : base(ptr){}
         
         public LearnedMove(MoveData move, byte maxUses, MoveLearnMethod learnMethod)
+        {
+            Initialize(CreatePtr(move, maxUses, learnMethod));
+        }
+
+        protected static IntPtr CreatePtr(MoveData move, byte maxUses, MoveLearnMethod learnMethod)
         {
             var ptr = IntPtr.Zero;
             LearnedAttack.Construct(ref ptr, move.Ptr, maxUses, (AttackLearnMethod) learnMethod).Assert();
-            Initialize(ptr);
+            return ptr;
         }
 
         public MoveData Move
diff --git a/PkmnLibSharp/Battling/Pokemon.cs b/PkmnLibSharp/Battling/Pokemon.cs
index 395dc39..4141057 100644
--- a/PkmnLibSharp/Battling/Pokemon.cs
+++ b/PkmnLibSharp/Battling/Pokemon.cs
@@ -23,18 +23,28 @@ namespace PkmnLibSharp.Battling
             byte abilityIndex,
             IReadOnlyCollection<LearnedMove> moves, StatisticSet<byte> ivs, StatisticSet<byte> evs,
             Nature nature)
-            : base(Pkmnlib.Generated.Pokemon.Construct(
-                library.Ptr, species.Ptr, forme.Ptr, level, experience,
+            : base(CreatePtr(library, species, forme, level, experience, uid, gender, coloring, heldItem, nickname,
+                hiddenAbility, abilityIndex, moves, ivs, evs, nature))
+        {
+            Library = library;
+            Initialize();
+        }
+
+        protected static IntPtr CreatePtr(BattleLibrary library, Species species, Forme forme,
+            byte level, uint experience, uint uid,
+            Gender gender, byte coloring, Item? heldItem, string? nickname, bool hiddenAbility,
+            byte abilityIndex,
+            IReadOnlyCollection<LearnedMove> moves, StatisticSet<byte> ivs, StatisticSet<byte> evs,
+            Nature nature)
+        {
+            return Pkmnlib.Generated.Pokemon.Construct(library.Ptr, species.Ptr, forme.Ptr, level, experience,
                 uid, (Pkmnlib.Gender) gender, coloring, heldItem?.Ptr ?? IntPtr.Zero, nickname.ToPtr(),
                 hiddenAbility.ToNative(), abilityIndex,
                 moves.Select(x => x?.Ptr ?? IntPtr.Zero).ToArray().ArrayPtr(),
                 (ulong) moves.Count,
                 ivs.HP, ivs.Attack, ivs.Defense, ivs.SpecialAttack,
                 ivs.SpecialDefense, ivs.Speed, evs.HP, evs.Attack, evs.Defense,
-                evs.SpecialAttack, evs.SpecialDefense, evs.Speed, nature.Ptr))
-        {
-            Library = library;
-            Initialize();
+                evs.SpecialAttack, evs.SpecialDefense, evs.Speed, nature.Ptr);
         }
 
         public BattleLibrary Library { get; private set; }
@@ -169,14 +179,14 @@ namespace PkmnLibSharp.Battling
                 return _nickname;
             }
         }
-        public ReadOnlyNativePtrArray<LearnedMove?> Moves
+        public ReadOnlyNativePtrArray<LearnedMove> Moves
         {
             get
             {
                 if (_moves != null) return _moves;
                 var movesLength = Creaturelib.Generated.Creature.GetAttacksCount(Ptr);
                 var movesPtr = Creaturelib.Generated.Creature.GetAttacks(Ptr);
-                _moves = new ReadOnlyNativePtrArray<LearnedMove?>(movesPtr, (int) movesLength,
+                _moves = new ReadOnlyNativePtrArray<LearnedMove>(movesPtr, (int) movesLength,
                     Constructor.GenericType.LearnedMove);
                 return _moves;
             }
@@ -443,7 +453,7 @@ namespace PkmnLibSharp.Battling
         private Species? _species;
         private Forme? _forme;
         private string? _nickname;
-        private ReadOnlyNativePtrArray<LearnedMove?>? _moves;
+        private ReadOnlyNativePtrArray<LearnedMove>? _moves;
         private Nature? _nature;
         private Battle? _battle;
         private BattleSide? _battleSide;
diff --git a/PkmnLibSharp/Battling/PokemonBuilder.cs b/PkmnLibSharp/Battling/PokemonBuilder.cs
index 0516522..41872cb 100644
--- a/PkmnLibSharp/Battling/PokemonBuilder.cs
+++ b/PkmnLibSharp/Battling/PokemonBuilder.cs
@@ -194,6 +194,7 @@ namespace PkmnLibSharp.Battling
                 Gender = species.GetRandomGender(random);
             }
             
+            PopulateUninitialized(species, forme!, random);
             return Finalize(species, forme!, heldItem, moves, nature);
         }
     }
diff --git a/PkmnLibSharp/Battling/PokemonParty.cs b/PkmnLibSharp/Battling/PokemonParty.cs
index 13eb784..c62df75 100644
--- a/PkmnLibSharp/Battling/PokemonParty.cs
+++ b/PkmnLibSharp/Battling/PokemonParty.cs
@@ -6,7 +6,7 @@ using PkmnLibSharp.Utilities;
 
 namespace PkmnLibSharp.Battling
 {
-    public class PokemonParty : PointerWrapper, IEnumerable<Pokemon>
+    public class PokemonParty : PointerWrapper, IEnumerable<Pokemon?>
     {
         private Pokemon?[]? _cache;
         private ReadOnlyNativePtrArray<Pokemon>? _party;
@@ -28,9 +28,9 @@ namespace PkmnLibSharp.Battling
             _cache = Party.ToArray();
         }
 
-        public virtual Pokemon this[int i] => GetAtIndex((ulong) i);
+        public virtual Pokemon? this[int i] => GetAtIndex((ulong) i);
 
-        public Pokemon GetAtIndex(ulong index)
+        public Pokemon? GetAtIndex(ulong index)
         {
             var ptr = IntPtr.Zero;
             Creaturelib.Generated.CreatureParty.GetAtIndex(ref ptr, Ptr, index).Assert();
@@ -45,10 +45,12 @@ namespace PkmnLibSharp.Battling
             _cache[indexB] = temp;
         }
 
-        public Pokemon SwapInto(ulong indexA, Pokemon pokemon)
+        public Pokemon? SwapInto(ulong indexA, Pokemon? pokemon)
         {
             var ptr = IntPtr.Zero;
-            Creaturelib.Generated.CreatureParty.SwapInto(ref ptr, Ptr, indexA, pokemon.Ptr).Assert();
+            var pkmnPtr = IntPtr.Zero;
+            if (pokemon != null) pkmnPtr = pokemon.Ptr;
+            Creaturelib.Generated.CreatureParty.SwapInto(ref ptr, Ptr, indexA, pkmnPtr).Assert();
             _cache![indexA] = pokemon;
             if (TryResolvePointer(ptr, out Pokemon? newPokemon))
                 return newPokemon!;
diff --git a/PkmnLibSharp/Generated/Arbutils/C.cs b/PkmnLibSharp/Generated/Arbutils/C.cs
index 9f4d09e..93797c3 100644
--- a/PkmnLibSharp/Generated/Arbutils/C.cs
+++ b/PkmnLibSharp/Generated/Arbutils/C.cs
@@ -7,17 +7,13 @@ namespace Arbutils.Generated
     internal static class C
     {
         /// <returns>const char *</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_C_GetLastException")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_C_GetLastException")]
         internal static extern IntPtr GetLastException();
 
         /// <param name="callback">Function *</param>
         /// <returns>void</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_C_SetSignalCallback")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_C_SetSignalCallback")]
         internal static extern void SetSignalCallback(IntPtr callback);
 
-        /// <returns>void</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_C_RaiseSignal")]
-        internal static extern void RaiseSignal();
-
     }
 }
diff --git a/PkmnLibSharp/Generated/Arbutils/Random.cs b/PkmnLibSharp/Generated/Arbutils/Random.cs
index d8740e6..6e9e3bd 100644
--- a/PkmnLibSharp/Generated/Arbutils/Random.cs
+++ b/PkmnLibSharp/Generated/Arbutils/Random.cs
@@ -7,39 +7,39 @@ namespace Arbutils.Generated
     internal static class Random
     {
         /// <returns>Random *</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_Construct")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="seed">long unsigned int</param>
         /// <returns>Random *</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_ConstructWithSeed")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_ConstructWithSeed")]
         internal static extern IntPtr ConstructWithSeed(ulong seed);
 
         /// <param name="p">Random *</param>
         /// <returns>void</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_Destruct")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">Random *</param>
         /// <returns>float</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetFloat")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetFloat")]
         internal static extern float GetFloat(IntPtr p);
 
         /// <param name="p">Random *</param>
         /// <returns>double</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetDouble")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetDouble")]
         internal static extern double GetDouble(IntPtr p);
 
         /// <param name="p">Random *</param>
         /// <returns>int</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_Get")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_Get")]
         internal static extern int Get(IntPtr p);
 
         /// <param name="p">Random *</param>
         /// <param name="max">int</param>
         /// <param name="out">int &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetWithMax")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetWithMax")]
         internal static extern byte GetWithMax(IntPtr p, int max, ref int @out);
 
         /// <param name="p">Random *</param>
@@ -47,19 +47,19 @@ namespace Arbutils.Generated
         /// <param name="max">int</param>
         /// <param name="out">int &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetInLimits")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetInLimits")]
         internal static extern byte GetInLimits(IntPtr p, int min, int max, ref int @out);
 
         /// <param name="p">Random *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsigned")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsigned")]
         internal static extern uint GetUnsigned(IntPtr p);
 
         /// <param name="p">Random *</param>
         /// <param name="max">unsigned int</param>
         /// <param name="out">unsigned int &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsignedWithMax")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsignedWithMax")]
         internal static extern byte GetUnsignedWithMax(IntPtr p, uint max, ref uint @out);
 
         /// <param name="p">Random *</param>
@@ -67,12 +67,12 @@ namespace Arbutils.Generated
         /// <param name="max">unsigned int</param>
         /// <param name="out">unsigned int &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsignedInLimits")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsignedInLimits")]
         internal static extern byte GetUnsignedInLimits(IntPtr p, uint min, uint max, ref uint @out);
 
         /// <param name="p">Random *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetSeed")]
+        [DllImport("libArbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetSeed")]
         internal static extern ulong GetSeed(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/AttackData.cs b/PkmnLibSharp/Generated/Creaturelib/AttackData.cs
index 8ffd0ef..a3ef1f4 100644
--- a/PkmnLibSharp/Generated/Creaturelib/AttackData.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/AttackData.cs
@@ -22,73 +22,73 @@ namespace Creaturelib.Generated
         /// <param name="flags">const char * *</param>
         /// <param name="flagsCount">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr name, byte type, AttackCategory category, byte power, byte accuracy, byte baseUsage, AttackTarget target, sbyte priority, float effectChance, IntPtr effectName, IntPtr effectParameters, ulong effectParameterCount, IntPtr flags, ulong flagsCount);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetName")]
         internal static extern IntPtr GetName(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetType")]
         internal static extern byte GetType(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>AttackCategory</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetCategory")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetCategory")]
         internal static extern AttackCategory GetCategory(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetBasePower")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetBasePower")]
         internal static extern byte GetBasePower(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetAccuracy")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetAccuracy")]
         internal static extern byte GetAccuracy(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetBaseUsages")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetBaseUsages")]
         internal static extern byte GetBaseUsages(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>AttackTarget</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetTarget")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetTarget")]
         internal static extern AttackTarget GetTarget(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>signed char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetPriority")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetPriority")]
         internal static extern sbyte GetPriority(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_HasSecondaryEffect")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_HasSecondaryEffect")]
         internal static extern byte HasSecondaryEffect(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>float</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetSecondaryEffectChance")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetSecondaryEffectChance")]
         internal static extern float GetSecondaryEffectChance(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetSecondaryEffectName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_GetSecondaryEffectName")]
         internal static extern IntPtr GetSecondaryEffectName(IntPtr p);
 
         /// <param name="p">const AttackData *</param>
         /// <param name="key">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_HasFlag")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackData_HasFlag")]
         internal static extern byte HasFlag(IntPtr p, IntPtr key);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/AttackLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/AttackLibrary.cs
index bab7330..b0123d4 100644
--- a/PkmnLibSharp/Generated/Creaturelib/AttackLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/AttackLibrary.cs
@@ -9,78 +9,78 @@ namespace Creaturelib.Generated
         /// <param name="library">AttackLibrary * &</param>
         /// <param name="initialCapacity">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Construct")]
         internal static extern byte Construct(ref IntPtr library, ulong initialCapacity);
 
         /// <param name="p">const AttackLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="t">AttackData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Insert")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Insert")]
         internal static extern byte Insert(IntPtr p, IntPtr name, IntPtr t);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="t">AttackData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_InsertWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_InsertWithHash")]
         internal static extern byte InsertWithHash(IntPtr p, uint hashedKey, IntPtr t);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="name">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Delete")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Delete")]
         internal static extern byte Delete(IntPtr p, IntPtr name);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_DeleteWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_DeleteWithHash")]
         internal static extern byte DeleteWithHash(IntPtr p, uint hashedKey);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const AttackData * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_TryGet")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_TryGet")]
         internal static extern byte TryGet(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="out">const AttackData * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_TryGetWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_TryGetWithHash")]
         internal static extern byte TryGetWithHash(IntPtr p, uint hashedKey, ref IntPtr @out);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const AttackData * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Get")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_Get")]
         internal static extern byte Get(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="out">const AttackData * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_GetWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_GetWithHash")]
         internal static extern byte GetWithHash(IntPtr p, uint hashedKey, ref IntPtr @out);
 
         /// <param name="p">AttackLibrary *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_GetCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_GetCount")]
         internal static extern ulong GetCount(IntPtr p);
 
         /// <param name="p">AttackLibrary *</param>
         /// <param name="index">long unsigned int</param>
         /// <param name="out">const AttackData * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_GetAtIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackLibrary_GetAtIndex")]
         internal static extern byte GetAtIndex(IntPtr p, ulong index, ref IntPtr @out);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/AttackTurnChoice.cs b/PkmnLibSharp/Generated/Creaturelib/AttackTurnChoice.cs
index 11c18a5..50c97f7 100644
--- a/PkmnLibSharp/Generated/Creaturelib/AttackTurnChoice.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/AttackTurnChoice.cs
@@ -11,43 +11,43 @@ namespace Creaturelib.Generated
         /// <param name="sideIndex">unsigned char</param>
         /// <param name="targetIndex">unsigned char</param>
         /// <returns>AttackTurnChoice *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_Construct")]
         internal static extern IntPtr Construct(IntPtr user, IntPtr attack, byte sideIndex, byte targetIndex);
 
         /// <param name="p">AttackTurnChoice *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const AttackTurnChoice *</param>
         /// <returns>LearnedAttack *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetAttack")]
         internal static extern IntPtr GetAttack(IntPtr p);
 
         /// <param name="p">const AttackTurnChoice *</param>
         /// <returns>TurnChoiceKind</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetKind")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetKind")]
         internal static extern TurnChoiceKind GetKind(IntPtr p);
 
         /// <param name="out">signed char &</param>
         /// <param name="p">AttackTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetPriority")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetPriority")]
         internal static extern byte GetPriority(ref sbyte @out, IntPtr p);
 
         /// <param name="p">const AttackTurnChoice *</param>
         /// <returns>Script *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetAttackScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetAttackScript")]
         internal static extern IntPtr GetAttackScript(IntPtr p);
 
         /// <param name="p">const AttackTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetTargetSideIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetTargetSideIndex")]
         internal static extern byte GetTargetSideIndex(IntPtr p);
 
         /// <param name="p">const AttackTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetTargetCreatureIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetTargetCreatureIndex")]
         internal static extern byte GetTargetCreatureIndex(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/AttackUseEvent.cs b/PkmnLibSharp/Generated/Creaturelib/AttackUseEvent.cs
index c714382..cc54c61 100644
--- a/PkmnLibSharp/Generated/Creaturelib/AttackUseEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/AttackUseEvent.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const AttackUseEvent *</param>
         /// <returns>const ExecutingAttack *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackUseEvent_GetAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackUseEvent_GetAttack")]
         internal static extern IntPtr GetAttack(IntPtr p);
 
         /// <param name="p">const AttackUseEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackUseEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackUseEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/AttackUseHistory.cs b/PkmnLibSharp/Generated/Creaturelib/AttackUseHistory.cs
index 7a24de7..4252bca 100644
--- a/PkmnLibSharp/Generated/Creaturelib/AttackUseHistory.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/AttackUseHistory.cs
@@ -8,7 +8,7 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const AttackUseHistory *</param>
         /// <returns>const ExecutingAttack *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackUseHistory_GetAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackUseHistory_GetAttack")]
         internal static extern IntPtr GetAttack(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/BaseTurnChoice.cs b/PkmnLibSharp/Generated/Creaturelib/BaseTurnChoice.cs
index 857c609..e08e6cc 100644
--- a/PkmnLibSharp/Generated/Creaturelib/BaseTurnChoice.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/BaseTurnChoice.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const BaseTurnChoice *</param>
         /// <returns>TurnChoiceKind</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetKind")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetKind")]
         internal static extern TurnChoiceKind GetKind(IntPtr p);
 
         /// <param name="p">const BaseTurnChoice *</param>
         /// <returns>Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetUser")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetUser")]
         internal static extern IntPtr GetUser(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/Battle.cs b/PkmnLibSharp/Generated/Creaturelib/Battle.cs
index 7f64990..033de96 100644
--- a/PkmnLibSharp/Generated/Creaturelib/Battle.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/Battle.cs
@@ -15,68 +15,68 @@ namespace Creaturelib.Generated
         /// <param name="creaturesPerSide">unsigned char</param>
         /// <param name="randomSeed">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr library, IntPtr partyArr, ulong numberOfParties, byte canFlee, byte numberOfSides, byte creaturesPerSide, ulong randomSeed);
 
         /// <param name="p">const Battle *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>const BattleLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetLibrary")]
         internal static extern IntPtr GetLibrary(IntPtr p);
 
         /// <param name="out">bool &</param>
         /// <param name="p">Battle *</param>
         /// <param name="turnChoice">BaseTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanUse")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanUse")]
         internal static extern byte CanUse(ref byte @out, IntPtr p, IntPtr turnChoice);
 
         /// <param name="out">bool &</param>
         /// <param name="p">Battle *</param>
         /// <param name="turnChoice">BaseTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_TrySetChoice")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_TrySetChoice")]
         internal static extern byte TrySetChoice(ref byte @out, IntPtr p, IntPtr turnChoice);
 
         /// <param name="p">const Battle *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanFlee")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanFlee")]
         internal static extern byte CanFlee(IntPtr p);
 
         /// <param name="p">Battle *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CheckChoicesSetAndRun")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CheckChoicesSetAndRun")]
         internal static extern byte CheckChoicesSetAndRun(IntPtr p);
 
         /// <param name="p">Battle *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCurrentTurn")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCurrentTurn")]
         internal static extern uint GetCurrentTurn(IntPtr p);
 
         /// <param name="p">Battle *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCreaturesPerSide")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCreaturesPerSide")]
         internal static extern uint GetCreaturesPerSide(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>ChoiceQueue *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCurrentTurnQueue")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCurrentTurnQueue")]
         internal static extern IntPtr GetCurrentTurnQueue(IntPtr p);
 
         /// <param name="p">Battle *</param>
         /// <returns>BattleRandom *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetRandom")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetRandom")]
         internal static extern IntPtr GetRandom(IntPtr p);
 
         /// <param name="out">bool &</param>
         /// <param name="p">const Battle *</param>
         /// <param name="c">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CreatureInField")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CreatureInField")]
         internal static extern byte CreatureInField(ref byte @out, IntPtr p, IntPtr c);
 
         /// <param name="out">Creature * &</param>
@@ -84,14 +84,14 @@ namespace Creaturelib.Generated
         /// <param name="side">unsigned char</param>
         /// <param name="target">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCreature")]
         internal static extern byte GetCreature(ref IntPtr @out, IntPtr p, byte side, byte target);
 
         /// <param name="p">Battle *</param>
         /// <param name="side">unsigned char</param>
         /// <param name="target">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_ForceRecall")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_ForceRecall")]
         internal static extern byte ForceRecall(IntPtr p, byte side, byte target);
 
         /// <param name="p">Battle *</param>
@@ -99,7 +99,7 @@ namespace Creaturelib.Generated
         /// <param name="target">unsigned char</param>
         /// <param name="c">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_SwitchCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_SwitchCreature")]
         internal static extern byte SwitchCreature(IntPtr p, byte side, byte target, IntPtr c);
 
         /// <param name="out">bool &</param>
@@ -107,99 +107,99 @@ namespace Creaturelib.Generated
         /// <param name="side">unsigned char</param>
         /// <param name="target">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanSlotBeFilled")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanSlotBeFilled")]
         internal static extern byte CanSlotBeFilled(ref byte @out, IntPtr p, byte side, byte target);
 
         /// <param name="p">Battle *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_ValidateBattleState")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_ValidateBattleState")]
         internal static extern byte ValidateBattleState(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasEnded")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasEnded")]
         internal static extern byte HasEnded(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasConclusiveResult")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasConclusiveResult")]
         internal static extern byte HasConclusiveResult(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetWinningSide")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetWinningSide")]
         internal static extern byte GetWinningSide(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetSidesCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetSidesCount")]
         internal static extern ulong GetSidesCount(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>const BattleSide * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetSides")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetSides")]
         internal static extern IntPtr GetSides(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetPartiesCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetPartiesCount")]
         internal static extern ulong GetPartiesCount(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>const BattleParty * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetParties")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetParties")]
         internal static extern IntPtr GetParties(IntPtr p);
 
         /// <param name="p">Battle *</param>
         /// <param name="key">const char *</param>
         /// <returns>Script *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetVolatileScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetVolatileScript")]
         internal static extern IntPtr GetVolatileScript(IntPtr p, IntPtr key);
 
         /// <param name="p">Battle *</param>
         /// <param name="key">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_AddVolatileScriptByName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_AddVolatileScriptByName")]
         internal static extern byte AddVolatileScriptByName(IntPtr p, IntPtr key);
 
         /// <param name="p">Battle *</param>
         /// <param name="script">Script *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_AddVolatileScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_AddVolatileScript")]
         internal static extern byte AddVolatileScript(IntPtr p, IntPtr script);
 
         /// <param name="p">Battle *</param>
         /// <param name="key">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RemoveVolatileScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RemoveVolatileScript")]
         internal static extern byte RemoveVolatileScript(IntPtr p, IntPtr key);
 
         /// <param name="p">Battle *</param>
         /// <param name="script">Script *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RemoveVolatileScriptWithScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RemoveVolatileScriptWithScript")]
         internal static extern byte RemoveVolatileScriptWithScript(IntPtr p, IntPtr script);
 
         /// <param name="p">Battle *</param>
         /// <param name="key">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasVolatileScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasVolatileScript")]
         internal static extern byte HasVolatileScript(IntPtr p, IntPtr key);
 
         /// <param name="p">Battle *</param>
         /// <param name="func">Function *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RegisterEventListener")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RegisterEventListener")]
         internal static extern byte RegisterEventListener(IntPtr p, IntPtr func);
 
         /// <param name="p">Battle *</param>
         /// <returns>const HistoryHolder *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetHistory")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetHistory")]
         internal static extern IntPtr GetHistory(IntPtr p);
 
         /// <param name="p">const Battle *</param>
         /// <returns>long int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetLastTurnTimeMicroseconds")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetLastTurnTimeMicroseconds")]
         internal static extern long GetLastTurnTimeMicroseconds(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/BattleLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/BattleLibrary.cs
index 68a38dd..466eed4 100644
--- a/PkmnLibSharp/Generated/Creaturelib/BattleLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/BattleLibrary.cs
@@ -14,37 +14,37 @@ namespace Creaturelib.Generated
         /// <param name="scriptResolver">ScriptResolver *</param>
         /// <param name="miscLibrary">MiscLibrary *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr staticLib, IntPtr statCalculator, IntPtr damageLibrary, IntPtr experienceLibrary, IntPtr scriptResolver, IntPtr miscLibrary);
 
         /// <param name="p">const BattleLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const BattleLibrary *</param>
         /// <returns>const DataLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetStaticLib")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetStaticLib")]
         internal static extern IntPtr GetStaticLib(IntPtr p);
 
         /// <param name="p">const BattleLibrary *</param>
         /// <returns>const BattleStatCalculator *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetStatCalculator")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetStatCalculator")]
         internal static extern IntPtr GetStatCalculator(IntPtr p);
 
         /// <param name="p">const BattleLibrary *</param>
         /// <returns>const DamageLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetDamageLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetDamageLibrary")]
         internal static extern IntPtr GetDamageLibrary(IntPtr p);
 
         /// <param name="p">const BattleLibrary *</param>
         /// <returns>const MiscLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetMiscLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetMiscLibrary")]
         internal static extern IntPtr GetMiscLibrary(IntPtr p);
 
         /// <param name="p">const BattleLibrary *</param>
         /// <returns>const ExperienceLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetExperienceLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetExperienceLibrary")]
         internal static extern IntPtr GetExperienceLibrary(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/BattleParty.cs b/PkmnLibSharp/Generated/Creaturelib/BattleParty.cs
index 7c85e58..5e23012 100644
--- a/PkmnLibSharp/Generated/Creaturelib/BattleParty.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/BattleParty.cs
@@ -11,17 +11,17 @@ namespace Creaturelib.Generated
         /// <param name="creatureIndices">unsigned char *</param>
         /// <param name="numberOfIndices">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr p, IntPtr creatureIndices, ulong numberOfIndices);
 
         /// <param name="p">const BattleParty *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const BattleParty *</param>
         /// <returns>CreatureParty *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_GetParty")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_GetParty")]
         internal static extern IntPtr GetParty(IntPtr p);
 
         /// <param name="out">bool &</param>
@@ -29,12 +29,12 @@ namespace Creaturelib.Generated
         /// <param name="side">unsigned char</param>
         /// <param name="creature">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_IsResponsibleForIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_IsResponsibleForIndex")]
         internal static extern byte IsResponsibleForIndex(ref byte @out, IntPtr p, byte side, byte creature);
 
         /// <param name="p">const BattleParty *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_HasCreaturesNotInField")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_HasCreaturesNotInField")]
         internal static extern byte HasCreaturesNotInField(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/BattleRandom.cs b/PkmnLibSharp/Generated/Creaturelib/BattleRandom.cs
index bd5a2ee..7793a70 100644
--- a/PkmnLibSharp/Generated/Creaturelib/BattleRandom.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/BattleRandom.cs
@@ -7,17 +7,17 @@ namespace Creaturelib.Generated
     internal static class BattleRandom
     {
         /// <returns>BattleRandom *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="seed">long unsigned int</param>
         /// <returns>BattleRandom *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_ConstructWithSeed")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_ConstructWithSeed")]
         internal static extern IntPtr ConstructWithSeed(ulong seed);
 
         /// <param name="p">BattleRandom *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">bool &</param>
@@ -26,30 +26,30 @@ namespace Creaturelib.Generated
         /// <param name="attack">ExecutingAttack *</param>
         /// <param name="target">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_EffectChance")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_EffectChance")]
         internal static extern byte EffectChance(ref byte @out, IntPtr p, float chance, IntPtr attack, IntPtr target);
 
         /// <param name="p">BattleRandom *</param>
         /// <returns>int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Get")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Get")]
         internal static extern int Get(IntPtr p);
 
         /// <param name="p">BattleRandom *</param>
         /// <param name="max">int</param>
         /// <returns>int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_GetMax")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_GetMax")]
         internal static extern int GetMax(IntPtr p, int max);
 
         /// <param name="p">BattleRandom *</param>
         /// <param name="min">int</param>
         /// <param name="max">int</param>
         /// <returns>int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_GetMinMax")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_GetMinMax")]
         internal static extern int GetMinMax(IntPtr p, int min, int max);
 
         /// <param name="p">BattleRandom *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_GetSeed")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_GetSeed")]
         internal static extern ulong GetSeed(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/BattleSide.cs b/PkmnLibSharp/Generated/Creaturelib/BattleSide.cs
index 30a2f8d..c72f029 100644
--- a/PkmnLibSharp/Generated/Creaturelib/BattleSide.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/BattleSide.cs
@@ -10,81 +10,81 @@ namespace Creaturelib.Generated
         /// <param name="battle">Battle *</param>
         /// <param name="creaturesPerSide">unsigned char</param>
         /// <returns>BattleSide *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_Construct")]
         internal static extern IntPtr Construct(byte index, IntPtr battle, byte creaturesPerSide);
 
         /// <param name="p">BattleSide *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">BattleSide *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_AllChoicesSet")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_AllChoicesSet")]
         internal static extern byte AllChoicesSet(IntPtr p);
 
         /// <param name="out">bool &</param>
         /// <param name="p">BattleSide *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_AllPossibleSlotsFilled")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_AllPossibleSlotsFilled")]
         internal static extern byte AllPossibleSlotsFilled(ref byte @out, IntPtr p);
 
         /// <param name="p">BattleSide *</param>
         /// <param name="choice">BaseTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_SetChoice")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_SetChoice")]
         internal static extern byte SetChoice(IntPtr p, IntPtr choice);
 
         /// <param name="p">BattleSide *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_ResetChoices")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_ResetChoices")]
         internal static extern void ResetChoices(IntPtr p);
 
         /// <param name="p">BattleSide *</param>
         /// <param name="creature">Creature *</param>
         /// <param name="index">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_SetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_SetCreature")]
         internal static extern byte SetCreature(IntPtr p, IntPtr creature, byte index);
 
         /// <param name="out">Creature * &</param>
         /// <param name="p">BattleSide *</param>
         /// <param name="index">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_GetCreature")]
         internal static extern byte GetCreature(ref IntPtr @out, IntPtr p, byte index);
 
         /// <param name="p">BattleSide *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_GetSideIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_GetSideIndex")]
         internal static extern byte GetSideIndex(IntPtr p);
 
         /// <param name="out">unsigned char &</param>
         /// <param name="p">BattleSide *</param>
         /// <param name="c">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_GetCreatureIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_GetCreatureIndex")]
         internal static extern byte GetCreatureIndex(ref byte @out, IntPtr p, IntPtr c);
 
         /// <param name="p">BattleSide *</param>
         /// <param name="c">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_MarkSlotAsUnfillable")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_MarkSlotAsUnfillable")]
         internal static extern byte MarkSlotAsUnfillable(IntPtr p, IntPtr c);
 
         /// <param name="p">BattleSide *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_IsDefeated")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_IsDefeated")]
         internal static extern byte IsDefeated(IntPtr p);
 
         /// <param name="p">BattleSide *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_HasFled")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_HasFled")]
         internal static extern byte HasFled(IntPtr p);
 
         /// <param name="p">BattleSide *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_MarkAsFled")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_MarkAsFled")]
         internal static extern void MarkAsFled(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/BattleStatCalculator.cs b/PkmnLibSharp/Generated/Creaturelib/BattleStatCalculator.cs
index 200a7cd..cbe92ef 100644
--- a/PkmnLibSharp/Generated/Creaturelib/BattleStatCalculator.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/BattleStatCalculator.cs
@@ -7,12 +7,12 @@ namespace Creaturelib.Generated
     internal static class BattleStatCalculator
     {
         /// <returns>const BattleStatCalculator *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">const BattleStatCalculator *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">unsigned int &</param>
@@ -20,7 +20,7 @@ namespace Creaturelib.Generated
         /// <param name="creature">Creature *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_CalculateFlatStat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_CalculateFlatStat")]
         internal static extern byte CalculateFlatStat(ref uint @out, IntPtr p, IntPtr creature, Statistic stat);
 
         /// <param name="out">unsigned int &</param>
@@ -28,7 +28,7 @@ namespace Creaturelib.Generated
         /// <param name="creature">Creature *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_CalculateBoostedStat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_CalculateBoostedStat")]
         internal static extern byte CalculateBoostedStat(ref uint @out, IntPtr p, IntPtr creature, Statistic stat);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/C.cs b/PkmnLibSharp/Generated/Creaturelib/C.cs
index 6cb534d..1bd787c 100644
--- a/PkmnLibSharp/Generated/Creaturelib/C.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/C.cs
@@ -7,11 +7,11 @@ namespace Creaturelib.Generated
     internal static class C
     {
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_C_GetLastException")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_C_GetLastException")]
         internal static extern IntPtr GetLastException();
 
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_C_GetLastExceptionStacktrace")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_C_GetLastExceptionStacktrace")]
         internal static extern IntPtr GetLastExceptionStacktrace();
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ChangeSpeciesEvent.cs b/PkmnLibSharp/Generated/Creaturelib/ChangeSpeciesEvent.cs
index c82e6af..9d44061 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ChangeSpeciesEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ChangeSpeciesEvent.cs
@@ -8,17 +8,17 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const ChangeSpeciesEvent *</param>
         /// <returns>const Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeSpeciesEvent_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeSpeciesEvent_GetCreature")]
         internal static extern IntPtr GetCreature(IntPtr p);
 
         /// <param name="p">const ChangeSpeciesEvent *</param>
         /// <returns>const CreatureSpecies *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeSpeciesEvent_GetNewSpecies")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeSpeciesEvent_GetNewSpecies")]
         internal static extern IntPtr GetNewSpecies(IntPtr p);
 
         /// <param name="p">const ChangeSpeciesEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeSpeciesEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeSpeciesEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ChangeVariantEvent.cs b/PkmnLibSharp/Generated/Creaturelib/ChangeVariantEvent.cs
index 959b4a6..e79b502 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ChangeVariantEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ChangeVariantEvent.cs
@@ -8,17 +8,17 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const ChangeVariantEvent *</param>
         /// <returns>const Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeVariantEvent_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeVariantEvent_GetCreature")]
         internal static extern IntPtr GetCreature(IntPtr p);
 
         /// <param name="p">const ChangeVariantEvent *</param>
         /// <returns>const SpeciesVariant *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeVariantEvent_GetNewVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeVariantEvent_GetNewVariant")]
         internal static extern IntPtr GetNewVariant(IntPtr p);
 
         /// <param name="p">const ChangeVariantEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeVariantEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ChangeVariantEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/Creature.cs b/PkmnLibSharp/Generated/Creaturelib/Creature.cs
index 3877f81..5b5a71a 100644
--- a/PkmnLibSharp/Generated/Creaturelib/Creature.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/Creature.cs
@@ -23,323 +23,323 @@ namespace Creaturelib.Generated
         /// <param name="attacksNum">long unsigned int</param>
         /// <param name="allowedExperienceGain">bool</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr library, IntPtr species, IntPtr variant, byte level, uint experience, uint uid, Gender gender, byte coloring, IntPtr heldItem, IntPtr nickname, byte secretTalent, byte talent, IntPtr attacks, ulong attacksNum, byte allowedExperienceGain);
 
         /// <param name="p">const Creature *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Initialize")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Initialize")]
         internal static extern byte Initialize(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>const BattleLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetLibrary")]
         internal static extern IntPtr GetLibrary(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>const CreatureSpecies *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetSpecies")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetSpecies")]
         internal static extern IntPtr GetSpecies(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>const SpeciesVariant *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetVariant")]
         internal static extern IntPtr GetVariant(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="species">const CreatureSpecies *</param>
         /// <param name="variant">const SpeciesVariant *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeSpecies")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeSpecies")]
         internal static extern byte ChangeSpecies(IntPtr p, IntPtr species, IntPtr variant);
 
         /// <param name="p">Creature *</param>
         /// <param name="variant">const SpeciesVariant *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeVariant")]
         internal static extern byte ChangeVariant(IntPtr p, IntPtr variant);
 
         /// <param name="p">const Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetLevel")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetLevel")]
         internal static extern byte GetLevel(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetExperience")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetExperience")]
         internal static extern uint GetExperience(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetUniqueIdentifier")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetUniqueIdentifier")]
         internal static extern uint GetUniqueIdentifier(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>Gender</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetGender")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetGender")]
         internal static extern Gender GetGender(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetColoring")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetColoring")]
         internal static extern byte GetColoring(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <param name="name">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasHeldItem")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasHeldItem")]
         internal static extern byte HasHeldItem(IntPtr p, IntPtr name);
 
         /// <param name="p">const Creature *</param>
         /// <param name="hash">unsigned int</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasHeldItemWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasHeldItemWithHash")]
         internal static extern byte HasHeldItemWithHash(IntPtr p, uint hash);
 
         /// <param name="p">const Creature *</param>
         /// <returns>const Item *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetHeldItem")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetHeldItem")]
         internal static extern IntPtr GetHeldItem(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="name">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetHeldItem")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetHeldItem")]
         internal static extern byte SetHeldItem(IntPtr p, IntPtr name);
 
         /// <param name="p">Creature *</param>
         /// <param name="hash">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetHeldItemWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetHeldItemWithHash")]
         internal static extern byte SetHeldItemWithHash(IntPtr p, uint hash);
 
         /// <param name="p">Creature *</param>
         /// <param name="item">const Item *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetHeldItemFromItem")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetHeldItemFromItem")]
         internal static extern void SetHeldItemFromItem(IntPtr p, IntPtr item);
 
         /// <param name="p">const Creature *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetCurrentHealth")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetCurrentHealth")]
         internal static extern uint GetCurrentHealth(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>Battle *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBattle")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBattle")]
         internal static extern IntPtr GetBattle(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>BattleSide *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBattleSide")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBattleSide")]
         internal static extern IntPtr GetBattleSide(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_IsOnBattleField")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_IsOnBattleField")]
         internal static extern byte IsOnBattleField(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetNickname")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetNickname")]
         internal static extern IntPtr GetNickname(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="type">unsigned char</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasType")]
         internal static extern byte HasType(IntPtr p, byte type);
 
         /// <param name="p">const Creature *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetMaxHealth")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetMaxHealth")]
         internal static extern uint GetMaxHealth(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="level">signed char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeLevelBy")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeLevelBy")]
         internal static extern byte ChangeLevelBy(IntPtr p, sbyte level);
 
         /// <param name="p">Creature *</param>
         /// <param name="damage">unsigned int</param>
         /// <param name="source">DamageSource</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Damage")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Damage")]
         internal static extern byte Damage(IntPtr p, uint damage, DamageSource source);
 
         /// <param name="p">Creature *</param>
         /// <param name="health">unsigned int</param>
         /// <param name="canRevive">bool</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Heal")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Heal")]
         internal static extern byte Heal(IntPtr p, uint health, byte canRevive);
 
         /// <param name="p">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_RestoreAllAttackUses")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_RestoreAllAttackUses")]
         internal static extern byte RestoreAllAttackUses(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetRealTalentIsSecret")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetRealTalentIsSecret")]
         internal static extern byte GetRealTalentIsSecret(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetRealTalentIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetRealTalentIndex")]
         internal static extern byte GetRealTalentIndex(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <param name="out">const char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetActiveTalent")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetActiveTalent")]
         internal static extern byte GetActiveTalent(IntPtr p, ref IntPtr @out);
 
         /// <param name="p">Creature *</param>
         /// <param name="talent">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_OverrideActiveTalent")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_OverrideActiveTalent")]
         internal static extern byte OverrideActiveTalent(IntPtr p, IntPtr talent);
 
         /// <param name="p">Creature *</param>
         /// <param name="experience">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddExperience")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddExperience")]
         internal static extern byte AddExperience(IntPtr p, uint experience);
 
         /// <param name="p">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ClearVolatileScripts")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ClearVolatileScripts")]
         internal static extern byte ClearVolatileScripts(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="scriptName">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddVolatileScriptByName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddVolatileScriptByName")]
         internal static extern byte AddVolatileScriptByName(IntPtr p, IntPtr scriptName);
 
         /// <param name="p">Creature *</param>
         /// <param name="script">Script *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddVolatileScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddVolatileScript")]
         internal static extern byte AddVolatileScript(IntPtr p, IntPtr script);
 
         /// <param name="p">Creature *</param>
         /// <param name="scriptName">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_RemoveVolatileScriptByName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_RemoveVolatileScriptByName")]
         internal static extern byte RemoveVolatileScriptByName(IntPtr p, IntPtr scriptName);
 
         /// <param name="p">Creature *</param>
         /// <param name="script">Script *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_RemoveVolatileScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_RemoveVolatileScript")]
         internal static extern byte RemoveVolatileScript(IntPtr p, IntPtr script);
 
         /// <param name="p">Creature *</param>
         /// <param name="scriptName">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasVolatileScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasVolatileScript")]
         internal static extern byte HasVolatileScript(IntPtr p, IntPtr scriptName);
 
         /// <param name="p">Creature *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttacksCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttacksCount")]
         internal static extern ulong GetAttacksCount(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <returns>const LearnedAttack * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttacks")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttacks")]
         internal static extern IntPtr GetAttacks(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="scriptName">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasAttack")]
         internal static extern byte HasAttack(IntPtr p, IntPtr scriptName);
 
         /// <param name="p">const Creature *</param>
         /// <returns>const CreatureSpecies *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetDisplaySpecies")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetDisplaySpecies")]
         internal static extern IntPtr GetDisplaySpecies(IntPtr p);
 
         /// <param name="p">const Creature *</param>
         /// <returns>const SpeciesVariant *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetDisplayVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetDisplayVariant")]
         internal static extern IntPtr GetDisplayVariant(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="species">const CreatureSpecies *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetDisplaySpecies")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetDisplaySpecies")]
         internal static extern void SetDisplaySpecies(IntPtr p, IntPtr species);
 
         /// <param name="p">Creature *</param>
         /// <param name="variant">const SpeciesVariant *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetDisplayVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetDisplayVariant")]
         internal static extern void SetDisplayVariant(IntPtr p, IntPtr variant);
 
         /// <param name="p">Creature *</param>
         /// <param name="stat">Statistic</param>
         /// <param name="diffAmount">signed char</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeStatBoost")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ChangeStatBoost")]
         internal static extern void ChangeStatBoost(IntPtr p, Statistic stat, sbyte diffAmount);
 
         /// <param name="p">Creature *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetFlatStat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetFlatStat")]
         internal static extern uint GetFlatStat(IntPtr p, Statistic stat);
 
         /// <param name="p">Creature *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBoostedStat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBoostedStat")]
         internal static extern uint GetBoostedStat(IntPtr p, Statistic stat);
 
         /// <param name="p">Creature *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBaseStat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBaseStat")]
         internal static extern uint GetBaseStat(IntPtr p, Statistic stat);
 
         /// <param name="p">Creature *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>signed char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetStatBoost")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetStatBoost")]
         internal static extern sbyte GetStatBoost(IntPtr p, Statistic stat);
 
         /// <param name="p">const Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAvailableAttackSlot")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAvailableAttackSlot")]
         internal static extern byte GetAvailableAttackSlot(IntPtr p);
 
         /// <param name="p">Creature *</param>
         /// <param name="attack">LearnedAttack *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddAttack")]
         internal static extern byte AddAttack(IntPtr p, IntPtr attack);
 
         /// <param name="p">Creature *</param>
         /// <param name="index">long unsigned int</param>
         /// <param name="attack">LearnedAttack *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ReplaceAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_ReplaceAttack")]
         internal static extern byte ReplaceAttack(IntPtr p, ulong index, IntPtr attack);
 
         /// <param name="p">Creature *</param>
         /// <param name="a">long unsigned int</param>
         /// <param name="b">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SwapAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SwapAttack")]
         internal static extern byte SwapAttack(IntPtr p, ulong a, ulong b);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/CreatureParty.cs b/PkmnLibSharp/Generated/Creaturelib/CreatureParty.cs
index 7ca870a..14a2472 100644
--- a/PkmnLibSharp/Generated/Creaturelib/CreatureParty.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/CreatureParty.cs
@@ -8,37 +8,37 @@ namespace Creaturelib.Generated
     {
         /// <param name="size">long unsigned int</param>
         /// <returns>CreatureParty *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_ConstructWithSize")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_ConstructWithSize")]
         internal static extern IntPtr ConstructWithSize(ulong size);
 
         /// <param name="creatures">Creature * *</param>
         /// <param name="size">long unsigned int</param>
         /// <returns>CreatureParty *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_ConstructFromArray")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_ConstructFromArray")]
         internal static extern IntPtr ConstructFromArray(IntPtr creatures, ulong size);
 
         /// <param name="p">const CreatureParty *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">Creature * &</param>
         /// <param name="p">const CreatureParty *</param>
         /// <param name="index">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetAtIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetAtIndex")]
         internal static extern byte GetAtIndex(ref IntPtr @out, IntPtr p, ulong index);
 
         /// <param name="p">CreatureParty *</param>
         /// <param name="a">long unsigned int</param>
         /// <param name="b">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_Switch")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_Switch")]
         internal static extern byte Switch(IntPtr p, ulong a, ulong b);
 
         /// <param name="p">CreatureParty *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_PackParty")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_PackParty")]
         internal static extern byte PackParty(IntPtr p);
 
         /// <param name="out">Creature * &</param>
@@ -46,22 +46,22 @@ namespace Creaturelib.Generated
         /// <param name="index">long unsigned int</param>
         /// <param name="creature">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_SwapInto")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_SwapInto")]
         internal static extern byte SwapInto(ref IntPtr @out, IntPtr p, ulong index, IntPtr creature);
 
         /// <param name="p">const CreatureParty *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_HasAvailableCreatures")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_HasAvailableCreatures")]
         internal static extern byte HasAvailableCreatures(IntPtr p);
 
         /// <param name="p">const CreatureParty *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetLength")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetLength")]
         internal static extern ulong GetLength(IntPtr p);
 
         /// <param name="p">CreatureParty *</param>
         /// <returns>const Creature * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetParty")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetParty")]
         internal static extern IntPtr GetParty(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/CreatureSpecies.cs b/PkmnLibSharp/Generated/Creaturelib/CreatureSpecies.cs
index 01a2316..97192c1 100644
--- a/PkmnLibSharp/Generated/Creaturelib/CreatureSpecies.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/CreatureSpecies.cs
@@ -16,106 +16,106 @@ namespace Creaturelib.Generated
         /// <param name="flags">const char * *</param>
         /// <param name="flagsCount">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_Construct")]
         internal static extern byte Construct(ref IntPtr @out, ushort id, IntPtr name, IntPtr defaultVariant, float genderRatio, IntPtr growthRate, byte captureRate, IntPtr flags, ulong flagsCount);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <returns>unsigned short</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetId")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetId")]
         internal static extern ushort GetId(IntPtr p);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <returns>float</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetGenderRate")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetGenderRate")]
         internal static extern float GetGenderRate(IntPtr p);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetCaptureRate")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetCaptureRate")]
         internal static extern byte GetCaptureRate(IntPtr p);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetName")]
         internal static extern IntPtr GetName(IntPtr p);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetGrowthRate")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetGrowthRate")]
         internal static extern IntPtr GetGrowthRate(IntPtr p);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <param name="name">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_HasVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_HasVariant")]
         internal static extern byte HasVariant(IntPtr p, IntPtr name);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <param name="hash">unsigned int</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_HasVariantWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_HasVariantWithHash")]
         internal static extern byte HasVariantWithHash(IntPtr p, uint hash);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const SpeciesVariant * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_TryGetVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_TryGetVariant")]
         internal static extern byte TryGetVariant(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <param name="hash">unsigned int</param>
         /// <param name="out">const SpeciesVariant * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_TryGetVariantWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_TryGetVariantWithHash")]
         internal static extern byte TryGetVariantWithHash(IntPtr p, uint hash, ref IntPtr @out);
 
         /// <param name="out">const SpeciesVariant * &</param>
         /// <param name="p">const CreatureSpecies *</param>
         /// <param name="name">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariant")]
         internal static extern byte GetVariant(ref IntPtr @out, IntPtr p, IntPtr name);
 
         /// <param name="out">const SpeciesVariant * &</param>
         /// <param name="p">const CreatureSpecies *</param>
         /// <param name="hash">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariantWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariantWithHash")]
         internal static extern byte GetVariantWithHash(ref IntPtr @out, IntPtr p, uint hash);
 
         /// <param name="p">CreatureSpecies *</param>
         /// <param name="name">const char *</param>
         /// <param name="variant">SpeciesVariant *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_SetVariant")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_SetVariant")]
         internal static extern byte SetVariant(IntPtr p, IntPtr name, IntPtr variant);
 
         /// <param name="p">CreatureSpecies *</param>
         /// <param name="random">Random *</param>
         /// <returns>Gender</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetRandomGender")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetRandomGender")]
         internal static extern Gender GetRandomGender(IntPtr p, IntPtr random);
 
         /// <param name="p">CreatureSpecies *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariantsCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariantsCount")]
         internal static extern ulong GetVariantsCount(IntPtr p);
 
         /// <param name="p">CreatureSpecies *</param>
         /// <returns>const const SpeciesVariant * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariants")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariants")]
         internal static extern IntPtr GetVariants(IntPtr p);
 
         /// <param name="p">const CreatureSpecies *</param>
         /// <param name="key">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_HasFlag")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_HasFlag")]
         internal static extern byte HasFlag(IntPtr p, IntPtr key);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/DamageEvent.cs b/PkmnLibSharp/Generated/Creaturelib/DamageEvent.cs
index 62ecb26..9a08929 100644
--- a/PkmnLibSharp/Generated/Creaturelib/DamageEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/DamageEvent.cs
@@ -8,27 +8,27 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const DamageEvent *</param>
         /// <returns>Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetCreature")]
         internal static extern IntPtr GetCreature(IntPtr p);
 
         /// <param name="p">const DamageEvent *</param>
         /// <returns>DamageSource</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetDamageSource")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetDamageSource")]
         internal static extern DamageSource GetDamageSource(IntPtr p);
 
         /// <param name="p">const DamageEvent *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetOriginalHealth")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetOriginalHealth")]
         internal static extern uint GetOriginalHealth(IntPtr p);
 
         /// <param name="p">const DamageEvent *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetNewHealth")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetNewHealth")]
         internal static extern uint GetNewHealth(IntPtr p);
 
         /// <param name="p">const DamageEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/DamageLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/DamageLibrary.cs
index 5bf64a6..6422f83 100644
--- a/PkmnLibSharp/Generated/Creaturelib/DamageLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/DamageLibrary.cs
@@ -7,12 +7,12 @@ namespace Creaturelib.Generated
     internal static class DamageLibrary
     {
         /// <returns>const DamageLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">const DamageLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">unsigned int &</param>
@@ -22,7 +22,7 @@ namespace Creaturelib.Generated
         /// <param name="hitIndex">unsigned char</param>
         /// <param name="hitData">HitData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetDamage")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetDamage")]
         internal static extern byte GetDamage(ref uint @out, IntPtr p, IntPtr attack, IntPtr target, byte hitIndex, IntPtr hitData);
 
         /// <param name="out">unsigned char &</param>
@@ -32,7 +32,7 @@ namespace Creaturelib.Generated
         /// <param name="hitIndex">unsigned char</param>
         /// <param name="hitData">HitData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetBasePower")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetBasePower")]
         internal static extern byte GetBasePower(ref byte @out, IntPtr p, IntPtr attack, IntPtr target, byte hitIndex, IntPtr hitData);
 
         /// <param name="out">float &</param>
@@ -42,7 +42,7 @@ namespace Creaturelib.Generated
         /// <param name="hitIndex">unsigned char</param>
         /// <param name="hitData">HitData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetStatModifier")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetStatModifier")]
         internal static extern byte GetStatModifier(ref float @out, IntPtr p, IntPtr attack, IntPtr target, byte hitIndex, IntPtr hitData);
 
         /// <param name="out">float &</param>
@@ -52,7 +52,7 @@ namespace Creaturelib.Generated
         /// <param name="hitIndex">unsigned char</param>
         /// <param name="hitData">HitData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetDamageModifier")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetDamageModifier")]
         internal static extern byte GetDamageModifier(ref float @out, IntPtr p, IntPtr attack, IntPtr target, byte hitIndex, IntPtr hitData);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/DataLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/DataLibrary.cs
index 70eee04..916efd9 100644
--- a/PkmnLibSharp/Generated/Creaturelib/DataLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/DataLibrary.cs
@@ -14,42 +14,42 @@ namespace Creaturelib.Generated
         /// <param name="growthRates">GrowthRateLibrary *</param>
         /// <param name="typeLibrary">TypeLibrary *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr settings, IntPtr species, IntPtr attacks, IntPtr items, IntPtr growthRates, IntPtr typeLibrary);
 
         /// <param name="p">const DataLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const DataLibrary *</param>
         /// <returns>const LibrarySettings *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetSettings")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetSettings")]
         internal static extern IntPtr GetSettings(IntPtr p);
 
         /// <param name="p">const DataLibrary *</param>
         /// <returns>const SpeciesLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetSpeciesLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetSpeciesLibrary")]
         internal static extern IntPtr GetSpeciesLibrary(IntPtr p);
 
         /// <param name="p">const DataLibrary *</param>
         /// <returns>const AttackLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetAttackLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetAttackLibrary")]
         internal static extern IntPtr GetAttackLibrary(IntPtr p);
 
         /// <param name="p">const DataLibrary *</param>
         /// <returns>const ItemLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetItemLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetItemLibrary")]
         internal static extern IntPtr GetItemLibrary(IntPtr p);
 
         /// <param name="p">const DataLibrary *</param>
         /// <returns>const GrowthRateLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetGrowthRates")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetGrowthRates")]
         internal static extern IntPtr GetGrowthRates(IntPtr p);
 
         /// <param name="p">const DataLibrary *</param>
         /// <returns>const TypeLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetTypeLibrary")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DataLibrary_GetTypeLibrary")]
         internal static extern IntPtr GetTypeLibrary(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/DisplayTextEvent.cs b/PkmnLibSharp/Generated/Creaturelib/DisplayTextEvent.cs
index aa04e1e..b155faa 100644
--- a/PkmnLibSharp/Generated/Creaturelib/DisplayTextEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/DisplayTextEvent.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const DisplayTextEvent *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DisplayTextEvent_GetText")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DisplayTextEvent_GetText")]
         internal static extern IntPtr GetText(IntPtr p);
 
         /// <param name="p">const DisplayTextEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DisplayTextEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DisplayTextEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/EffectParameter.cs b/PkmnLibSharp/Generated/Creaturelib/EffectParameter.cs
index 07956a0..426b071 100644
--- a/PkmnLibSharp/Generated/Creaturelib/EffectParameter.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/EffectParameter.cs
@@ -8,56 +8,56 @@ namespace Creaturelib.Generated
     {
         /// <param name="b">bool</param>
         /// <returns>EffectParameter *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromBool")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromBool")]
         internal static extern IntPtr FromBool(byte b);
 
         /// <param name="i">long int</param>
         /// <returns>EffectParameter *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromInt")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromInt")]
         internal static extern IntPtr FromInt(long i);
 
         /// <param name="f">float</param>
         /// <returns>EffectParameter *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromFloat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromFloat")]
         internal static extern IntPtr FromFloat(float f);
 
         /// <param name="c">const char *</param>
         /// <returns>EffectParameter *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromString")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_FromString")]
         internal static extern IntPtr FromString(IntPtr c);
 
         /// <param name="p">const EffectParameter *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const EffectParameter *</param>
         /// <returns>EffectParameterType</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_GetType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_GetType")]
         internal static extern EffectParameterType GetType(IntPtr p);
 
         /// <param name="p">const EffectParameter *</param>
         /// <param name="out">bool &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsBool")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsBool")]
         internal static extern byte AsBool(IntPtr p, ref byte @out);
 
         /// <param name="p">const EffectParameter *</param>
         /// <param name="out">long int &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsInt")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsInt")]
         internal static extern byte AsInt(IntPtr p, ref long @out);
 
         /// <param name="p">const EffectParameter *</param>
         /// <param name="out">float &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsFloat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsFloat")]
         internal static extern byte AsFloat(IntPtr p, ref float @out);
 
         /// <param name="p">const EffectParameter *</param>
         /// <param name="out">const char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsString")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EffectParameter_AsString")]
         internal static extern byte AsString(IntPtr p, ref IntPtr @out);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/EventData.cs b/PkmnLibSharp/Generated/Creaturelib/EventData.cs
index d40808c..b9bafaf 100644
--- a/PkmnLibSharp/Generated/Creaturelib/EventData.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/EventData.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const EventData *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EventData_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EventData_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const EventData *</param>
         /// <returns>EventDataKind</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EventData_GetKind")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_EventData_GetKind")]
         internal static extern EventDataKind GetKind(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ExecutingAttack.cs b/PkmnLibSharp/Generated/Creaturelib/ExecutingAttack.cs
index 59355a8..4072297 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ExecutingAttack.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ExecutingAttack.cs
@@ -14,17 +14,17 @@ namespace Creaturelib.Generated
         /// <param name="attack">LearnedAttack *</param>
         /// <param name="script">Script *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr targets, ulong targetCount, byte numberHits, IntPtr user, IntPtr attack, IntPtr script);
 
         /// <param name="p">ExecutingAttack *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const ExecutingAttack *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetNumberOfHits")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetNumberOfHits")]
         internal static extern byte GetNumberOfHits(IntPtr p);
 
         /// <param name="out">HitData * &</param>
@@ -32,33 +32,33 @@ namespace Creaturelib.Generated
         /// <param name="target">Creature *</param>
         /// <param name="hit">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetHitData")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetHitData")]
         internal static extern byte GetHitData(ref IntPtr @out, IntPtr p, IntPtr target, byte hit);
 
         /// <param name="p">ExecutingAttack *</param>
         /// <param name="target">Creature *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_IsCreatureTarget")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_IsCreatureTarget")]
         internal static extern byte IsCreatureTarget(IntPtr p, IntPtr target);
 
         /// <param name="p">ExecutingAttack *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetTargetCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetTargetCount")]
         internal static extern byte GetTargetCount(IntPtr p);
 
         /// <param name="p">ExecutingAttack *</param>
         /// <returns>const const Creature * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetTargets")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetTargets")]
         internal static extern IntPtr GetTargets(IntPtr p);
 
         /// <param name="p">ExecutingAttack *</param>
         /// <returns>Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetUser")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetUser")]
         internal static extern IntPtr GetUser(IntPtr p);
 
         /// <param name="p">ExecutingAttack *</param>
         /// <returns>LearnedAttack *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExecutingAttack_GetAttack")]
         internal static extern IntPtr GetAttack(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ExperienceGainEvent.cs b/PkmnLibSharp/Generated/Creaturelib/ExperienceGainEvent.cs
index 6d4af71..f44e48c 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ExperienceGainEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ExperienceGainEvent.cs
@@ -8,22 +8,22 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const ExperienceGainEvent *</param>
         /// <returns>const Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_GetCreature")]
         internal static extern IntPtr GetCreature(IntPtr p);
 
         /// <param name="p">const ExperienceGainEvent *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_GetPreviousExperience")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_GetPreviousExperience")]
         internal static extern uint GetPreviousExperience(IntPtr p);
 
         /// <param name="p">const ExperienceGainEvent *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_GetNewExperience")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_GetNewExperience")]
         internal static extern uint GetNewExperience(IntPtr p);
 
         /// <param name="p">const ExperienceGainEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceGainEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ExperienceLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/ExperienceLibrary.cs
index f367c92..367f068 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ExperienceLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ExperienceLibrary.cs
@@ -7,12 +7,12 @@ namespace Creaturelib.Generated
     internal static class ExperienceLibrary
     {
         /// <returns>const ExperienceLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceLibrary_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">const ExperienceLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const ExperienceLibrary *</param>
@@ -20,7 +20,7 @@ namespace Creaturelib.Generated
         /// <param name="opponents">Creature * *</param>
         /// <param name="opponentsCount">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceLibrary_HandleExperienceGain")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExperienceLibrary_HandleExperienceGain")]
         internal static extern byte HandleExperienceGain(IntPtr p, IntPtr faintedMon, IntPtr opponents, ulong opponentsCount);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ExternGrowthRate.cs b/PkmnLibSharp/Generated/Creaturelib/ExternGrowthRate.cs
index 133cae9..fc719bc 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ExternGrowthRate.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ExternGrowthRate.cs
@@ -10,12 +10,12 @@ namespace Creaturelib.Generated
         /// <param name="calcLevel">Function *</param>
         /// <param name="calcExperience">Function *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExternGrowthRate_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExternGrowthRate_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr calcLevel, IntPtr calcExperience);
 
         /// <param name="p">const ExternGrowthRate *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExternGrowthRate_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ExternGrowthRate_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/FaintEvent.cs b/PkmnLibSharp/Generated/Creaturelib/FaintEvent.cs
index 2d3b930..21e850d 100644
--- a/PkmnLibSharp/Generated/Creaturelib/FaintEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/FaintEvent.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const FaintEvent *</param>
         /// <returns>Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FaintEvent_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FaintEvent_GetCreature")]
         internal static extern IntPtr GetCreature(IntPtr p);
 
         /// <param name="p">const FaintEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FaintEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FaintEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/FleeTurnChoice.cs b/PkmnLibSharp/Generated/Creaturelib/FleeTurnChoice.cs
index b834ea6..0345d88 100644
--- a/PkmnLibSharp/Generated/Creaturelib/FleeTurnChoice.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/FleeTurnChoice.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="user">Creature *</param>
         /// <returns>FleeTurnChoice *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FleeTurnChoice_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FleeTurnChoice_Construct")]
         internal static extern IntPtr Construct(IntPtr user);
 
         /// <param name="p">AttackTurnChoice *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FleeTurnChoice_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_FleeTurnChoice_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/GrowthRate.cs b/PkmnLibSharp/Generated/Creaturelib/GrowthRate.cs
index ebd0a10..a4b012f 100644
--- a/PkmnLibSharp/Generated/Creaturelib/GrowthRate.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/GrowthRate.cs
@@ -8,21 +8,21 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const GrowthRate *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRate_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRate_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">unsigned char &</param>
         /// <param name="p">const GrowthRate *</param>
         /// <param name="experience">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRate_CalculateLevel")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRate_CalculateLevel")]
         internal static extern byte CalculateLevel(ref byte @out, IntPtr p, uint experience);
 
         /// <param name="out">unsigned int &</param>
         /// <param name="p">const GrowthRate *</param>
         /// <param name="level">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRate_CalculateExperience")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRate_CalculateExperience")]
         internal static extern byte CalculateExperience(ref uint @out, IntPtr p, byte level);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/GrowthRateLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/GrowthRateLibrary.cs
index ffa1d15..f317e68 100644
--- a/PkmnLibSharp/Generated/Creaturelib/GrowthRateLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/GrowthRateLibrary.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="initialCapacity">long unsigned int</param>
         /// <returns>GrowthRateLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_Construct")]
         internal static extern IntPtr Construct(ulong initialCapacity);
 
         /// <param name="p">GrowthRateLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">unsigned char &</param>
@@ -21,7 +21,7 @@ namespace Creaturelib.Generated
         /// <param name="growthRate">const char *</param>
         /// <param name="experience">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateLevel")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateLevel")]
         internal static extern byte CalculateLevel(ref byte @out, IntPtr library, IntPtr growthRate, uint experience);
 
         /// <param name="out">unsigned char &</param>
@@ -29,7 +29,7 @@ namespace Creaturelib.Generated
         /// <param name="growthRateHash">unsigned int</param>
         /// <param name="experience">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateLevelWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateLevelWithHash")]
         internal static extern byte CalculateLevelWithHash(ref byte @out, IntPtr library, uint growthRateHash, uint experience);
 
         /// <param name="out">unsigned int &</param>
@@ -37,7 +37,7 @@ namespace Creaturelib.Generated
         /// <param name="growthRate">const char *</param>
         /// <param name="level">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateExperience")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateExperience")]
         internal static extern byte CalculateExperience(ref uint @out, IntPtr library, IntPtr growthRate, byte level);
 
         /// <param name="out">unsigned int &</param>
@@ -45,21 +45,21 @@ namespace Creaturelib.Generated
         /// <param name="growthRateHash">unsigned int</param>
         /// <param name="level">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash")]
         internal static extern byte CalculateExperienceWithHash(ref uint @out, IntPtr library, uint growthRateHash, byte level);
 
         /// <param name="library">GrowthRateLibrary *</param>
         /// <param name="growthRateName">const char *</param>
         /// <param name="growthRate">GrowthRate *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_AddGrowthRate")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_AddGrowthRate")]
         internal static extern byte AddGrowthRate(IntPtr library, IntPtr growthRateName, IntPtr growthRate);
 
         /// <param name="library">GrowthRateLibrary *</param>
         /// <param name="growthRateHash">unsigned int</param>
         /// <param name="growthRate">GrowthRate *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash")]
         internal static extern byte AddGrowthRateWithHash(IntPtr library, uint growthRateHash, IntPtr growthRate);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/HealEvent.cs b/PkmnLibSharp/Generated/Creaturelib/HealEvent.cs
index 4e1f523..002c02d 100644
--- a/PkmnLibSharp/Generated/Creaturelib/HealEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/HealEvent.cs
@@ -8,22 +8,22 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const HealEvent *</param>
         /// <returns>Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_GetCreature")]
         internal static extern IntPtr GetCreature(IntPtr p);
 
         /// <param name="p">const HealEvent *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_GetOriginalHealth")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_GetOriginalHealth")]
         internal static extern uint GetOriginalHealth(IntPtr p);
 
         /// <param name="p">const HealEvent *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_GetNewHealth")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_GetNewHealth")]
         internal static extern uint GetNewHealth(IntPtr p);
 
         /// <param name="p">const HealEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HealEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/HistoryElement.cs b/PkmnLibSharp/Generated/Creaturelib/HistoryElement.cs
index 3f3a9de..14ff420 100644
--- a/PkmnLibSharp/Generated/Creaturelib/HistoryElement.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/HistoryElement.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const HistoryElement *</param>
         /// <returns>HistoryElementKind</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryElement_GetKind")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryElement_GetKind")]
         internal static extern HistoryElementKind GetKind(IntPtr p);
 
         /// <param name="p">const HistoryElement *</param>
         /// <returns>const HistoryElement *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryElement_GetPrevious")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryElement_GetPrevious")]
         internal static extern IntPtr GetPrevious(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/HistoryHandler.cs b/PkmnLibSharp/Generated/Creaturelib/HistoryHandler.cs
index 53a5c41..9441a37 100644
--- a/PkmnLibSharp/Generated/Creaturelib/HistoryHandler.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/HistoryHandler.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const HistoryHolder *</param>
         /// <returns>const HistoryElement *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryHandler_GetTopElement")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryHandler_GetTopElement")]
         internal static extern IntPtr GetTopElement(IntPtr p);
 
         /// <param name="p">const HistoryHolder *</param>
         /// <returns>const HistoryElement *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryHandler_GetLastUsedAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HistoryHandler_GetLastUsedAttack")]
         internal static extern IntPtr GetLastUsedAttack(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/HitData.cs b/PkmnLibSharp/Generated/Creaturelib/HitData.cs
index b5ad32e..941be16 100644
--- a/PkmnLibSharp/Generated/Creaturelib/HitData.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/HitData.cs
@@ -8,57 +8,57 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const HitData *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_IsCritical")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_IsCritical")]
         internal static extern byte IsCritical(IntPtr p);
 
         /// <param name="p">const HitData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetBasePower")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetBasePower")]
         internal static extern byte GetBasePower(IntPtr p);
 
         /// <param name="p">const HitData *</param>
         /// <returns>float</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetEffectiveness")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetEffectiveness")]
         internal static extern float GetEffectiveness(IntPtr p);
 
         /// <param name="p">const HitData *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetDamage")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetDamage")]
         internal static extern uint GetDamage(IntPtr p);
 
         /// <param name="p">const HitData *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_GetType")]
         internal static extern byte GetType(IntPtr p);
 
         /// <param name="p">HitData *</param>
         /// <param name="val">bool</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetCritical")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetCritical")]
         internal static extern void SetCritical(IntPtr p, byte val);
 
         /// <param name="p">HitData *</param>
         /// <param name="val">unsigned char</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetBasePower")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetBasePower")]
         internal static extern void SetBasePower(IntPtr p, byte val);
 
         /// <param name="p">HitData *</param>
         /// <param name="val">float</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetEffectiveness")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetEffectiveness")]
         internal static extern void SetEffectiveness(IntPtr p, float val);
 
         /// <param name="p">HitData *</param>
         /// <param name="val">unsigned int</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetDamage")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetDamage")]
         internal static extern void SetDamage(IntPtr p, uint val);
 
         /// <param name="p">HitData *</param>
         /// <param name="val">unsigned char</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_HitData_SetType")]
         internal static extern void SetType(IntPtr p, byte val);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/Item.cs b/PkmnLibSharp/Generated/Creaturelib/Item.cs
index 8085bb1..a0ab6b8 100644
--- a/PkmnLibSharp/Generated/Creaturelib/Item.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/Item.cs
@@ -13,38 +13,38 @@ namespace Creaturelib.Generated
         /// <param name="flags">const char * *</param>
         /// <param name="flagsCount">long unsigned int</param>
         /// <returns>Item *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_Construct")]
         internal static extern IntPtr Construct(IntPtr name, ItemCategory category, BattleItemCategory battleCategory, int price, IntPtr flags, ulong flagsCount);
 
         /// <param name="p">const Item *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const Item *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetName")]
         internal static extern IntPtr GetName(IntPtr p);
 
         /// <param name="p">const Item *</param>
         /// <returns>ItemCategory</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetCategory")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetCategory")]
         internal static extern ItemCategory GetCategory(IntPtr p);
 
         /// <param name="p">const Item *</param>
         /// <returns>BattleItemCategory</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetBattleCategory")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetBattleCategory")]
         internal static extern BattleItemCategory GetBattleCategory(IntPtr p);
 
         /// <param name="p">const Item *</param>
         /// <returns>int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetPrice")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_GetPrice")]
         internal static extern int GetPrice(IntPtr p);
 
         /// <param name="p">const Item *</param>
         /// <param name="key">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_HasFlag")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Item_HasFlag")]
         internal static extern byte HasFlag(IntPtr p, IntPtr key);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ItemLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/ItemLibrary.cs
index 98f8037..971acd0 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ItemLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ItemLibrary.cs
@@ -8,78 +8,78 @@ namespace Creaturelib.Generated
     {
         /// <param name="initialCapacity">long unsigned int</param>
         /// <returns>const ItemLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Construct")]
         internal static extern IntPtr Construct(ulong initialCapacity);
 
         /// <param name="p">const ItemLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="t">Item *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Insert")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Insert")]
         internal static extern byte Insert(IntPtr p, IntPtr name, IntPtr t);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="t">Item *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_InsertWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_InsertWithHash")]
         internal static extern byte InsertWithHash(IntPtr p, uint hashedKey, IntPtr t);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="name">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Delete")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Delete")]
         internal static extern byte Delete(IntPtr p, IntPtr name);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_DeleteWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_DeleteWithHash")]
         internal static extern byte DeleteWithHash(IntPtr p, uint hashedKey);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const Item * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_TryGet")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_TryGet")]
         internal static extern byte TryGet(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="out">const Item * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_TryGetWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_TryGetWithHash")]
         internal static extern byte TryGetWithHash(IntPtr p, uint hashedKey, ref IntPtr @out);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const Item * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Get")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_Get")]
         internal static extern byte Get(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="out">const Item * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_GetWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_GetWithHash")]
         internal static extern byte GetWithHash(IntPtr p, uint hashedKey, ref IntPtr @out);
 
         /// <param name="p">ItemLibrary *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_GetCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_GetCount")]
         internal static extern ulong GetCount(IntPtr p);
 
         /// <param name="p">ItemLibrary *</param>
         /// <param name="index">long unsigned int</param>
         /// <param name="out">const Item * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_GetAtIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ItemLibrary_GetAtIndex")]
         internal static extern byte GetAtIndex(IntPtr p, ulong index, ref IntPtr @out);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/LearnableAttacks.cs b/PkmnLibSharp/Generated/Creaturelib/LearnableAttacks.cs
index 915c7da..1ba2f88 100644
--- a/PkmnLibSharp/Generated/Creaturelib/LearnableAttacks.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/LearnableAttacks.cs
@@ -9,47 +9,47 @@ namespace Creaturelib.Generated
         /// <param name="out">LearnableAttacks * &</param>
         /// <param name="levelAttackCapacity">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_Construct")]
         internal static extern byte Construct(ref IntPtr @out, ulong levelAttackCapacity);
 
         /// <param name="p">LearnableAttacks *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">LearnableAttacks *</param>
         /// <param name="level">unsigned char</param>
         /// <param name="attack">const AttackData *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_AddLevelAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_AddLevelAttack")]
         internal static extern void AddLevelAttack(IntPtr p, byte level, IntPtr attack);
 
         /// <param name="p">LearnableAttacks *</param>
         /// <param name="level">unsigned char</param>
         /// <returns>const const AttackData * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetAttacksForLevel")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetAttacksForLevel")]
         internal static extern IntPtr GetAttacksForLevel(IntPtr p, byte level);
 
         /// <param name="p">LearnableAttacks *</param>
         /// <param name="level">unsigned char</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_HasAttacksForLevel")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_HasAttacksForLevel")]
         internal static extern byte HasAttacksForLevel(IntPtr p, byte level);
 
         /// <param name="p">LearnableAttacks *</param>
         /// <param name="level">unsigned char</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetAttacksForLevelCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetAttacksForLevelCount")]
         internal static extern ulong GetAttacksForLevelCount(IntPtr p, byte level);
 
         /// <param name="p">LearnableAttacks *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetDistinctLevelAttacksCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetDistinctLevelAttacksCount")]
         internal static extern ulong GetDistinctLevelAttacksCount(IntPtr p);
 
         /// <param name="p">LearnableAttacks *</param>
         /// <returns>const const AttackData * *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetDistinctLevelAttacks")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnableAttacks_GetDistinctLevelAttacks")]
         internal static extern IntPtr GetDistinctLevelAttacks(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/LearnedAttack.cs b/PkmnLibSharp/Generated/Creaturelib/LearnedAttack.cs
index 93b7452..166d0c5 100644
--- a/PkmnLibSharp/Generated/Creaturelib/LearnedAttack.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/LearnedAttack.cs
@@ -11,55 +11,55 @@ namespace Creaturelib.Generated
         /// <param name="maxUses">unsigned char</param>
         /// <param name="learnMethod">AttackLearnMethod</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr attack, byte maxUses, AttackLearnMethod learnMethod);
 
         /// <param name="p">LearnedAttack *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const LearnedAttack *</param>
         /// <returns>const AttackData *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetAttack")]
         internal static extern IntPtr GetAttack(IntPtr p);
 
         /// <param name="p">const LearnedAttack *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetMaxUses")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetMaxUses")]
         internal static extern byte GetMaxUses(IntPtr p);
 
         /// <param name="p">const LearnedAttack *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetRemainingUses")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetRemainingUses")]
         internal static extern byte GetRemainingUses(IntPtr p);
 
         /// <param name="p">const LearnedAttack *</param>
         /// <returns>AttackLearnMethod</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetLearnMethod")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_GetLearnMethod")]
         internal static extern AttackLearnMethod GetLearnMethod(IntPtr p);
 
         /// <param name="p">LearnedAttack *</param>
         /// <param name="uses">unsigned char</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_TryUse")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_TryUse")]
         internal static extern byte TryUse(IntPtr p, byte uses);
 
         /// <param name="p">LearnedAttack *</param>
         /// <param name="uses">unsigned char</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_DecreaseUses")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_DecreaseUses")]
         internal static extern void DecreaseUses(IntPtr p, byte uses);
 
         /// <param name="p">LearnedAttack *</param>
         /// <param name="uses">unsigned char</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_RestoreUses")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_RestoreUses")]
         internal static extern void RestoreUses(IntPtr p, byte uses);
 
         /// <param name="p">LearnedAttack *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_RestoreAllUses")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LearnedAttack_RestoreAllUses")]
         internal static extern void RestoreAllUses(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/LibrarySettings.cs b/PkmnLibSharp/Generated/Creaturelib/LibrarySettings.cs
index 27f7871..4d2e61c 100644
--- a/PkmnLibSharp/Generated/Creaturelib/LibrarySettings.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/LibrarySettings.cs
@@ -9,22 +9,22 @@ namespace Creaturelib.Generated
         /// <param name="maximalLevel">unsigned char</param>
         /// <param name="maximalMoves">unsigned char</param>
         /// <returns>const LibrarySettings *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_Construct")]
         internal static extern IntPtr Construct(byte maximalLevel, byte maximalMoves);
 
         /// <param name="p">const LibrarySettings *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const LibrarySettings *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_GetMaximalLevel")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_GetMaximalLevel")]
         internal static extern byte GetMaximalLevel(IntPtr p);
 
         /// <param name="p">const LibrarySettings *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_GetMaximalAttacks")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LibrarySettings_GetMaximalAttacks")]
         internal static extern byte GetMaximalAttacks(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/LookupGrowthRate.cs b/PkmnLibSharp/Generated/Creaturelib/LookupGrowthRate.cs
index e410eea..a027576 100644
--- a/PkmnLibSharp/Generated/Creaturelib/LookupGrowthRate.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/LookupGrowthRate.cs
@@ -9,12 +9,12 @@ namespace Creaturelib.Generated
         /// <param name="experiencePerLevel">unsigned int *</param>
         /// <param name="count">long unsigned int</param>
         /// <returns>GrowthRate *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LookupGrowthRate_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LookupGrowthRate_Construct")]
         internal static extern IntPtr Construct(IntPtr experiencePerLevel, ulong count);
 
         /// <param name="p">const LookupGrowthRate *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LookupGrowthRate_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_LookupGrowthRate_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/MiscLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/MiscLibrary.cs
index 79db629..ba0a063 100644
--- a/PkmnLibSharp/Generated/Creaturelib/MiscLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/MiscLibrary.cs
@@ -7,12 +7,12 @@ namespace Creaturelib.Generated
     internal static class MiscLibrary
     {
         /// <returns>MiscLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">const MiscLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">bool &</param>
@@ -21,14 +21,14 @@ namespace Creaturelib.Generated
         /// <param name="target">Creature *</param>
         /// <param name="hit">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_IsCritical")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_IsCritical")]
         internal static extern byte IsCritical(ref byte @out, IntPtr p, IntPtr attack, IntPtr target, byte hit);
 
         /// <param name="out">bool &</param>
         /// <param name="p">MiscLibrary *</param>
         /// <param name="switchChoice">FleeTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_CanFlee")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_CanFlee")]
         internal static extern byte CanFlee(ref byte @out, IntPtr p, IntPtr switchChoice);
 
         /// <param name="out">BaseTurnChoice * &</param>
@@ -37,7 +37,7 @@ namespace Creaturelib.Generated
         /// <param name="sideTarget">unsigned char</param>
         /// <param name="creatureTarget">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_ReplacementAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MiscLibrary_ReplacementAttack")]
         internal static extern byte ReplacementAttack(ref IntPtr @out, IntPtr p, IntPtr user, byte sideTarget, byte creatureTarget);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/MissEvent.cs b/PkmnLibSharp/Generated/Creaturelib/MissEvent.cs
index 886e153..a980968 100644
--- a/PkmnLibSharp/Generated/Creaturelib/MissEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/MissEvent.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const MissEvent *</param>
         /// <returns>const Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MissEvent_GetCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MissEvent_GetCreature")]
         internal static extern IntPtr GetCreature(IntPtr p);
 
         /// <param name="p">const MissEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MissEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_MissEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/PassTurnChoice.cs b/PkmnLibSharp/Generated/Creaturelib/PassTurnChoice.cs
index a10c7da..69b2ee4 100644
--- a/PkmnLibSharp/Generated/Creaturelib/PassTurnChoice.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/PassTurnChoice.cs
@@ -8,12 +8,12 @@ namespace Creaturelib.Generated
     {
         /// <param name="user">Creature *</param>
         /// <returns>PassTurnChoice *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_PassTurnChoice_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_PassTurnChoice_Construct")]
         internal static extern IntPtr Construct(IntPtr user);
 
         /// <param name="p">AttackTurnChoice *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_PassTurnChoice_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_PassTurnChoice_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/Script.cs b/PkmnLibSharp/Generated/Creaturelib/Script.cs
index c28bd3b..af1312b 100644
--- a/PkmnLibSharp/Generated/Creaturelib/Script.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/Script.cs
@@ -8,62 +8,62 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">Script *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">Script *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_Stack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_Stack")]
         internal static extern byte Stack(IntPtr p);
 
         /// <param name="p">Script *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnRemove")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnRemove")]
         internal static extern byte OnRemove(IntPtr p);
 
         /// <param name="p">Script *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_GetName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_GetName")]
         internal static extern IntPtr GetName(IntPtr p);
 
         /// <param name="p">Script *</param>
         /// <param name="choice">const BaseTurnChoice *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnBeforeTurn")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnBeforeTurn")]
         internal static extern byte OnBeforeTurn(IntPtr p, IntPtr choice);
 
         /// <param name="p">Script *</param>
         /// <param name="choice">AttackTurnChoice *</param>
         /// <param name="outAttack">const char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ChangeAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ChangeAttack")]
         internal static extern byte ChangeAttack(IntPtr p, IntPtr choice, ref IntPtr outAttack);
 
         /// <param name="p">Script *</param>
         /// <param name="attack">ExecutingAttack *</param>
         /// <param name="outResult">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_PreventAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_PreventAttack")]
         internal static extern byte PreventAttack(IntPtr p, IntPtr attack, IntPtr outResult);
 
         /// <param name="p">Script *</param>
         /// <param name="attack">ExecutingAttack *</param>
         /// <param name="outResult">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_FailAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_FailAttack")]
         internal static extern byte FailAttack(IntPtr p, IntPtr attack, IntPtr outResult);
 
         /// <param name="p">Script *</param>
         /// <param name="attack">ExecutingAttack *</param>
         /// <param name="outResult">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_StopBeforeAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_StopBeforeAttack")]
         internal static extern byte StopBeforeAttack(IntPtr p, IntPtr attack, IntPtr outResult);
 
         /// <param name="p">Script *</param>
         /// <param name="attack">ExecutingAttack *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnBeforeAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnBeforeAttack")]
         internal static extern byte OnBeforeAttack(IntPtr p, IntPtr attack);
 
         /// <param name="p">Script *</param>
@@ -71,7 +71,7 @@ namespace Creaturelib.Generated
         /// <param name="target">Creature *</param>
         /// <param name="outResult">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_FailIncomingAttack")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_FailIncomingAttack")]
         internal static extern byte FailIncomingAttack(IntPtr p, IntPtr attack, IntPtr target, IntPtr outResult);
 
         /// <param name="p">Script *</param>
@@ -79,14 +79,14 @@ namespace Creaturelib.Generated
         /// <param name="target">Creature *</param>
         /// <param name="outResult">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_IsInvulnerable")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_IsInvulnerable")]
         internal static extern byte IsInvulnerable(IntPtr p, IntPtr attack, IntPtr target, IntPtr outResult);
 
         /// <param name="p">Script *</param>
         /// <param name="attack">ExecutingAttack *</param>
         /// <param name="target">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnAttackMiss")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnAttackMiss")]
         internal static extern byte OnAttackMiss(IntPtr p, IntPtr attack, IntPtr target);
 
         /// <param name="p">Script *</param>
@@ -95,7 +95,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="outType">unsigned char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ChangeAttackType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ChangeAttackType")]
         internal static extern byte ChangeAttackType(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr outType);
 
         /// <param name="p">Script *</param>
@@ -104,7 +104,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="basePower">unsigned char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OverrideBasePower")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OverrideBasePower")]
         internal static extern byte OverrideBasePower(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr basePower);
 
         /// <param name="p">Script *</param>
@@ -113,7 +113,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="statsUser">Creature * *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ChangeDamageStatsUser")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ChangeDamageStatsUser")]
         internal static extern byte ChangeDamageStatsUser(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr statsUser);
 
         /// <param name="p">Script *</param>
@@ -122,7 +122,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="bypass">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_BypassDefensiveStat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_BypassDefensiveStat")]
         internal static extern byte BypassDefensiveStat(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr bypass);
 
         /// <param name="p">Script *</param>
@@ -131,7 +131,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="bypass">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_BypassOffensiveStat")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_BypassOffensiveStat")]
         internal static extern byte BypassOffensiveStat(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr bypass);
 
         /// <param name="p">Script *</param>
@@ -140,7 +140,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="modifier">float *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyStatModifier")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyStatModifier")]
         internal static extern byte ModifyStatModifier(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr modifier);
 
         /// <param name="p">Script *</param>
@@ -149,7 +149,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="modifier">float *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyDamageModifier")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyDamageModifier")]
         internal static extern byte ModifyDamageModifier(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr modifier);
 
         /// <param name="p">Script *</param>
@@ -158,7 +158,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="damage">unsigned int *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OverrideDamage")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OverrideDamage")]
         internal static extern byte OverrideDamage(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr damage);
 
         /// <param name="p">Script *</param>
@@ -167,7 +167,7 @@ namespace Creaturelib.Generated
         /// <param name="hitNumber">unsigned char</param>
         /// <param name="outResult">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_PreventSecondaryEffects")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_PreventSecondaryEffects")]
         internal static extern byte PreventSecondaryEffects(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber, IntPtr outResult);
 
         /// <param name="p">Script *</param>
@@ -175,21 +175,21 @@ namespace Creaturelib.Generated
         /// <param name="target">Creature *</param>
         /// <param name="hitNumber">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnSecondaryEffect")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnSecondaryEffect")]
         internal static extern byte OnSecondaryEffect(IntPtr p, IntPtr attack, IntPtr target, byte hitNumber);
 
         /// <param name="p">Script *</param>
         /// <param name="attack">ExecutingAttack *</param>
         /// <param name="target">Creature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnAfterHits")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_OnAfterHits")]
         internal static extern byte OnAfterHits(IntPtr p, IntPtr attack, IntPtr target);
 
         /// <param name="p">Script *</param>
         /// <param name="choice">const SwitchTurnChoice *</param>
         /// <param name="outResult">bool *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_PreventSelfSwitch")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_PreventSelfSwitch")]
         internal static extern byte PreventSelfSwitch(IntPtr p, IntPtr choice, IntPtr outResult);
 
         /// <param name="p">Script *</param>
@@ -197,7 +197,7 @@ namespace Creaturelib.Generated
         /// <param name="target">Creature *</param>
         /// <param name="chance">float *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyEffectChance")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyEffectChance")]
         internal static extern byte ModifyEffectChance(IntPtr p, IntPtr attack, IntPtr target, IntPtr chance);
 
         /// <param name="p">Script *</param>
@@ -205,7 +205,7 @@ namespace Creaturelib.Generated
         /// <param name="target">Creature *</param>
         /// <param name="chance">float *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyIncomingEffectChance")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Script_ModifyIncomingEffectChance")]
         internal static extern byte ModifyIncomingEffectChance(IntPtr p, IntPtr attack, IntPtr target, IntPtr chance);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/ScriptResolver.cs b/PkmnLibSharp/Generated/Creaturelib/ScriptResolver.cs
index 20ff388..5961f9c 100644
--- a/PkmnLibSharp/Generated/Creaturelib/ScriptResolver.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/ScriptResolver.cs
@@ -7,18 +7,18 @@ namespace Creaturelib.Generated
     internal static class ScriptResolver
     {
         /// <returns>ScriptResolver *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">const ScriptResolver *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">ScriptResolver *</param>
         /// <param name="library">BattleLibrary *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_Initialize")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_Initialize")]
         internal static extern byte Initialize(IntPtr p, IntPtr library);
 
         /// <param name="out">Script * &</param>
@@ -26,7 +26,7 @@ namespace Creaturelib.Generated
         /// <param name="category">ScriptCategory</param>
         /// <param name="scriptName">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_LoadScript")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_ScriptResolver_LoadScript")]
         internal static extern byte LoadScript(ref IntPtr @out, IntPtr p, ScriptCategory category, IntPtr scriptName);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/SpeciesLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/SpeciesLibrary.cs
index d848ee1..7208e13 100644
--- a/PkmnLibSharp/Generated/Creaturelib/SpeciesLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/SpeciesLibrary.cs
@@ -8,84 +8,84 @@ namespace Creaturelib.Generated
     {
         /// <param name="initialCapacity">long unsigned int</param>
         /// <returns>const SpeciesLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Construct")]
         internal static extern IntPtr Construct(ulong initialCapacity);
 
         /// <param name="p">const SpeciesLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="t">CreatureSpecies *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Insert")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Insert")]
         internal static extern byte Insert(IntPtr p, IntPtr name, IntPtr t);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="t">CreatureSpecies *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_InsertWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_InsertWithHash")]
         internal static extern byte InsertWithHash(IntPtr p, uint hashedKey, IntPtr t);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="name">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Delete")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Delete")]
         internal static extern byte Delete(IntPtr p, IntPtr name);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_DeleteWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_DeleteWithHash")]
         internal static extern byte DeleteWithHash(IntPtr p, uint hashedKey);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const CreatureSpecies * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_TryGet")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_TryGet")]
         internal static extern byte TryGet(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="out">const CreatureSpecies * &</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_TryGetWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_TryGetWithHash")]
         internal static extern byte TryGetWithHash(IntPtr p, uint hashedKey, ref IntPtr @out);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const CreatureSpecies * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Get")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_Get")]
         internal static extern byte Get(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="hashedKey">unsigned int</param>
         /// <param name="out">const CreatureSpecies * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetWithHash")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetWithHash")]
         internal static extern byte GetWithHash(IntPtr p, uint hashedKey, ref IntPtr @out);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetCount")]
         internal static extern ulong GetCount(IntPtr p);
 
         /// <param name="p">SpeciesLibrary *</param>
         /// <param name="index">long unsigned int</param>
         /// <param name="out">const CreatureSpecies * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetAtIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetAtIndex")]
         internal static extern byte GetAtIndex(IntPtr p, ulong index, ref IntPtr @out);
 
         /// <param name="p">const SpeciesLibrary *</param>
         /// <param name="id">unsigned short</param>
         /// <returns>const CreatureSpecies *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetById")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesLibrary_GetById")]
         internal static extern IntPtr GetById(IntPtr p, ushort id);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/SpeciesVariant.cs b/PkmnLibSharp/Generated/Creaturelib/SpeciesVariant.cs
index 4f5c897..c870db0 100644
--- a/PkmnLibSharp/Generated/Creaturelib/SpeciesVariant.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/SpeciesVariant.cs
@@ -26,59 +26,59 @@ namespace Creaturelib.Generated
         /// <param name="flags">const char * *</param>
         /// <param name="flagsCount">long unsigned int</param>
         /// <returns>SpeciesVariant *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_Construct")]
         internal static extern IntPtr Construct(IntPtr name, float height, float weight, uint baseExperience, IntPtr types, ulong typeLength, ushort baseHealth, ushort baseAttack, ushort baseDefense, ushort baseMagicalAttack, ushort baseMagicalDefense, ushort baseSpeed, IntPtr talents, ulong talentsLength, IntPtr secretTalents, ulong secretTalentsLength, IntPtr attacks, IntPtr flags, ulong flagsCount);
 
         /// <param name="p">SpeciesVariant *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">SpeciesVariant *</param>
         /// <returns>const char *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetName")]
         internal static extern IntPtr GetName(IntPtr p);
 
         /// <param name="p">const SpeciesVariant *</param>
         /// <returns>float</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetHeight")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetHeight")]
         internal static extern float GetHeight(IntPtr p);
 
         /// <param name="p">const SpeciesVariant *</param>
         /// <returns>float</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetWeight")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetWeight")]
         internal static extern float GetWeight(IntPtr p);
 
         /// <param name="p">const SpeciesVariant *</param>
         /// <returns>unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetBaseExperience")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetBaseExperience")]
         internal static extern uint GetBaseExperience(IntPtr p);
 
         /// <param name="p">const SpeciesVariant *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetTypeCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetTypeCount")]
         internal static extern ulong GetTypeCount(IntPtr p);
 
         /// <param name="p">SpeciesVariant *</param>
         /// <param name="index">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetType")]
         internal static extern byte GetType(IntPtr p, ulong index);
 
         /// <param name="p">SpeciesVariant *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned short</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetStatistic")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetStatistic")]
         internal static extern ushort GetStatistic(IntPtr p, Statistic stat);
 
         /// <param name="p">const SpeciesVariant *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetTalentCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetTalentCount")]
         internal static extern ulong GetTalentCount(IntPtr p);
 
         /// <param name="p">const SpeciesVariant *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetSecretTalentCount")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetSecretTalentCount")]
         internal static extern ulong GetSecretTalentCount(IntPtr p);
 
         /// <param name="p">SpeciesVariant *</param>
@@ -86,24 +86,24 @@ namespace Creaturelib.Generated
         /// <param name="index">unsigned char</param>
         /// <param name="out">const char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetTalent")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetTalent")]
         internal static extern byte GetTalent(IntPtr p, byte secret, byte index, ref IntPtr @out);
 
         /// <param name="p">SpeciesVariant *</param>
         /// <returns>const LearnableAttacks *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetLearnableAttacks")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetLearnableAttacks")]
         internal static extern IntPtr GetLearnableAttacks(IntPtr p);
 
         /// <param name="p">SpeciesVariant *</param>
         /// <param name="rand">Random *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetRandomTalent")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetRandomTalent")]
         internal static extern byte GetRandomTalent(IntPtr p, IntPtr rand);
 
         /// <param name="p">const SpeciesVariant *</param>
         /// <param name="key">const char *</param>
         /// <returns>bool</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_HasFlag")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_HasFlag")]
         internal static extern byte HasFlag(IntPtr p, IntPtr key);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/SwitchEvent.cs b/PkmnLibSharp/Generated/Creaturelib/SwitchEvent.cs
index 3caa228..fa0c566 100644
--- a/PkmnLibSharp/Generated/Creaturelib/SwitchEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/SwitchEvent.cs
@@ -8,22 +8,22 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const SwitchEvent *</param>
         /// <returns>Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_GetNewCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_GetNewCreature")]
         internal static extern IntPtr GetNewCreature(IntPtr p);
 
         /// <param name="p">const SwitchEvent *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_GetSide")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_GetSide")]
         internal static extern byte GetSide(IntPtr p);
 
         /// <param name="p">const SwitchEvent *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_GetIndex")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_GetIndex")]
         internal static extern byte GetIndex(IntPtr p);
 
         /// <param name="p">const SwitchEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/SwitchTurnChoice.cs b/PkmnLibSharp/Generated/Creaturelib/SwitchTurnChoice.cs
index 885adbb..0811fd2 100644
--- a/PkmnLibSharp/Generated/Creaturelib/SwitchTurnChoice.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/SwitchTurnChoice.cs
@@ -9,17 +9,17 @@ namespace Creaturelib.Generated
         /// <param name="user">Creature *</param>
         /// <param name="newCreature">Creature *</param>
         /// <returns>SwitchTurnChoice *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchTurnChoice_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchTurnChoice_Construct")]
         internal static extern IntPtr Construct(IntPtr user, IntPtr newCreature);
 
         /// <param name="p">AttackTurnChoice *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchTurnChoice_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchTurnChoice_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const SwitchTurnChoice *</param>
         /// <returns>Creature *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchTurnChoice_GetNewCreature")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SwitchTurnChoice_GetNewCreature")]
         internal static extern IntPtr GetNewCreature(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/TurnEndEvent.cs b/PkmnLibSharp/Generated/Creaturelib/TurnEndEvent.cs
index 261a8ab..af3c850 100644
--- a/PkmnLibSharp/Generated/Creaturelib/TurnEndEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/TurnEndEvent.cs
@@ -8,7 +8,7 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const TurnEndEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TurnEndEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TurnEndEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/TurnStartEvent.cs b/PkmnLibSharp/Generated/Creaturelib/TurnStartEvent.cs
index c92de3f..8ec3954 100644
--- a/PkmnLibSharp/Generated/Creaturelib/TurnStartEvent.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/TurnStartEvent.cs
@@ -8,7 +8,7 @@ namespace Creaturelib.Generated
     {
         /// <param name="p">const TurnStartEvent *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TurnStartEvent_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TurnStartEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Creaturelib/TypeLibrary.cs b/PkmnLibSharp/Generated/Creaturelib/TypeLibrary.cs
index 523b28e..1d22468 100644
--- a/PkmnLibSharp/Generated/Creaturelib/TypeLibrary.cs
+++ b/PkmnLibSharp/Generated/Creaturelib/TypeLibrary.cs
@@ -8,26 +8,26 @@ namespace Creaturelib.Generated
     {
         /// <param name="initialCapacity">long unsigned int</param>
         /// <returns>TypeLibrary *</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_Construct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_Construct")]
         internal static extern IntPtr Construct(ulong initialCapacity);
 
         /// <param name="p">const TypeLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_Destruct")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="out">unsigned char &</param>
         /// <param name="p">const TypeLibrary *</param>
         /// <param name="type">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetTypeId")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetTypeId")]
         internal static extern byte GetTypeId(ref byte @out, IntPtr p, IntPtr type);
 
         /// <param name="out">unsigned char &</param>
         /// <param name="p">TypeLibrary *</param>
         /// <param name="type">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_RegisterType")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_RegisterType")]
         internal static extern byte RegisterType(ref byte @out, IntPtr p, IntPtr type);
 
         /// <param name="p">TypeLibrary *</param>
@@ -35,7 +35,7 @@ namespace Creaturelib.Generated
         /// <param name="defensive">unsigned char</param>
         /// <param name="effectiveness">float</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_SetEffectiveness")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_SetEffectiveness")]
         internal static extern byte SetEffectiveness(IntPtr p, byte attacking, byte defensive, float effectiveness);
 
         /// <param name="out">float &</param>
@@ -43,7 +43,7 @@ namespace Creaturelib.Generated
         /// <param name="attacking">unsigned char</param>
         /// <param name="defensive">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetSingleEffectiveness")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetSingleEffectiveness")]
         internal static extern byte GetSingleEffectiveness(ref float @out, IntPtr p, byte attacking, byte defensive);
 
         /// <param name="out">float &</param>
@@ -52,14 +52,14 @@ namespace Creaturelib.Generated
         /// <param name="defensive">unsigned char *</param>
         /// <param name="defensiveCount">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetEffectiveness")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetEffectiveness")]
         internal static extern byte GetEffectiveness(ref float @out, IntPtr p, byte attacking, IntPtr defensive, ulong defensiveCount);
 
         /// <param name="out">const char * &</param>
         /// <param name="p">TypeLibrary *</param>
         /// <param name="type">unsigned char</param>
         /// <returns>unsigned char</returns>
-        [DllImport("CreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetTypeName")]
+        [DllImport("libCreatureLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_TypeLibrary_GetTypeName")]
         internal static extern byte GetTypeName(ref IntPtr @out, IntPtr p, byte type);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/AngelScriptResolver.cs b/PkmnLibSharp/Generated/Pkmnlib/AngelScriptResolver.cs
index 66951ed..f54f451 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/AngelScriptResolver.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/AngelScriptResolver.cs
@@ -7,30 +7,30 @@ namespace Pkmnlib.Generated
     internal static class AngelScriptResolver
     {
         /// <returns>AngelScriptResolver *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_Destruct")]
         internal static extern byte Destruct(IntPtr p);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <param name="lib">BattleLibrary *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_Initialize")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_Initialize")]
         internal static extern byte Initialize(IntPtr p, IntPtr lib);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <param name="name">const char *</param>
         /// <param name="script">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_CreateScript")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_CreateScript")]
         internal static extern byte CreateScript(IntPtr p, IntPtr name, IntPtr script);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_FinalizeModule")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_FinalizeModule")]
         internal static extern byte FinalizeModule(IntPtr p);
 
         /// <param name="out">Script * &</param>
@@ -38,20 +38,20 @@ namespace Pkmnlib.Generated
         /// <param name="category">ScriptCategory</param>
         /// <param name="scriptName">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_LoadScript")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_LoadScript")]
         internal static extern byte LoadScript(ref IntPtr @out, IntPtr p, ScriptCategory category, IntPtr scriptName);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <param name="file">const char *</param>
         /// <param name="stripDebugInfo">bool</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_WriteByteCodeToFile")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_WriteByteCodeToFile")]
         internal static extern byte WriteByteCodeToFile(IntPtr p, IntPtr file, byte stripDebugInfo);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <param name="file">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_LoadByteCodeFromFile")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_LoadByteCodeFromFile")]
         internal static extern byte LoadByteCodeFromFile(IntPtr p, IntPtr file);
 
         /// <param name="p">AngelScriptResolver *</param>
@@ -59,20 +59,20 @@ namespace Pkmnlib.Generated
         /// <param name="size">long unsigned int &</param>
         /// <param name="out">unsigned char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_WriteByteCodeToMemory")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_WriteByteCodeToMemory")]
         internal static extern byte WriteByteCodeToMemory(IntPtr p, byte stripDebugInfo, ref ulong size, ref IntPtr @out);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <param name="memory">unsigned char *</param>
         /// <param name="size">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_LoadByteCodeFromMemory")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_LoadByteCodeFromMemory")]
         internal static extern byte LoadByteCodeFromMemory(IntPtr p, IntPtr memory, ulong size);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <param name="typeName">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_RegisterType")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_RegisterType")]
         internal static extern byte RegisterType(IntPtr p, IntPtr typeName);
 
         /// <param name="p">AngelScriptResolver *</param>
@@ -80,14 +80,14 @@ namespace Pkmnlib.Generated
         /// <param name="decl">const char *</param>
         /// <param name="func">Function *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_RegisterTypeMethod")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_RegisterTypeMethod")]
         internal static extern byte RegisterTypeMethod(IntPtr p, IntPtr typeName, IntPtr decl, IntPtr func);
 
         /// <param name="p">AngelScriptResolver *</param>
         /// <param name="decl">const char *</param>
         /// <param name="func">Function *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_RegisterGlobalMethod")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelScriptResolver_RegisterGlobalMethod")]
         internal static extern byte RegisterGlobalMethod(IntPtr p, IntPtr decl, IntPtr func);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/AngelscriptScript.cs b/PkmnLibSharp/Generated/Pkmnlib/AngelscriptScript.cs
index cc9f9c5..a50a90e 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/AngelscriptScript.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/AngelscriptScript.cs
@@ -8,7 +8,7 @@ namespace Pkmnlib.Generated
     {
         /// <param name="p">AngelScriptScript *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelscriptScript_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_AngelscriptScript_Destruct")]
         internal static extern byte Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/Battle.cs b/PkmnLibSharp/Generated/Pkmnlib/Battle.cs
index 318c467..28a713a 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/Battle.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/Battle.cs
@@ -15,28 +15,28 @@ namespace Pkmnlib.Generated
         /// <param name="creaturesPerSide">unsigned char</param>
         /// <param name="randomSeed">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr library, IntPtr parties, ulong partiesCount, byte canFlee, byte numberOfSides, byte creaturesPerSide, ulong randomSeed);
 
         /// <param name="p">Battle *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">Battle *</param>
         /// <param name="name">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_SetWeather")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_SetWeather")]
         internal static extern byte SetWeather(IntPtr p, IntPtr name);
 
         /// <param name="p">Battle *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_ClearWeather")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_ClearWeather")]
         internal static extern byte ClearWeather(IntPtr p);
 
         /// <param name="p">Battle *</param>
         /// <returns>const char *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_GetWeatherName")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Battle_GetWeatherName")]
         internal static extern IntPtr GetWeatherName(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/BattleLibrary.cs b/PkmnLibSharp/Generated/Pkmnlib/BattleLibrary.cs
index b1ebe5f..b267f35 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/BattleLibrary.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/BattleLibrary.cs
@@ -14,12 +14,12 @@ namespace Pkmnlib.Generated
         /// <param name="scriptResolver">ScriptResolver *</param>
         /// <param name="miscLibrary">MiscLibrary *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_BattleLibrary_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_BattleLibrary_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr staticLib, IntPtr statCalculator, IntPtr damageLibrary, IntPtr experienceLibrary, IntPtr scriptResolver, IntPtr miscLibrary);
 
         /// <param name="p">BattleLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_BattleLibrary_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_BattleLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/C.cs b/PkmnLibSharp/Generated/Pkmnlib/C.cs
index 3df84f2..ea570b9 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/C.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/C.cs
@@ -7,7 +7,7 @@ namespace Pkmnlib.Generated
     internal static class C
     {
         /// <returns>const char *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_C_GetLastException")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_C_GetLastException")]
         internal static extern IntPtr GetLastException();
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/DamageLibrary.cs b/PkmnLibSharp/Generated/Pkmnlib/DamageLibrary.cs
index 18cd2fa..202a0d5 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/DamageLibrary.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/DamageLibrary.cs
@@ -7,12 +7,12 @@ namespace Pkmnlib.Generated
     internal static class DamageLibrary
     {
         /// <returns>DamageLibrary *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_DamageLibrary_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_DamageLibrary_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">DamageLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_DamageLibrary_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_DamageLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/EvolutionData.cs b/PkmnLibSharp/Generated/Pkmnlib/EvolutionData.cs
index a84aa84..fcecd06 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/EvolutionData.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/EvolutionData.cs
@@ -9,103 +9,103 @@ namespace Pkmnlib.Generated
         /// <param name="level">unsigned char</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateLevelEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateLevelEvolution")]
         internal static extern IntPtr CreateLevelEvolution(byte level, IntPtr into);
 
         /// <param name="friendship">unsigned char</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateFriendshipEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateFriendshipEvolution")]
         internal static extern IntPtr CreateFriendshipEvolution(byte friendship, IntPtr into);
 
         /// <param name="move">const MoveData *</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateKnownMoveEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateKnownMoveEvolution")]
         internal static extern IntPtr CreateKnownMoveEvolution(IntPtr move, IntPtr into);
 
         /// <param name="location">const char *</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateLocationEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateLocationEvolution")]
         internal static extern IntPtr CreateLocationEvolution(IntPtr location, IntPtr into);
 
         /// <param name="time">TimeOfDay</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTimeEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTimeEvolution")]
         internal static extern IntPtr CreateTimeEvolution(TimeOfDay time, IntPtr into);
 
         /// <param name="item">const Item *</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateItemEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateItemEvolution")]
         internal static extern IntPtr CreateItemEvolution(IntPtr item, IntPtr into);
 
         /// <param name="gender">Gender</param>
         /// <param name="level">unsigned char</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateGenderBasedEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateGenderBasedEvolution")]
         internal static extern IntPtr CreateGenderBasedEvolution(Gender gender, byte level, IntPtr into);
 
         /// <param name="item">const Item *</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateItemUseEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateItemUseEvolution")]
         internal static extern IntPtr CreateItemUseEvolution(IntPtr item, IntPtr into);
 
         /// <param name="item">const Item *</param>
         /// <param name="gender">Gender</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateItemUseWithGenderEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateItemUseWithGenderEvolution")]
         internal static extern IntPtr CreateItemUseWithGenderEvolution(IntPtr item, Gender gender, IntPtr into);
 
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTradeEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTradeEvolution")]
         internal static extern IntPtr CreateTradeEvolution(IntPtr into);
 
         /// <param name="item">const Item *</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTradeWithItemEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTradeWithItemEvolution")]
         internal static extern IntPtr CreateTradeWithItemEvolution(IntPtr item, IntPtr into);
 
         /// <param name="traded">const PokemonSpecies *</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTradeWithSpeciesEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateTradeWithSpeciesEvolution")]
         internal static extern IntPtr CreateTradeWithSpeciesEvolution(IntPtr traded, IntPtr into);
 
         /// <param name="data">const EffectParameter * *</param>
         /// <param name="dataLength">long unsigned int</param>
         /// <param name="into">const PokemonSpecies *</param>
         /// <returns>const EvolutionData *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateCustomEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_CreateCustomEvolution")]
         internal static extern IntPtr CreateCustomEvolution(IntPtr data, ulong dataLength, IntPtr into);
 
         /// <param name="data">const EvolutionData *</param>
         /// <returns>EvolutionMethod</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetMethod")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetMethod")]
         internal static extern EvolutionMethod GetMethod(IntPtr data);
 
         /// <param name="data">const EvolutionData *</param>
         /// <returns>const PokemonSpecies *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetNewSpecies")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetNewSpecies")]
         internal static extern IntPtr GetNewSpecies(IntPtr data);
 
         /// <param name="data">const EvolutionData *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetDataCount")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetDataCount")]
         internal static extern ulong GetDataCount(IntPtr data);
 
         /// <param name="data">const EvolutionData *</param>
         /// <param name="index">long unsigned int</param>
         /// <param name="out">const EffectParameter * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetData")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_EvolutionData_GetData")]
         internal static extern byte GetData(IntPtr data, ulong index, ref IntPtr @out);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/ExperienceLibrary.cs b/PkmnLibSharp/Generated/Pkmnlib/ExperienceLibrary.cs
index a760d5a..22eda7c 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/ExperienceLibrary.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/ExperienceLibrary.cs
@@ -7,7 +7,7 @@ namespace Pkmnlib.Generated
     internal static class ExperienceLibrary
     {
         /// <returns>ExperienceLibrary *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_ExperienceLibrary_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_ExperienceLibrary_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">ExperienceLibrary *</param>
@@ -15,12 +15,12 @@ namespace Pkmnlib.Generated
         /// <param name="opponents">const Creature * *</param>
         /// <param name="numberOfOpponents">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_ExperienceLibrary_HandleExperienceGain")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_ExperienceLibrary_HandleExperienceGain")]
         internal static extern byte HandleExperienceGain(IntPtr p, IntPtr faintedMon, IntPtr opponents, ulong numberOfOpponents);
 
         /// <param name="p">ExperienceLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_ExperienceLibrary_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_ExperienceLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/Item.cs b/PkmnLibSharp/Generated/Pkmnlib/Item.cs
index f5814b7..f9ceefb 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/Item.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/Item.cs
@@ -14,17 +14,17 @@ namespace Pkmnlib.Generated
         /// <param name="flagsCount">long unsigned int</param>
         /// <param name="flingPower">unsigned char</param>
         /// <returns>Item *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Item_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Item_Construct")]
         internal static extern IntPtr Construct(IntPtr name, ItemCategory category, BattleItemCategory battleCategory, int price, IntPtr flags, ulong flagsCount, byte flingPower);
 
         /// <param name="p">const Item *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Item_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Item_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const Item *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Item_GetFlingPower")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Item_GetFlingPower")]
         internal static extern byte GetFlingPower(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/LearnableMoves.cs b/PkmnLibSharp/Generated/Pkmnlib/LearnableMoves.cs
index ef3d08d..9491fb0 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/LearnableMoves.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/LearnableMoves.cs
@@ -9,28 +9,28 @@ namespace Pkmnlib.Generated
         /// <param name="out">LearnableMoves * &</param>
         /// <param name="levelAttackCapacity">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_Construct")]
         internal static extern byte Construct(ref IntPtr @out, ulong levelAttackCapacity);
 
         /// <param name="p">const LearnableMoves *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">LearnableMoves *</param>
         /// <param name="move">MoveData *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_AddEggMove")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_AddEggMove")]
         internal static extern void AddEggMove(IntPtr p, IntPtr move);
 
         /// <param name="p">LearnableMoves *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_GetEggMovesCount")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_GetEggMovesCount")]
         internal static extern ulong GetEggMovesCount(IntPtr p);
 
         /// <param name="p">LearnableMoves *</param>
         /// <returns>const const MoveData * *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_GetEggMoves")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LearnableMoves_GetEggMoves")]
         internal static extern IntPtr GetEggMoves(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/LibrarySettings.cs b/PkmnLibSharp/Generated/Pkmnlib/LibrarySettings.cs
index 8becb2a..e9ad742 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/LibrarySettings.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/LibrarySettings.cs
@@ -10,17 +10,17 @@ namespace Pkmnlib.Generated
         /// <param name="maximalMoves">unsigned char</param>
         /// <param name="shinyRate">unsigned short</param>
         /// <returns>const LibrarySettings *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LibrarySettings_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LibrarySettings_Construct")]
         internal static extern IntPtr Construct(byte maximalLevel, byte maximalMoves, ushort shinyRate);
 
         /// <param name="p">const LibrarySettings *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LibrarySettings_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LibrarySettings_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const LibrarySettings *</param>
         /// <returns>unsigned short</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LibrarySettings_GetShinyRate")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_LibrarySettings_GetShinyRate")]
         internal static extern ushort GetShinyRate(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/MiscLibrary.cs b/PkmnLibSharp/Generated/Pkmnlib/MiscLibrary.cs
index 02530f3..c8f2c4d 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/MiscLibrary.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/MiscLibrary.cs
@@ -7,12 +7,12 @@ namespace Pkmnlib.Generated
     internal static class MiscLibrary
     {
         /// <returns>MiscLibrary *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_MiscLibrary_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_MiscLibrary_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">MiscLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_MiscLibrary_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_MiscLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/Nature.cs b/PkmnLibSharp/Generated/Pkmnlib/Nature.cs
index e82197f..eccb025 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/Nature.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/Nature.cs
@@ -11,38 +11,38 @@ namespace Pkmnlib.Generated
         /// <param name="increasedModifier">float</param>
         /// <param name="decreasedModifier">float</param>
         /// <returns>Nature *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_Construct")]
         internal static extern IntPtr Construct(Statistic increasedStat, Statistic decreasedStat, float increasedModifier, float decreasedModifier);
 
         /// <param name="p">const Nature *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const Nature *</param>
         /// <returns>float</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetIncreaseModifier")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetIncreaseModifier")]
         internal static extern float GetIncreaseModifier(IntPtr p);
 
         /// <param name="p">const Nature *</param>
         /// <returns>float</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetDecreaseModifier")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetDecreaseModifier")]
         internal static extern float GetDecreaseModifier(IntPtr p);
 
         /// <param name="p">const Nature *</param>
         /// <returns>Statistic</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetIncreasedStat")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetIncreasedStat")]
         internal static extern Statistic GetIncreasedStat(IntPtr p);
 
         /// <param name="p">const Nature *</param>
         /// <returns>Statistic</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetDecreasedStat")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetDecreasedStat")]
         internal static extern Statistic GetDecreasedStat(IntPtr p);
 
         /// <param name="nature">const Nature *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>float</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetStatModifier")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Nature_GetStatModifier")]
         internal static extern float GetStatModifier(IntPtr nature, Statistic stat);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/NatureLibrary.cs b/PkmnLibSharp/Generated/Pkmnlib/NatureLibrary.cs
index 79f2cc1..c978c6d 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/NatureLibrary.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/NatureLibrary.cs
@@ -8,52 +8,52 @@ namespace Pkmnlib.Generated
     {
         /// <param name="initialCapacity">long unsigned int</param>
         /// <returns>NatureLibrary *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_Construct")]
         internal static extern IntPtr Construct(ulong initialCapacity);
 
         /// <param name="p">const NatureLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">NatureLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="nature">const Nature *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_LoadNature")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_LoadNature")]
         internal static extern byte LoadNature(IntPtr p, IntPtr name, IntPtr nature);
 
         /// <param name="p">NatureLibrary *</param>
         /// <param name="name">const char *</param>
         /// <param name="out">const Nature * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureByName")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureByName")]
         internal static extern byte GetNatureByName(IntPtr p, IntPtr name, ref IntPtr @out);
 
         /// <param name="p">NatureLibrary *</param>
         /// <param name="rand">Random *</param>
         /// <param name="out">const char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetRandomNatureName")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetRandomNatureName")]
         internal static extern byte GetRandomNatureName(IntPtr p, IntPtr rand, ref IntPtr @out);
 
         /// <param name="p">NatureLibrary *</param>
         /// <param name="nature">const Nature *</param>
         /// <param name="out">const char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureName")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureName")]
         internal static extern byte GetNatureName(IntPtr p, IntPtr nature, ref IntPtr @out);
 
         /// <param name="p">const NatureLibrary *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureCount")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureCount")]
         internal static extern ulong GetNatureCount(IntPtr p);
 
         /// <param name="p">NatureLibrary *</param>
         /// <param name="index">long unsigned int</param>
         /// <param name="out">const char * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureByIndex")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_NatureLibrary_GetNatureByIndex")]
         internal static extern byte GetNatureByIndex(IntPtr p, ulong index, ref IntPtr @out);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/PkmnScript.cs b/PkmnLibSharp/Generated/Pkmnlib/PkmnScript.cs
index 72b41bc..aacfdd8 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/PkmnScript.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/PkmnScript.cs
@@ -12,7 +12,7 @@ namespace Pkmnlib.Generated
         /// <param name="hit">unsigned char</param>
         /// <param name="critStage">unsigned char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PkmnScript_ModifyCriticalStage")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PkmnScript_ModifyCriticalStage")]
         internal static extern byte ModifyCriticalStage(IntPtr script, IntPtr attack, IntPtr target, byte hit, IntPtr critStage);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/Pokemon.cs b/PkmnLibSharp/Generated/Pkmnlib/Pokemon.cs
index f9fc655..a75917a 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/Pokemon.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/Pokemon.cs
@@ -34,88 +34,88 @@ namespace Pkmnlib.Generated
         /// <param name="spEv">unsigned char</param>
         /// <param name="nature">const Nature *</param>
         /// <returns>Pokemon *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_Construct")]
         internal static extern IntPtr Construct(IntPtr library, IntPtr species, IntPtr forme, byte level, uint experience, uint uid, Gender gender, byte coloring, IntPtr heldItem, IntPtr nickname, byte hiddenAbility, byte abilityIndex, IntPtr moves, ulong moveCount, byte hpIv, byte attIv, byte defIv, byte sAtIv, byte sDeIv, byte spIv, byte hpEv, byte attEv, byte defEv, byte sAtEv, byte sDeEv, byte spEv, IntPtr nature);
 
         /// <param name="p">const Pokemon *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const Pokemon *</param>
         /// <returns>bool</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_IsShiny")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_IsShiny")]
         internal static extern byte IsShiny(IntPtr p);
 
         /// <param name="p">const Pokemon *</param>
         /// <returns>const Nature *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetNature")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetNature")]
         internal static extern IntPtr GetNature(IntPtr p);
 
         /// <param name="p">const Pokemon *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetIndividualValue")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetIndividualValue")]
         internal static extern byte GetIndividualValue(IntPtr p, Statistic stat);
 
         /// <param name="p">Pokemon *</param>
         /// <param name="stat">Statistic</param>
         /// <param name="value">unsigned char</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetIndividualValue")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetIndividualValue")]
         internal static extern void SetIndividualValue(IntPtr p, Statistic stat, byte value);
 
         /// <param name="p">const Pokemon *</param>
         /// <param name="stat">Statistic</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetEffortValue")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetEffortValue")]
         internal static extern byte GetEffortValue(IntPtr p, Statistic stat);
 
         /// <param name="p">Pokemon *</param>
         /// <param name="stat">Statistic</param>
         /// <param name="value">unsigned char</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetEffortValue")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetEffortValue")]
         internal static extern void SetEffortValue(IntPtr p, Statistic stat, byte value);
 
         /// <param name="p">Pokemon *</param>
         /// <param name="name">const char *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetStatus")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetStatus")]
         internal static extern byte SetStatus(IntPtr p, IntPtr name);
 
         /// <param name="p">Pokemon *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_ClearStatus")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_ClearStatus")]
         internal static extern byte ClearStatus(IntPtr p);
 
         /// <param name="p">Pokemon *</param>
         /// <returns>const char *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetStatusName")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetStatusName")]
         internal static extern IntPtr GetStatusName(IntPtr p);
 
         /// <param name="p">const Pokemon *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetFriendship")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_GetFriendship")]
         internal static extern byte GetFriendship(IntPtr p);
 
         /// <param name="p">Pokemon *</param>
         /// <param name="value">unsigned char</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetFriendship")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_SetFriendship")]
         internal static extern void SetFriendship(IntPtr p, byte value);
 
         /// <param name="p">Pokemon *</param>
         /// <param name="amount">signed char</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_ChangeFriendship")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_ChangeFriendship")]
         internal static extern void ChangeFriendship(IntPtr p, sbyte amount);
 
         /// <param name="p">Pokemon *</param>
         /// <param name="species">const PokemonSpecies *</param>
         /// <param name="forme">const PokemonForme *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_Evolve")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_Pokemon_Evolve")]
         internal static extern byte Evolve(IntPtr p, IntPtr species, IntPtr forme);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/PokemonForme.cs b/PkmnLibSharp/Generated/Pkmnlib/PokemonForme.cs
index b5cbc82..84c79c2 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/PokemonForme.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/PokemonForme.cs
@@ -26,7 +26,7 @@ namespace Pkmnlib.Generated
         /// <param name="flags">const char * *</param>
         /// <param name="flagsCount">long unsigned int</param>
         /// <returns>PokemonForme *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonForme_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonForme_Construct")]
         internal static extern IntPtr Construct(IntPtr name, float height, float weight, uint baseExperience, IntPtr types, ulong typeLength, ushort baseHealth, ushort baseAttack, ushort baseDefense, ushort baseMagicalAttack, ushort baseMagicalDefense, ushort baseSpeed, IntPtr talents, ulong talentsLength, IntPtr secretTalents, ulong secretTalentsLength, IntPtr attacks, IntPtr flags, ulong flagsCount);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/PokemonLibrary.cs b/PkmnLibSharp/Generated/Pkmnlib/PokemonLibrary.cs
index 54ff22b..14ec6ea 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/PokemonLibrary.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/PokemonLibrary.cs
@@ -15,17 +15,17 @@ namespace Pkmnlib.Generated
         /// <param name="typeLibrary">TypeLibrary *</param>
         /// <param name="natures">NatureLibrary *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonLibrary_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonLibrary_Construct")]
         internal static extern byte Construct(ref IntPtr @out, IntPtr settings, IntPtr species, IntPtr moves, IntPtr items, IntPtr growthRates, IntPtr typeLibrary, IntPtr natures);
 
         /// <param name="p">const PokemonLibrary *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonLibrary_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonLibrary_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const PokemonLibrary *</param>
         /// <returns>const NatureLibrary *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonLibrary_GetNatureLibrary")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonLibrary_GetNatureLibrary")]
         internal static extern IntPtr GetNatureLibrary(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/PokemonSpecies.cs b/PkmnLibSharp/Generated/Pkmnlib/PokemonSpecies.cs
index aa5390e..95e26a3 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/PokemonSpecies.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/PokemonSpecies.cs
@@ -19,52 +19,52 @@ namespace Pkmnlib.Generated
         /// <param name="flags">const char * *</param>
         /// <param name="flagsCount">long unsigned int</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_Construct")]
         internal static extern byte Construct(ref IntPtr @out, ushort id, IntPtr name, IntPtr defaultForme, float genderRatio, IntPtr growthRate, byte captureRate, byte baseHappiness, IntPtr eggGroupsRaw, ulong eggGroupsLength, IntPtr flags, ulong flagsCount);
 
         /// <param name="p">const PokemonSpecies *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">const PokemonSpecies *</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetBaseHappiness")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetBaseHappiness")]
         internal static extern byte GetBaseHappiness(IntPtr p);
 
         /// <param name="p">PokemonSpecies *</param>
         /// <param name="evo">EvolutionData *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_AddEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_AddEvolution")]
         internal static extern void AddEvolution(IntPtr p, IntPtr evo);
 
         /// <param name="p">const PokemonSpecies *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEvolutionCount")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEvolutionCount")]
         internal static extern ulong GetEvolutionCount(IntPtr p);
 
         /// <param name="p">const PokemonSpecies *</param>
         /// <param name="index">long unsigned int</param>
         /// <param name="out">const EvolutionData * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEvolution")]
         internal static extern byte GetEvolution(IntPtr p, ulong index, ref IntPtr @out);
 
         /// <param name="p">const PokemonSpecies *</param>
         /// <param name="out">const const EvolutionData * * &</param>
         /// <returns>unsigned char</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEvolutions")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEvolutions")]
         internal static extern byte GetEvolutions(IntPtr p, ref IntPtr @out);
 
         /// <param name="p">const PokemonSpecies *</param>
         /// <returns>long unsigned int</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEggGroupCount")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEggGroupCount")]
         internal static extern ulong GetEggGroupCount(IntPtr p);
 
         /// <param name="p">const PokemonSpecies *</param>
         /// <param name="index">long unsigned int</param>
         /// <returns>const char *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEggGroup")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_PokemonSpecies_GetEggGroup")]
         internal static extern IntPtr GetEggGroup(IntPtr p, ulong index);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/SpeciesLibrary.cs b/PkmnLibSharp/Generated/Pkmnlib/SpeciesLibrary.cs
index 1dc5b68..46fb532 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/SpeciesLibrary.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/SpeciesLibrary.cs
@@ -9,7 +9,7 @@ namespace Pkmnlib.Generated
         /// <param name="p">const SpeciesLibrary *</param>
         /// <param name="species">const PokemonSpecies *</param>
         /// <returns>const PokemonSpecies *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_SpeciesLibrary_FindPreEvolution")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_SpeciesLibrary_FindPreEvolution")]
         internal static extern IntPtr FindPreEvolution(IntPtr p, IntPtr species);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/StatCalculator.cs b/PkmnLibSharp/Generated/Pkmnlib/StatCalculator.cs
index b1360f7..7fe9647 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/StatCalculator.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/StatCalculator.cs
@@ -7,12 +7,12 @@ namespace Pkmnlib.Generated
     internal static class StatCalculator
     {
         /// <returns>StatCalculator *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_StatCalculator_Construct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_StatCalculator_Construct")]
         internal static extern IntPtr Construct();
 
         /// <param name="p">StatCalculator *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_StatCalculator_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_StatCalculator_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Generated/Pkmnlib/WeatherChangeEvent.cs b/PkmnLibSharp/Generated/Pkmnlib/WeatherChangeEvent.cs
index 3b7d288..b2edebd 100644
--- a/PkmnLibSharp/Generated/Pkmnlib/WeatherChangeEvent.cs
+++ b/PkmnLibSharp/Generated/Pkmnlib/WeatherChangeEvent.cs
@@ -8,12 +8,12 @@ namespace Pkmnlib.Generated
     {
         /// <param name="p">WeatherChangeEvent *</param>
         /// <returns>void</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_WeatherChangeEvent_Destruct")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_WeatherChangeEvent_Destruct")]
         internal static extern void Destruct(IntPtr p);
 
         /// <param name="p">WeatherChangeEvent *</param>
         /// <returns>const char *</returns>
-        [DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_WeatherChangeEvent_GetWeatherName")]
+        [DllImport("libpkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_WeatherChangeEvent_GetWeatherName")]
         internal static extern IntPtr GetWeatherName(IntPtr p);
 
     }
diff --git a/PkmnLibSharp/Native/libArbutils.so b/PkmnLibSharp/Native/libArbutils.so
index 34ac9b8..b43c2ba 100755
--- a/PkmnLibSharp/Native/libArbutils.so
+++ b/PkmnLibSharp/Native/libArbutils.so
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:930cb5a99e885cd40314cc259d5211680e8619f9df65d096ae51e12e17801d6c
-size 3314296
+oid sha256:3cc1be7910048d60fd9ced97df53498f79fadf3a82d6d79fd8629f424dcf0393
+size 3273304
diff --git a/PkmnLibSharp/Native/libCreatureLib.so b/PkmnLibSharp/Native/libCreatureLib.so
index 36de71e..8f989f0 100755
--- a/PkmnLibSharp/Native/libCreatureLib.so
+++ b/PkmnLibSharp/Native/libCreatureLib.so
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:35df84bd6d55a6d79beb0206bb76763d7388e06a260aa6acb1132a99de30bbb9
-size 25248712
+oid sha256:025992bc0921d497378d3c20316ebd0cb4e72bed3f394b188d4a120578efb073
+size 24438712
diff --git a/PkmnLibSharp/Native/libpkmnLib.so b/PkmnLibSharp/Native/libpkmnLib.so
index ce2a9ca..918c6c4 100755
--- a/PkmnLibSharp/Native/libpkmnLib.so
+++ b/PkmnLibSharp/Native/libpkmnLib.so
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:73acd6ca81aa4973b37b9803bf7aaf0fb06757a35734433948cd10592810e978
-size 17852736
+oid sha256:888c575d1c35f0c887ab9cf5daf1a6ca0146e1d78158c6e85d2a151edbe5e6a4
+size 16606488
diff --git a/PkmnLibSharp/arbutils.json b/PkmnLibSharp/arbutils.json
index d1dd4e7..4cbb381 100644
--- a/PkmnLibSharp/arbutils.json
+++ b/PkmnLibSharp/arbutils.json
@@ -1 +1 @@
-{"enums":[{"byteSize":4,"filename":"Arbutils","name":"float_denorm_style","values":{"-1":"denorm_indeterminate","0":"denorm_absent","1":"denorm_present"}},{"byteSize":4,"filename":"Arbutils","name":"float_round_style","values":{"-1":"round_indeterminate","0":"round_toward_zero","1":"round_to_nearest","2":"round_toward_infinity","3":"round_toward_neg_infinity"}}],"functions":[{"filename":"Arbutils","name":"Arbutils_C_GetLastException","parameters":[],"returns":"const char *"},{"filename":"Arbutils","name":"Arbutils_C_SetSignalCallback","parameters":[{"name":"callback","type":"Function *"}],"returns":"void"},{"filename":"Arbutils","name":"Arbutils_C_RaiseSignal","parameters":[],"returns":"void"},{"filename":"Arbutils","name":"Arbutils_Random_Construct","parameters":[],"returns":"Random *"},{"filename":"Arbutils","name":"Arbutils_Random_ConstructWithSeed","parameters":[{"name":"seed","type":"long unsigned int"}],"returns":"Random *"},{"filename":"Arbutils","name":"Arbutils_Random_Destruct","parameters":[{"name":"p","type":"Random *"}],"returns":"void"},{"filename":"Arbutils","name":"Arbutils_Random_GetFloat","parameters":[{"name":"p","type":"Random *"}],"returns":"float"},{"filename":"Arbutils","name":"Arbutils_Random_GetDouble","parameters":[{"name":"p","type":"Random *"}],"returns":"double"},{"filename":"Arbutils","name":"Arbutils_Random_Get","parameters":[{"name":"p","type":"Random *"}],"returns":"int"},{"filename":"Arbutils","name":"Arbutils_Random_GetWithMax","parameters":[{"name":"p","type":"Random *"},{"name":"max","type":"int"},{"name":"out","type":"int &"}],"returns":"unsigned char"},{"filename":"Arbutils","name":"Arbutils_Random_GetInLimits","parameters":[{"name":"p","type":"Random *"},{"name":"min","type":"int"},{"name":"max","type":"int"},{"name":"out","type":"int &"}],"returns":"unsigned char"},{"filename":"Arbutils","name":"Arbutils_Random_GetUnsigned","parameters":[{"name":"p","type":"Random *"}],"returns":"unsigned int"},{"filename":"Arbutils","name":"Arbutils_Random_GetUnsignedWithMax","parameters":[{"name":"p","type":"Random *"},{"name":"max","type":"unsigned int"},{"name":"out","type":"unsigned int &"}],"returns":"unsigned char"},{"filename":"Arbutils","name":"Arbutils_Random_GetUnsignedInLimits","parameters":[{"name":"p","type":"Random *"},{"name":"min","type":"unsigned int"},{"name":"max","type":"unsigned int"},{"name":"out","type":"unsigned int &"}],"returns":"unsigned char"},{"filename":"Arbutils","name":"Arbutils_Random_GetSeed","parameters":[{"name":"p","type":"Random *"}],"returns":"long unsigned int"}]}
+{"enums":[{"byteSize":4,"filename":"libArbutils","name":"float_denorm_style","values":{"-1":"denorm_indeterminate","0":"denorm_absent","1":"denorm_present"}},{"byteSize":4,"filename":"libArbutils","name":"float_round_style","values":{"-1":"round_indeterminate","0":"round_toward_zero","1":"round_to_nearest","2":"round_toward_infinity","3":"round_toward_neg_infinity"}}],"functions":[{"filename":"libArbutils","name":"Arbutils_C_GetLastException","parameters":[],"returns":"const char *"},{"filename":"libArbutils","name":"Arbutils_C_SetSignalCallback","parameters":[{"name":"callback","type":"Function *"}],"returns":"void"},{"filename":"libArbutils","name":"Arbutils_Random_Construct","parameters":[],"returns":"Random *"},{"filename":"libArbutils","name":"Arbutils_Random_ConstructWithSeed","parameters":[{"name":"seed","type":"long unsigned int"}],"returns":"Random *"},{"filename":"libArbutils","name":"Arbutils_Random_Destruct","parameters":[{"name":"p","type":"Random *"}],"returns":"void"},{"filename":"libArbutils","name":"Arbutils_Random_GetFloat","parameters":[{"name":"p","type":"Random *"}],"returns":"float"},{"filename":"libArbutils","name":"Arbutils_Random_GetDouble","parameters":[{"name":"p","type":"Random *"}],"returns":"double"},{"filename":"libArbutils","name":"Arbutils_Random_Get","parameters":[{"name":"p","type":"Random *"}],"returns":"int"},{"filename":"libArbutils","name":"Arbutils_Random_GetWithMax","parameters":[{"name":"p","type":"Random *"},{"name":"max","type":"int"},{"name":"out","type":"int &"}],"returns":"unsigned char"},{"filename":"libArbutils","name":"Arbutils_Random_GetInLimits","parameters":[{"name":"p","type":"Random *"},{"name":"min","type":"int"},{"name":"max","type":"int"},{"name":"out","type":"int &"}],"returns":"unsigned char"},{"filename":"libArbutils","name":"Arbutils_Random_GetUnsigned","parameters":[{"name":"p","type":"Random *"}],"returns":"unsigned int"},{"filename":"libArbutils","name":"Arbutils_Random_GetUnsignedWithMax","parameters":[{"name":"p","type":"Random *"},{"name":"max","type":"unsigned int"},{"name":"out","type":"unsigned int &"}],"returns":"unsigned char"},{"filename":"libArbutils","name":"Arbutils_Random_GetUnsignedInLimits","parameters":[{"name":"p","type":"Random *"},{"name":"min","type":"unsigned int"},{"name":"max","type":"unsigned int"},{"name":"out","type":"unsigned int &"}],"returns":"unsigned char"},{"filename":"libArbutils","name":"Arbutils_Random_GetSeed","parameters":[{"name":"p","type":"Random *"}],"returns":"long unsigned int"}]}
diff --git a/PkmnLibSharp/creaturelib.json b/PkmnLibSharp/creaturelib.json
index d721dab..81ab231 100644
--- a/PkmnLibSharp/creaturelib.json
+++ b/PkmnLibSharp/creaturelib.json
@@ -1 +1 @@
-{"enums":[{"byteSize":4,"filename":"CreatureLib","name":"float_denorm_style","values":{"-1":"denorm_indeterminate","0":"denorm_absent","1":"denorm_present"}},{"byteSize":4,"filename":"CreatureLib","name":"float_round_style","values":{"-1":"round_indeterminate","0":"round_toward_zero","1":"round_to_nearest","2":"round_toward_infinity","3":"round_toward_neg_infinity"}},{"byteSize":1,"filename":"CreatureLib","name":"ScriptCategory","values":{"0":"Attack","1":"Talent","2":"Status","3":"Creature","4":"Battle","5":"Side"}},{"byteSize":1,"filename":"CreatureLib","name":"Statistic","values":{"0":"Health","1":"PhysicalAttack","2":"PhysicalDefense","3":"MagicalAttack","4":"MagicalDefense","5":"Speed"}},{"byteSize":1,"filename":"CreatureLib","name":"Gender","values":{"0":"Male","1":"Female","2":"Genderless"}},{"byteSize":1,"filename":"CreatureLib","name":"ItemCategory","values":{"0":"MiscItem","1":"CaptureDevice","2":"Medicine","3":"Berry","4":"MoveLearner","5":"VariantChanger","6":"KeyItem","7":"Mail"}},{"byteSize":1,"filename":"CreatureLib","name":"BattleItemCategory","values":{"0":"None","1":"Healing","2":"StatusHealing","3":"CaptureDevice","4":"MiscBattleItem"}},{"byteSize":1,"filename":"CreatureLib","name":"DamageSource","values":{"0":"AttackDamage"}},{"byteSize":1,"filename":"CreatureLib","name":"EventDataKind","values":{"0":"Damage","1":"Heal","10":"ChangeVariant","11":"AttackUse","2":"Faint","3":"Switch","4":"TurnStart","5":"TurnEnd","6":"ExperienceGain","7":"Miss","8":"DisplayText","9":"ChangeSpecies"}},{"byteSize":1,"filename":"CreatureLib","name":"HistoryElementKind","values":{"0":"AttackUse"}},{"byteSize":4,"filename":"CreatureLib","name":"AttackLearnMethod","values":{"0":"Unknown","1":"Level"}},{"byteSize":1,"filename":"CreatureLib","name":"TurnChoiceKind","values":{"0":"Pass","1":"Attack","2":"Item","3":"Switch","4":"Flee"}},{"byteSize":1,"filename":"CreatureLib","name":"EffectParameterType","values":{"0":"None","1":"Bool","2":"Int","3":"Float","4":"String"}},{"byteSize":1,"filename":"CreatureLib","name":"AttackCategory","values":{"0":"Physical","1":"Magical","2":"Status"}},{"byteSize":1,"filename":"CreatureLib","name":"AttackTarget","values":{"0":"Adjacent","1":"AdjacentAlly","10":"RandomOpponent","11":"Self","2":"AdjacentAllySelf","3":"AdjacentOpponent","4":"All","5":"AllAdjacent","6":"AllAdjacentOpponent","7":"AllAlly","8":"AllOpponent","9":"Any"}}],"functions":[{"filename":"CreatureLib","name":"CreatureLib_Battle_Construct","parameters":[{"name":"out","type":"Battle * &"},{"name":"library","type":"const BattleLibrary *"},{"name":"partyArr","type":"BattleParty * *"},{"name":"numberOfParties","type":"long unsigned int"},{"name":"canFlee","type":"bool"},{"name":"numberOfSides","type":"unsigned char"},{"name":"creaturesPerSide","type":"unsigned char"},{"name":"randomSeed","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_Destruct","parameters":[{"name":"p","type":"const Battle *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetLibrary","parameters":[{"name":"p","type":"const Battle *"}],"returns":"const BattleLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_Battle_CanUse","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"Battle *"},{"name":"turnChoice","type":"BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_TrySetChoice","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"Battle *"},{"name":"turnChoice","type":"BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_CanFlee","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Battle_CheckChoicesSetAndRun","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetCurrentTurn","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetCreaturesPerSide","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetCurrentTurnQueue","parameters":[{"name":"p","type":"const Battle *"}],"returns":"ChoiceQueue *"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetRandom","parameters":[{"name":"p","type":"Battle *"}],"returns":"BattleRandom *"},{"filename":"CreatureLib","name":"CreatureLib_Battle_CreatureInField","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"const Battle *"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetCreature","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"const Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_ForceRecall","parameters":[{"name":"p","type":"Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_SwitchCreature","parameters":[{"name":"p","type":"Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_CanSlotBeFilled","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"const Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_ValidateBattleState","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_HasEnded","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Battle_HasConclusiveResult","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetWinningSide","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetSidesCount","parameters":[{"name":"p","type":"const Battle *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetSides","parameters":[{"name":"p","type":"const Battle *"}],"returns":"const BattleSide * *"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetPartiesCount","parameters":[{"name":"p","type":"const Battle *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetParties","parameters":[{"name":"p","type":"const Battle *"}],"returns":"const BattleParty * *"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"Script *"},{"filename":"CreatureLib","name":"CreatureLib_Battle_AddVolatileScriptByName","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_AddVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_RemoveVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_RemoveVolatileScriptWithScript","parameters":[{"name":"p","type":"Battle *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_HasVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Battle_RegisterEventListener","parameters":[{"name":"p","type":"Battle *"},{"name":"func","type":"Function *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetHistory","parameters":[{"name":"p","type":"Battle *"}],"returns":"const HistoryHolder *"},{"filename":"CreatureLib","name":"CreatureLib_Battle_GetLastTurnTimeMicroseconds","parameters":[{"name":"p","type":"const Battle *"}],"returns":"long int"},{"filename":"CreatureLib","name":"CreatureLib_BattleLibrary_Construct","parameters":[{"name":"out","type":"const BattleLibrary * &"},{"name":"staticLib","type":"const DataLibrary *"},{"name":"statCalculator","type":"BattleStatCalculator *"},{"name":"damageLibrary","type":"DamageLibrary *"},{"name":"experienceLibrary","type":"ExperienceLibrary *"},{"name":"scriptResolver","type":"ScriptResolver *"},{"name":"miscLibrary","type":"MiscLibrary *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleLibrary_Destruct","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BattleLibrary_GetStaticLib","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const DataLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_BattleLibrary_GetStatCalculator","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const BattleStatCalculator *"},{"filename":"CreatureLib","name":"CreatureLib_BattleLibrary_GetDamageLibrary","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const DamageLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_BattleLibrary_GetMiscLibrary","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const MiscLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_BattleLibrary_GetExperienceLibrary","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const ExperienceLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_BattleParty_Construct","parameters":[{"name":"out","type":"BattleParty * &"},{"name":"p","type":"CreatureParty *"},{"name":"creatureIndices","type":"unsigned char *"},{"name":"numberOfIndices","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleParty_Destruct","parameters":[{"name":"p","type":"const BattleParty *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BattleParty_GetParty","parameters":[{"name":"p","type":"const BattleParty *"}],"returns":"CreatureParty *"},{"filename":"CreatureLib","name":"CreatureLib_BattleParty_IsResponsibleForIndex","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"const BattleParty *"},{"name":"side","type":"unsigned char"},{"name":"creature","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleParty_HasCreaturesNotInField","parameters":[{"name":"p","type":"const BattleParty *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_Construct","parameters":[],"returns":"BattleRandom *"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_ConstructWithSeed","parameters":[{"name":"seed","type":"long unsigned int"}],"returns":"BattleRandom *"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_Destruct","parameters":[{"name":"p","type":"BattleRandom *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_EffectChance","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"BattleRandom *"},{"name":"chance","type":"float"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_Get","parameters":[{"name":"p","type":"BattleRandom *"}],"returns":"int"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_GetMax","parameters":[{"name":"p","type":"BattleRandom *"},{"name":"max","type":"int"}],"returns":"int"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_GetMinMax","parameters":[{"name":"p","type":"BattleRandom *"},{"name":"min","type":"int"},{"name":"max","type":"int"}],"returns":"int"},{"filename":"CreatureLib","name":"CreatureLib_BattleRandom_GetSeed","parameters":[{"name":"p","type":"BattleRandom *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_Construct","parameters":[{"name":"index","type":"unsigned char"},{"name":"battle","type":"Battle *"},{"name":"creaturesPerSide","type":"unsigned char"}],"returns":"BattleSide *"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_Destruct","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_AllChoicesSet","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_AllPossibleSlotsFilled","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"BattleSide *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_SetChoice","parameters":[{"name":"p","type":"BattleSide *"},{"name":"choice","type":"BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_ResetChoices","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_SetCreature","parameters":[{"name":"p","type":"BattleSide *"},{"name":"creature","type":"Creature *"},{"name":"index","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_GetCreature","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"BattleSide *"},{"name":"index","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_GetSideIndex","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_GetCreatureIndex","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"BattleSide *"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_MarkSlotAsUnfillable","parameters":[{"name":"p","type":"BattleSide *"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_IsDefeated","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_HasFled","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_BattleSide_MarkAsFled","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BattleStatCalculator_Construct","parameters":[],"returns":"const BattleStatCalculator *"},{"filename":"CreatureLib","name":"CreatureLib_BattleStatCalculator_Destruct","parameters":[{"name":"p","type":"const BattleStatCalculator *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BattleStatCalculator_CalculateFlatStat","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const BattleStatCalculator *"},{"name":"creature","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_BattleStatCalculator_CalculateBoostedStat","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const BattleStatCalculator *"},{"name":"creature","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_Construct","parameters":[{"name":"out","type":"Creature * &"},{"name":"library","type":"const BattleLibrary *"},{"name":"species","type":"const CreatureSpecies *"},{"name":"variant","type":"const SpeciesVariant *"},{"name":"level","type":"unsigned char"},{"name":"experience","type":"unsigned int"},{"name":"uid","type":"unsigned int"},{"name":"gender","type":"Gender"},{"name":"coloring","type":"unsigned char"},{"name":"heldItem","type":"const Item *"},{"name":"nickname","type":"const char *"},{"name":"secretTalent","type":"bool"},{"name":"talent","type":"unsigned char"},{"name":"attacks","type":"LearnedAttack * *"},{"name":"attacksNum","type":"long unsigned int"},{"name":"allowedExperienceGain","type":"bool"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_Destruct","parameters":[{"name":"p","type":"const Creature *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Creature_Initialize","parameters":[{"name":"p","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetLibrary","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const BattleLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetSpecies","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const CreatureSpecies *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetVariant","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const SpeciesVariant *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_ChangeSpecies","parameters":[{"name":"p","type":"Creature *"},{"name":"species","type":"const CreatureSpecies *"},{"name":"variant","type":"const SpeciesVariant *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_ChangeVariant","parameters":[{"name":"p","type":"Creature *"},{"name":"variant","type":"const SpeciesVariant *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetLevel","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetExperience","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetUniqueIdentifier","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetGender","parameters":[{"name":"p","type":"const Creature *"}],"returns":"Gender"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetColoring","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_HasHeldItem","parameters":[{"name":"p","type":"const Creature *"},{"name":"name","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_HasHeldItemWithHash","parameters":[{"name":"p","type":"const Creature *"},{"name":"hash","type":"unsigned int"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetHeldItem","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const Item *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_SetHeldItem","parameters":[{"name":"p","type":"Creature *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_SetHeldItemWithHash","parameters":[{"name":"p","type":"Creature *"},{"name":"hash","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_SetHeldItemFromItem","parameters":[{"name":"p","type":"Creature *"},{"name":"item","type":"const Item *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetCurrentHealth","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetBattle","parameters":[{"name":"p","type":"const Creature *"}],"returns":"Battle *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetBattleSide","parameters":[{"name":"p","type":"const Creature *"}],"returns":"BattleSide *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_IsOnBattleField","parameters":[{"name":"p","type":"const Creature *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetNickname","parameters":[{"name":"p","type":"Creature *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_HasType","parameters":[{"name":"p","type":"Creature *"},{"name":"type","type":"unsigned char"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetMaxHealth","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_ChangeLevelBy","parameters":[{"name":"p","type":"Creature *"},{"name":"level","type":"signed char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_Damage","parameters":[{"name":"p","type":"Creature *"},{"name":"damage","type":"unsigned int"},{"name":"source","type":"DamageSource"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_Heal","parameters":[{"name":"p","type":"Creature *"},{"name":"health","type":"unsigned int"},{"name":"canRevive","type":"bool"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_RestoreAllAttackUses","parameters":[{"name":"p","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetRealTalentIsSecret","parameters":[{"name":"p","type":"const Creature *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetRealTalentIndex","parameters":[{"name":"p","type":"const Creature *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetActiveTalent","parameters":[{"name":"p","type":"const Creature *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_OverrideActiveTalent","parameters":[{"name":"p","type":"Creature *"},{"name":"talent","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_AddExperience","parameters":[{"name":"p","type":"Creature *"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_ClearVolatileScripts","parameters":[{"name":"p","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_AddVolatileScriptByName","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_AddVolatileScript","parameters":[{"name":"p","type":"Creature *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_RemoveVolatileScriptByName","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_RemoveVolatileScript","parameters":[{"name":"p","type":"Creature *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_HasVolatileScript","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetAttacksCount","parameters":[{"name":"p","type":"Creature *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetAttacks","parameters":[{"name":"p","type":"Creature *"}],"returns":"const LearnedAttack * *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_HasAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetDisplaySpecies","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const CreatureSpecies *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetDisplayVariant","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const SpeciesVariant *"},{"filename":"CreatureLib","name":"CreatureLib_Creature_SetDisplaySpecies","parameters":[{"name":"p","type":"Creature *"},{"name":"species","type":"const CreatureSpecies *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Creature_SetDisplayVariant","parameters":[{"name":"p","type":"Creature *"},{"name":"variant","type":"const SpeciesVariant *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Creature_ChangeStatBoost","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"},{"name":"diffAmount","type":"signed char"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetFlatStat","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetBoostedStat","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetBaseStat","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetStatBoost","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"signed char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_GetAvailableAttackSlot","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_AddAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"attack","type":"LearnedAttack *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_ReplaceAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"index","type":"long unsigned int"},{"name":"attack","type":"LearnedAttack *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Creature_SwapAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"a","type":"long unsigned int"},{"name":"b","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_ConstructWithSize","parameters":[{"name":"size","type":"long unsigned int"}],"returns":"CreatureParty *"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_ConstructFromArray","parameters":[{"name":"creatures","type":"Creature * *"},{"name":"size","type":"long unsigned int"}],"returns":"CreatureParty *"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_Destruct","parameters":[{"name":"p","type":"const CreatureParty *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_GetAtIndex","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"const CreatureParty *"},{"name":"index","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_Switch","parameters":[{"name":"p","type":"CreatureParty *"},{"name":"a","type":"long unsigned int"},{"name":"b","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_PackParty","parameters":[{"name":"p","type":"CreatureParty *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_SwapInto","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"CreatureParty *"},{"name":"index","type":"long unsigned int"},{"name":"creature","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_HasAvailableCreatures","parameters":[{"name":"p","type":"const CreatureParty *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_GetLength","parameters":[{"name":"p","type":"const CreatureParty *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_CreatureParty_GetParty","parameters":[{"name":"p","type":"CreatureParty *"}],"returns":"const Creature * *"},{"filename":"CreatureLib","name":"CreatureLib_DamageLibrary_Construct","parameters":[],"returns":"const DamageLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_DamageLibrary_Destruct","parameters":[{"name":"p","type":"const DamageLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_DamageLibrary_GetDamage","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_DamageLibrary_GetBasePower","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_DamageLibrary_GetStatModifier","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_DamageLibrary_GetDamageModifier","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_EventData_Destruct","parameters":[{"name":"p","type":"const EventData *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_EventData_GetKind","parameters":[{"name":"p","type":"const EventData *"}],"returns":"EventDataKind"},{"filename":"CreatureLib","name":"CreatureLib_DamageEvent_GetCreature","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"Creature *"},{"filename":"CreatureLib","name":"CreatureLib_DamageEvent_GetDamageSource","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"DamageSource"},{"filename":"CreatureLib","name":"CreatureLib_DamageEvent_GetOriginalHealth","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_DamageEvent_GetNewHealth","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_DamageEvent_Destruct","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_HealEvent_GetCreature","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"Creature *"},{"filename":"CreatureLib","name":"CreatureLib_HealEvent_GetOriginalHealth","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_HealEvent_GetNewHealth","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_HealEvent_Destruct","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_FaintEvent_GetCreature","parameters":[{"name":"p","type":"const FaintEvent *"}],"returns":"Creature *"},{"filename":"CreatureLib","name":"CreatureLib_FaintEvent_Destruct","parameters":[{"name":"p","type":"const FaintEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_SwitchEvent_GetNewCreature","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"Creature *"},{"filename":"CreatureLib","name":"CreatureLib_SwitchEvent_GetSide","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SwitchEvent_GetIndex","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SwitchEvent_Destruct","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_TurnStartEvent_Destruct","parameters":[{"name":"p","type":"const TurnStartEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_TurnEndEvent_Destruct","parameters":[{"name":"p","type":"const TurnEndEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ExperienceGainEvent_GetCreature","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"const Creature *"},{"filename":"CreatureLib","name":"CreatureLib_ExperienceGainEvent_GetPreviousExperience","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_ExperienceGainEvent_GetNewExperience","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_ExperienceGainEvent_Destruct","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_MissEvent_GetCreature","parameters":[{"name":"p","type":"const MissEvent *"}],"returns":"const Creature *"},{"filename":"CreatureLib","name":"CreatureLib_MissEvent_Destruct","parameters":[{"name":"p","type":"const MissEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ChangeSpeciesEvent_GetCreature","parameters":[{"name":"p","type":"const ChangeSpeciesEvent *"}],"returns":"const Creature *"},{"filename":"CreatureLib","name":"CreatureLib_ChangeSpeciesEvent_GetNewSpecies","parameters":[{"name":"p","type":"const ChangeSpeciesEvent *"}],"returns":"const CreatureSpecies *"},{"filename":"CreatureLib","name":"CreatureLib_ChangeSpeciesEvent_Destruct","parameters":[{"name":"p","type":"const ChangeSpeciesEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ChangeVariantEvent_GetCreature","parameters":[{"name":"p","type":"const ChangeVariantEvent *"}],"returns":"const Creature *"},{"filename":"CreatureLib","name":"CreatureLib_ChangeVariantEvent_GetNewVariant","parameters":[{"name":"p","type":"const ChangeVariantEvent *"}],"returns":"const SpeciesVariant *"},{"filename":"CreatureLib","name":"CreatureLib_ChangeVariantEvent_Destruct","parameters":[{"name":"p","type":"const ChangeVariantEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_AttackUseEvent_GetAttack","parameters":[{"name":"p","type":"const AttackUseEvent *"}],"returns":"const ExecutingAttack *"},{"filename":"CreatureLib","name":"CreatureLib_AttackUseEvent_Destruct","parameters":[{"name":"p","type":"const AttackUseEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_DisplayTextEvent_GetText","parameters":[{"name":"p","type":"const DisplayTextEvent *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_DisplayTextEvent_Destruct","parameters":[{"name":"p","type":"const DisplayTextEvent *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_Construct","parameters":[{"name":"out","type":"ExecutingAttack * &"},{"name":"targets","type":"const Creature * *"},{"name":"targetCount","type":"long unsigned int"},{"name":"numberHits","type":"unsigned char"},{"name":"user","type":"Creature *"},{"name":"attack","type":"LearnedAttack *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_Destruct","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_GetNumberOfHits","parameters":[{"name":"p","type":"const ExecutingAttack *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_GetHitData","parameters":[{"name":"out","type":"HitData * &"},{"name":"p","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hit","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_IsCreatureTarget","parameters":[{"name":"p","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_GetTargetCount","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_GetTargets","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"const const Creature * *"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_GetUser","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"Creature *"},{"filename":"CreatureLib","name":"CreatureLib_ExecutingAttack_GetAttack","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"LearnedAttack *"},{"filename":"CreatureLib","name":"CreatureLib_HitData_IsCritical","parameters":[{"name":"p","type":"const HitData *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_HitData_GetBasePower","parameters":[{"name":"p","type":"const HitData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_HitData_GetEffectiveness","parameters":[{"name":"p","type":"const HitData *"}],"returns":"float"},{"filename":"CreatureLib","name":"CreatureLib_HitData_GetDamage","parameters":[{"name":"p","type":"const HitData *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_HitData_GetType","parameters":[{"name":"p","type":"const HitData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_HitData_SetCritical","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"bool"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_HitData_SetBasePower","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"unsigned char"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_HitData_SetEffectiveness","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"float"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_HitData_SetDamage","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"unsigned int"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_HitData_SetType","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"unsigned char"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ExperienceLibrary_Construct","parameters":[],"returns":"const ExperienceLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_ExperienceLibrary_Destruct","parameters":[{"name":"p","type":"const ExperienceLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ExperienceLibrary_HandleExperienceGain","parameters":[{"name":"p","type":"const ExperienceLibrary *"},{"name":"faintedMon","type":"Creature *"},{"name":"opponents","type":"Creature * *"},{"name":"opponentsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_HistoryHandler_GetTopElement","parameters":[{"name":"p","type":"const HistoryHolder *"}],"returns":"const HistoryElement *"},{"filename":"CreatureLib","name":"CreatureLib_HistoryHandler_GetLastUsedAttack","parameters":[{"name":"p","type":"const HistoryHolder *"}],"returns":"const HistoryElement *"},{"filename":"CreatureLib","name":"CreatureLib_HistoryElement_GetKind","parameters":[{"name":"p","type":"const HistoryElement *"}],"returns":"HistoryElementKind"},{"filename":"CreatureLib","name":"CreatureLib_HistoryElement_GetPrevious","parameters":[{"name":"p","type":"const HistoryElement *"}],"returns":"const HistoryElement *"},{"filename":"CreatureLib","name":"CreatureLib_AttackUseHistory_GetAttack","parameters":[{"name":"p","type":"const AttackUseHistory *"}],"returns":"const ExecutingAttack *"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_Construct","parameters":[{"name":"out","type":"LearnedAttack * &"},{"name":"attack","type":"const AttackData *"},{"name":"maxUses","type":"unsigned char"},{"name":"learnMethod","type":"AttackLearnMethod"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_Destruct","parameters":[{"name":"p","type":"LearnedAttack *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_GetAttack","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"const AttackData *"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_GetMaxUses","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_GetRemainingUses","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_GetLearnMethod","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"AttackLearnMethod"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_TryUse","parameters":[{"name":"p","type":"LearnedAttack *"},{"name":"uses","type":"unsigned char"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_DecreaseUses","parameters":[{"name":"p","type":"LearnedAttack *"},{"name":"uses","type":"unsigned char"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_RestoreUses","parameters":[{"name":"p","type":"LearnedAttack *"},{"name":"uses","type":"unsigned char"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_LearnedAttack_RestoreAllUses","parameters":[{"name":"p","type":"LearnedAttack *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_MiscLibrary_Construct","parameters":[],"returns":"MiscLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_MiscLibrary_Destruct","parameters":[{"name":"p","type":"const MiscLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_MiscLibrary_IsCritical","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"MiscLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hit","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_MiscLibrary_CanFlee","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"MiscLibrary *"},{"name":"switchChoice","type":"FleeTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_MiscLibrary_ReplacementAttack","parameters":[{"name":"out","type":"BaseTurnChoice * &"},{"name":"p","type":"MiscLibrary *"},{"name":"user","type":"Creature *"},{"name":"sideTarget","type":"unsigned char"},{"name":"creatureTarget","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_Destruct","parameters":[{"name":"p","type":"Script *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Script_Stack","parameters":[{"name":"p","type":"Script *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_OnRemove","parameters":[{"name":"p","type":"Script *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_GetName","parameters":[{"name":"p","type":"Script *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_Script_OnBeforeTurn","parameters":[{"name":"p","type":"Script *"},{"name":"choice","type":"const BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_ChangeAttack","parameters":[{"name":"p","type":"Script *"},{"name":"choice","type":"AttackTurnChoice *"},{"name":"outAttack","type":"const char * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_PreventAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_FailAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_StopBeforeAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_OnBeforeAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_FailIncomingAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_IsInvulnerable","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_OnAttackMiss","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_ChangeAttackType","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"outType","type":"unsigned char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_OverrideBasePower","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"basePower","type":"unsigned char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_ChangeDamageStatsUser","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"statsUser","type":"Creature * *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_BypassDefensiveStat","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"bypass","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_BypassOffensiveStat","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"bypass","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_ModifyStatModifier","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"modifier","type":"float *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_ModifyDamageModifier","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"modifier","type":"float *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_OverrideDamage","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"damage","type":"unsigned int *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_PreventSecondaryEffects","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_OnSecondaryEffect","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_OnAfterHits","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_PreventSelfSwitch","parameters":[{"name":"p","type":"Script *"},{"name":"choice","type":"const SwitchTurnChoice *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_ModifyEffectChance","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"const ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"chance","type":"float *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Script_ModifyIncomingEffectChance","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"const ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"chance","type":"float *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ScriptResolver_Construct","parameters":[],"returns":"ScriptResolver *"},{"filename":"CreatureLib","name":"CreatureLib_ScriptResolver_Destruct","parameters":[{"name":"p","type":"const ScriptResolver *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ScriptResolver_Initialize","parameters":[{"name":"p","type":"ScriptResolver *"},{"name":"library","type":"BattleLibrary *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ScriptResolver_LoadScript","parameters":[{"name":"out","type":"Script * &"},{"name":"p","type":"ScriptResolver *"},{"name":"category","type":"ScriptCategory"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"},{"name":"attack","type":"LearnedAttack *"},{"name":"sideIndex","type":"unsigned char"},{"name":"targetIndex","type":"unsigned char"}],"returns":"AttackTurnChoice *"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_FleeTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"}],"returns":"FleeTurnChoice *"},{"filename":"CreatureLib","name":"CreatureLib_FleeTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_PassTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"}],"returns":"PassTurnChoice *"},{"filename":"CreatureLib","name":"CreatureLib_PassTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_SwitchTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"},{"name":"newCreature","type":"Creature *"}],"returns":"SwitchTurnChoice *"},{"filename":"CreatureLib","name":"CreatureLib_SwitchTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_BaseTurnChoice_GetKind","parameters":[{"name":"p","type":"const BaseTurnChoice *"}],"returns":"TurnChoiceKind"},{"filename":"CreatureLib","name":"CreatureLib_BaseTurnChoice_GetUser","parameters":[{"name":"p","type":"const BaseTurnChoice *"}],"returns":"Creature *"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_GetAttack","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"LearnedAttack *"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_GetKind","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"TurnChoiceKind"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_GetPriority","parameters":[{"name":"out","type":"signed char &"},{"name":"p","type":"AttackTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_GetAttackScript","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"Script *"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_GetTargetSideIndex","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackTurnChoice_GetTargetCreatureIndex","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SwitchTurnChoice_GetNewCreature","parameters":[{"name":"p","type":"const SwitchTurnChoice *"}],"returns":"Creature *"},{"filename":"CreatureLib","name":"CreatureLib_C_GetLastException","parameters":[],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_C_GetLastExceptionStacktrace","parameters":[],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_Construct","parameters":[{"name":"out","type":"AttackData * &"},{"name":"name","type":"const char *"},{"name":"type","type":"unsigned char"},{"name":"category","type":"AttackCategory"},{"name":"power","type":"unsigned char"},{"name":"accuracy","type":"unsigned char"},{"name":"baseUsage","type":"unsigned char"},{"name":"target","type":"AttackTarget"},{"name":"priority","type":"signed char"},{"name":"effectChance","type":"float"},{"name":"effectName","type":"const char *"},{"name":"effectParameters","type":"EffectParameter * *"},{"name":"effectParameterCount","type":"long unsigned int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_Destruct","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetName","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetType","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetCategory","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"AttackCategory"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetBasePower","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetAccuracy","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetBaseUsages","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetTarget","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"AttackTarget"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetPriority","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"signed char"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_HasSecondaryEffect","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetSecondaryEffectChance","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"float"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_GetSecondaryEffectName","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_AttackData_HasFlag","parameters":[{"name":"p","type":"const AttackData *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_Construct","parameters":[{"name":"library","type":"AttackLibrary * &"},{"name":"initialCapacity","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_Destruct","parameters":[{"name":"p","type":"const AttackLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_Insert","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"},{"name":"t","type":"AttackData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_InsertWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"t","type":"AttackData *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_Delete","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_DeleteWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_TryGet","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const AttackData * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_TryGetWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const AttackData * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_Get","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const AttackData * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_GetWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const AttackData * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_GetCount","parameters":[{"name":"p","type":"AttackLibrary *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_AttackLibrary_GetAtIndex","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const AttackData * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_Construct","parameters":[{"name":"out","type":"CreatureSpecies * &"},{"name":"id","type":"unsigned short"},{"name":"name","type":"const char *"},{"name":"defaultVariant","type":"SpeciesVariant *"},{"name":"genderRatio","type":"float"},{"name":"growthRate","type":"const char *"},{"name":"captureRate","type":"unsigned char"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_Destruct","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetId","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"unsigned short"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetGenderRate","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"float"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetCaptureRate","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetName","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetGrowthRate","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_HasVariant","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"name","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_HasVariantWithHash","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"hash","type":"unsigned int"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_TryGetVariant","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"name","type":"const char *"},{"name":"out","type":"const SpeciesVariant * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_TryGetVariantWithHash","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"hash","type":"unsigned int"},{"name":"out","type":"const SpeciesVariant * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetVariant","parameters":[{"name":"out","type":"const SpeciesVariant * &"},{"name":"p","type":"const CreatureSpecies *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetVariantWithHash","parameters":[{"name":"out","type":"const SpeciesVariant * &"},{"name":"p","type":"const CreatureSpecies *"},{"name":"hash","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_SetVariant","parameters":[{"name":"p","type":"CreatureSpecies *"},{"name":"name","type":"const char *"},{"name":"variant","type":"SpeciesVariant *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetRandomGender","parameters":[{"name":"p","type":"CreatureSpecies *"},{"name":"random","type":"Random *"}],"returns":"Gender"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetVariantsCount","parameters":[{"name":"p","type":"CreatureSpecies *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_GetVariants","parameters":[{"name":"p","type":"CreatureSpecies *"}],"returns":"const const SpeciesVariant * *"},{"filename":"CreatureLib","name":"CreatureLib_CreatureSpecies_HasFlag","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_Construct","parameters":[{"name":"out","type":"const DataLibrary * &"},{"name":"settings","type":"LibrarySettings *"},{"name":"species","type":"SpeciesLibrary *"},{"name":"attacks","type":"AttackLibrary *"},{"name":"items","type":"ItemLibrary *"},{"name":"growthRates","type":"GrowthRateLibrary *"},{"name":"typeLibrary","type":"TypeLibrary *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_Destruct","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_GetSettings","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const LibrarySettings *"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_GetSpeciesLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const SpeciesLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_GetAttackLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const AttackLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_GetItemLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const ItemLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_GetGrowthRates","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const GrowthRateLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_DataLibrary_GetTypeLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const TypeLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_FromBool","parameters":[{"name":"b","type":"bool"}],"returns":"EffectParameter *"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_FromInt","parameters":[{"name":"i","type":"long int"}],"returns":"EffectParameter *"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_FromFloat","parameters":[{"name":"f","type":"float"}],"returns":"EffectParameter *"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_FromString","parameters":[{"name":"c","type":"const char *"}],"returns":"EffectParameter *"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_Destruct","parameters":[{"name":"p","type":"const EffectParameter *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_GetType","parameters":[{"name":"p","type":"const EffectParameter *"}],"returns":"EffectParameterType"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_AsBool","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"bool &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_AsInt","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"long int &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_AsFloat","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"float &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_EffectParameter_AsString","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_LookupGrowthRate_Construct","parameters":[{"name":"experiencePerLevel","type":"unsigned int *"},{"name":"count","type":"long unsigned int"}],"returns":"GrowthRate *"},{"filename":"CreatureLib","name":"CreatureLib_ExternGrowthRate_Construct","parameters":[{"name":"out","type":"GrowthRate * &"},{"name":"calcLevel","type":"Function *"},{"name":"calcExperience","type":"Function *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRate_Destruct","parameters":[{"name":"p","type":"const GrowthRate *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_LookupGrowthRate_Destruct","parameters":[{"name":"p","type":"const LookupGrowthRate *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ExternGrowthRate_Destruct","parameters":[{"name":"p","type":"const ExternGrowthRate *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRate_CalculateLevel","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"const GrowthRate *"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRate_CalculateExperience","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const GrowthRate *"},{"name":"level","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"GrowthRateLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_Destruct","parameters":[{"name":"p","type":"GrowthRateLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateLevel","parameters":[{"name":"out","type":"unsigned char &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRate","type":"const char *"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateLevelWithHash","parameters":[{"name":"out","type":"unsigned char &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateHash","type":"unsigned int"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateExperience","parameters":[{"name":"out","type":"unsigned int &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRate","type":"const char *"},{"name":"level","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash","parameters":[{"name":"out","type":"unsigned int &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateHash","type":"unsigned int"},{"name":"level","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_AddGrowthRate","parameters":[{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateName","type":"const char *"},{"name":"growthRate","type":"GrowthRate *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash","parameters":[{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateHash","type":"unsigned int"},{"name":"growthRate","type":"GrowthRate *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_Item_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"category","type":"ItemCategory"},{"name":"battleCategory","type":"BattleItemCategory"},{"name":"price","type":"int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"Item *"},{"filename":"CreatureLib","name":"CreatureLib_Item_Destruct","parameters":[{"name":"p","type":"const Item *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_Item_GetName","parameters":[{"name":"p","type":"const Item *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_Item_GetCategory","parameters":[{"name":"p","type":"const Item *"}],"returns":"ItemCategory"},{"filename":"CreatureLib","name":"CreatureLib_Item_GetBattleCategory","parameters":[{"name":"p","type":"const Item *"}],"returns":"BattleItemCategory"},{"filename":"CreatureLib","name":"CreatureLib_Item_GetPrice","parameters":[{"name":"p","type":"const Item *"}],"returns":"int"},{"filename":"CreatureLib","name":"CreatureLib_Item_HasFlag","parameters":[{"name":"p","type":"const Item *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"const ItemLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_Destruct","parameters":[{"name":"p","type":"const ItemLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_Insert","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"},{"name":"t","type":"Item *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_InsertWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"t","type":"Item *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_Delete","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_DeleteWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_TryGet","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const Item * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_TryGetWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const Item * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_Get","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const Item * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_GetWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const Item * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_GetCount","parameters":[{"name":"p","type":"ItemLibrary *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_ItemLibrary_GetAtIndex","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const Item * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_Construct","parameters":[{"name":"out","type":"LearnableAttacks * &"},{"name":"levelAttackCapacity","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_Destruct","parameters":[{"name":"p","type":"LearnableAttacks *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_AddLevelAttack","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"},{"name":"attack","type":"const AttackData *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_GetAttacksForLevel","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"}],"returns":"const const AttackData * *"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_HasAttacksForLevel","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_GetAttacksForLevelCount","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_GetDistinctLevelAttacksCount","parameters":[{"name":"p","type":"LearnableAttacks *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_LearnableAttacks_GetDistinctLevelAttacks","parameters":[{"name":"p","type":"LearnableAttacks *"}],"returns":"const const AttackData * *"},{"filename":"CreatureLib","name":"CreatureLib_LibrarySettings_Construct","parameters":[{"name":"maximalLevel","type":"unsigned char"},{"name":"maximalMoves","type":"unsigned char"}],"returns":"const LibrarySettings *"},{"filename":"CreatureLib","name":"CreatureLib_LibrarySettings_Destruct","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_LibrarySettings_GetMaximalLevel","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_LibrarySettings_GetMaximalAttacks","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"const SpeciesLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_Destruct","parameters":[{"name":"p","type":"const SpeciesLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_Insert","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"},{"name":"t","type":"CreatureSpecies *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_InsertWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"t","type":"CreatureSpecies *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_Delete","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_DeleteWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_TryGet","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_TryGetWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_Get","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_GetWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_GetCount","parameters":[{"name":"p","type":"SpeciesLibrary *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_GetAtIndex","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesLibrary_GetById","parameters":[{"name":"p","type":"const SpeciesLibrary *"},{"name":"id","type":"unsigned short"}],"returns":"const CreatureSpecies *"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"height","type":"float"},{"name":"weight","type":"float"},{"name":"baseExperience","type":"unsigned int"},{"name":"types","type":"unsigned char *"},{"name":"typeLength","type":"long unsigned int"},{"name":"baseHealth","type":"unsigned short"},{"name":"baseAttack","type":"unsigned short"},{"name":"baseDefense","type":"unsigned short"},{"name":"baseMagicalAttack","type":"unsigned short"},{"name":"baseMagicalDefense","type":"unsigned short"},{"name":"baseSpeed","type":"unsigned short"},{"name":"talents","type":"const char * *"},{"name":"talentsLength","type":"long unsigned int"},{"name":"secretTalents","type":"const char * *"},{"name":"secretTalentsLength","type":"long unsigned int"},{"name":"attacks","type":"const LearnableAttacks *"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"SpeciesVariant *"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_Destruct","parameters":[{"name":"p","type":"SpeciesVariant *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetName","parameters":[{"name":"p","type":"SpeciesVariant *"}],"returns":"const char *"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetHeight","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"float"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetWeight","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"float"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetBaseExperience","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetTypeCount","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetType","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"index","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetStatistic","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned short"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetTalentCount","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetSecretTalentCount","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"long unsigned int"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetTalent","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"secret","type":"bool"},{"name":"index","type":"unsigned char"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetLearnableAttacks","parameters":[{"name":"p","type":"SpeciesVariant *"}],"returns":"const LearnableAttacks *"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_GetRandomTalent","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"rand","type":"Random *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_SpeciesVariant_HasFlag","parameters":[{"name":"p","type":"const SpeciesVariant *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"TypeLibrary *"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_Destruct","parameters":[{"name":"p","type":"const TypeLibrary *"}],"returns":"void"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_GetTypeId","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"const TypeLibrary *"},{"name":"type","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_RegisterType","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"TypeLibrary *"},{"name":"type","type":"const char *"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_SetEffectiveness","parameters":[{"name":"p","type":"TypeLibrary *"},{"name":"attacking","type":"unsigned char"},{"name":"defensive","type":"unsigned char"},{"name":"effectiveness","type":"float"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_GetSingleEffectiveness","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"TypeLibrary *"},{"name":"attacking","type":"unsigned char"},{"name":"defensive","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_GetEffectiveness","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"TypeLibrary *"},{"name":"attacking","type":"unsigned char"},{"name":"defensive","type":"unsigned char *"},{"name":"defensiveCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"CreatureLib","name":"CreatureLib_TypeLibrary_GetTypeName","parameters":[{"name":"out","type":"const char * &"},{"name":"p","type":"TypeLibrary *"},{"name":"type","type":"unsigned char"}],"returns":"unsigned char"}]}
+{"enums":[{"byteSize":4,"filename":"libCreatureLib","name":"float_denorm_style","values":{"-1":"denorm_indeterminate","0":"denorm_absent","1":"denorm_present"}},{"byteSize":4,"filename":"libCreatureLib","name":"float_round_style","values":{"-1":"round_indeterminate","0":"round_toward_zero","1":"round_to_nearest","2":"round_toward_infinity","3":"round_toward_neg_infinity"}},{"byteSize":1,"filename":"libCreatureLib","name":"ScriptCategory","values":{"0":"Attack","1":"Talent","2":"Status","3":"Creature","4":"Battle","5":"Side"}},{"byteSize":1,"filename":"libCreatureLib","name":"Statistic","values":{"0":"Health","1":"PhysicalAttack","2":"PhysicalDefense","3":"MagicalAttack","4":"MagicalDefense","5":"Speed"}},{"byteSize":1,"filename":"libCreatureLib","name":"Gender","values":{"0":"Male","1":"Female","2":"Genderless"}},{"byteSize":1,"filename":"libCreatureLib","name":"DamageSource","values":{"0":"AttackDamage"}},{"byteSize":1,"filename":"libCreatureLib","name":"EventDataKind","values":{"0":"Damage","1":"Heal","10":"ChangeVariant","11":"AttackUse","2":"Faint","3":"Switch","4":"TurnStart","5":"TurnEnd","6":"ExperienceGain","7":"Miss","8":"DisplayText","9":"ChangeSpecies"}},{"byteSize":1,"filename":"libCreatureLib","name":"HistoryElementKind","values":{"0":"AttackUse"}},{"byteSize":4,"filename":"libCreatureLib","name":"AttackLearnMethod","values":{"0":"Unknown","1":"Level"}},{"byteSize":1,"filename":"libCreatureLib","name":"TurnChoiceKind","values":{"0":"Pass","1":"Attack","2":"Item","3":"Switch","4":"Flee"}},{"byteSize":1,"filename":"libCreatureLib","name":"EffectParameterType","values":{"0":"None","1":"Bool","2":"Int","3":"Float","4":"String"}},{"byteSize":1,"filename":"libCreatureLib","name":"AttackCategory","values":{"0":"Physical","1":"Magical","2":"Status"}},{"byteSize":1,"filename":"libCreatureLib","name":"AttackTarget","values":{"0":"Adjacent","1":"AdjacentAlly","10":"RandomOpponent","11":"Self","2":"AdjacentAllySelf","3":"AdjacentOpponent","4":"All","5":"AllAdjacent","6":"AllAdjacentOpponent","7":"AllAlly","8":"AllOpponent","9":"Any"}},{"byteSize":1,"filename":"libCreatureLib","name":"ItemCategory","values":{"0":"MiscItem","1":"CaptureDevice","2":"Medicine","3":"Berry","4":"MoveLearner","5":"VariantChanger","6":"KeyItem","7":"Mail"}},{"byteSize":1,"filename":"libCreatureLib","name":"BattleItemCategory","values":{"0":"None","1":"Healing","2":"StatusHealing","3":"CaptureDevice","4":"MiscBattleItem"}}],"functions":[{"filename":"libCreatureLib","name":"CreatureLib_Battle_Construct","parameters":[{"name":"out","type":"Battle * &"},{"name":"library","type":"const BattleLibrary *"},{"name":"partyArr","type":"BattleParty * *"},{"name":"numberOfParties","type":"long unsigned int"},{"name":"canFlee","type":"bool"},{"name":"numberOfSides","type":"unsigned char"},{"name":"creaturesPerSide","type":"unsigned char"},{"name":"randomSeed","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_Destruct","parameters":[{"name":"p","type":"const Battle *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetLibrary","parameters":[{"name":"p","type":"const Battle *"}],"returns":"const BattleLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_CanUse","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"Battle *"},{"name":"turnChoice","type":"BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_TrySetChoice","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"Battle *"},{"name":"turnChoice","type":"BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_CanFlee","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_CheckChoicesSetAndRun","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetCurrentTurn","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetCreaturesPerSide","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetCurrentTurnQueue","parameters":[{"name":"p","type":"const Battle *"}],"returns":"ChoiceQueue *"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetRandom","parameters":[{"name":"p","type":"Battle *"}],"returns":"BattleRandom *"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_CreatureInField","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"const Battle *"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetCreature","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"const Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_ForceRecall","parameters":[{"name":"p","type":"Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_SwitchCreature","parameters":[{"name":"p","type":"Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_CanSlotBeFilled","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"const Battle *"},{"name":"side","type":"unsigned char"},{"name":"target","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_ValidateBattleState","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_HasEnded","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_HasConclusiveResult","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetWinningSide","parameters":[{"name":"p","type":"const Battle *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetSidesCount","parameters":[{"name":"p","type":"const Battle *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetSides","parameters":[{"name":"p","type":"const Battle *"}],"returns":"const BattleSide * *"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetPartiesCount","parameters":[{"name":"p","type":"const Battle *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetParties","parameters":[{"name":"p","type":"const Battle *"}],"returns":"const BattleParty * *"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"Script *"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_AddVolatileScriptByName","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_AddVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_RemoveVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_RemoveVolatileScriptWithScript","parameters":[{"name":"p","type":"Battle *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_HasVolatileScript","parameters":[{"name":"p","type":"Battle *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_RegisterEventListener","parameters":[{"name":"p","type":"Battle *"},{"name":"func","type":"Function *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetHistory","parameters":[{"name":"p","type":"Battle *"}],"returns":"const HistoryHolder *"},{"filename":"libCreatureLib","name":"CreatureLib_Battle_GetLastTurnTimeMicroseconds","parameters":[{"name":"p","type":"const Battle *"}],"returns":"long int"},{"filename":"libCreatureLib","name":"CreatureLib_BattleLibrary_Construct","parameters":[{"name":"out","type":"const BattleLibrary * &"},{"name":"staticLib","type":"const DataLibrary *"},{"name":"statCalculator","type":"BattleStatCalculator *"},{"name":"damageLibrary","type":"DamageLibrary *"},{"name":"experienceLibrary","type":"ExperienceLibrary *"},{"name":"scriptResolver","type":"ScriptResolver *"},{"name":"miscLibrary","type":"MiscLibrary *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleLibrary_Destruct","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BattleLibrary_GetStaticLib","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const DataLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleLibrary_GetStatCalculator","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const BattleStatCalculator *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleLibrary_GetDamageLibrary","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const DamageLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleLibrary_GetMiscLibrary","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const MiscLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleLibrary_GetExperienceLibrary","parameters":[{"name":"p","type":"const BattleLibrary *"}],"returns":"const ExperienceLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleParty_Construct","parameters":[{"name":"out","type":"BattleParty * &"},{"name":"p","type":"CreatureParty *"},{"name":"creatureIndices","type":"unsigned char *"},{"name":"numberOfIndices","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleParty_Destruct","parameters":[{"name":"p","type":"const BattleParty *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BattleParty_GetParty","parameters":[{"name":"p","type":"const BattleParty *"}],"returns":"CreatureParty *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleParty_IsResponsibleForIndex","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"const BattleParty *"},{"name":"side","type":"unsigned char"},{"name":"creature","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleParty_HasCreaturesNotInField","parameters":[{"name":"p","type":"const BattleParty *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_Construct","parameters":[],"returns":"BattleRandom *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_ConstructWithSeed","parameters":[{"name":"seed","type":"long unsigned int"}],"returns":"BattleRandom *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_Destruct","parameters":[{"name":"p","type":"BattleRandom *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_EffectChance","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"BattleRandom *"},{"name":"chance","type":"float"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_Get","parameters":[{"name":"p","type":"BattleRandom *"}],"returns":"int"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_GetMax","parameters":[{"name":"p","type":"BattleRandom *"},{"name":"max","type":"int"}],"returns":"int"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_GetMinMax","parameters":[{"name":"p","type":"BattleRandom *"},{"name":"min","type":"int"},{"name":"max","type":"int"}],"returns":"int"},{"filename":"libCreatureLib","name":"CreatureLib_BattleRandom_GetSeed","parameters":[{"name":"p","type":"BattleRandom *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_Construct","parameters":[{"name":"index","type":"unsigned char"},{"name":"battle","type":"Battle *"},{"name":"creaturesPerSide","type":"unsigned char"}],"returns":"BattleSide *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_Destruct","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_AllChoicesSet","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_AllPossibleSlotsFilled","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"BattleSide *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_SetChoice","parameters":[{"name":"p","type":"BattleSide *"},{"name":"choice","type":"BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_ResetChoices","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_SetCreature","parameters":[{"name":"p","type":"BattleSide *"},{"name":"creature","type":"Creature *"},{"name":"index","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_GetCreature","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"BattleSide *"},{"name":"index","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_GetSideIndex","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_GetCreatureIndex","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"BattleSide *"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_MarkSlotAsUnfillable","parameters":[{"name":"p","type":"BattleSide *"},{"name":"c","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_IsDefeated","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_HasFled","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_BattleSide_MarkAsFled","parameters":[{"name":"p","type":"BattleSide *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BattleStatCalculator_Construct","parameters":[],"returns":"const BattleStatCalculator *"},{"filename":"libCreatureLib","name":"CreatureLib_BattleStatCalculator_Destruct","parameters":[{"name":"p","type":"const BattleStatCalculator *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BattleStatCalculator_CalculateFlatStat","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const BattleStatCalculator *"},{"name":"creature","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_BattleStatCalculator_CalculateBoostedStat","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const BattleStatCalculator *"},{"name":"creature","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_Construct","parameters":[{"name":"out","type":"Creature * &"},{"name":"library","type":"const BattleLibrary *"},{"name":"species","type":"const CreatureSpecies *"},{"name":"variant","type":"const SpeciesVariant *"},{"name":"level","type":"unsigned char"},{"name":"experience","type":"unsigned int"},{"name":"uid","type":"unsigned int"},{"name":"gender","type":"Gender"},{"name":"coloring","type":"unsigned char"},{"name":"heldItem","type":"const Item *"},{"name":"nickname","type":"const char *"},{"name":"secretTalent","type":"bool"},{"name":"talent","type":"unsigned char"},{"name":"attacks","type":"LearnedAttack * *"},{"name":"attacksNum","type":"long unsigned int"},{"name":"allowedExperienceGain","type":"bool"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_Destruct","parameters":[{"name":"p","type":"const Creature *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_Initialize","parameters":[{"name":"p","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetLibrary","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const BattleLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetSpecies","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const CreatureSpecies *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetVariant","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const SpeciesVariant *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_ChangeSpecies","parameters":[{"name":"p","type":"Creature *"},{"name":"species","type":"const CreatureSpecies *"},{"name":"variant","type":"const SpeciesVariant *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_ChangeVariant","parameters":[{"name":"p","type":"Creature *"},{"name":"variant","type":"const SpeciesVariant *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetLevel","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetExperience","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetUniqueIdentifier","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetGender","parameters":[{"name":"p","type":"const Creature *"}],"returns":"Gender"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetColoring","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_HasHeldItem","parameters":[{"name":"p","type":"const Creature *"},{"name":"name","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_HasHeldItemWithHash","parameters":[{"name":"p","type":"const Creature *"},{"name":"hash","type":"unsigned int"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetHeldItem","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const Item *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_SetHeldItem","parameters":[{"name":"p","type":"Creature *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_SetHeldItemWithHash","parameters":[{"name":"p","type":"Creature *"},{"name":"hash","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_SetHeldItemFromItem","parameters":[{"name":"p","type":"Creature *"},{"name":"item","type":"const Item *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetCurrentHealth","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetBattle","parameters":[{"name":"p","type":"const Creature *"}],"returns":"Battle *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetBattleSide","parameters":[{"name":"p","type":"const Creature *"}],"returns":"BattleSide *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_IsOnBattleField","parameters":[{"name":"p","type":"const Creature *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetNickname","parameters":[{"name":"p","type":"Creature *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_HasType","parameters":[{"name":"p","type":"Creature *"},{"name":"type","type":"unsigned char"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetMaxHealth","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_ChangeLevelBy","parameters":[{"name":"p","type":"Creature *"},{"name":"level","type":"signed char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_Damage","parameters":[{"name":"p","type":"Creature *"},{"name":"damage","type":"unsigned int"},{"name":"source","type":"DamageSource"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_Heal","parameters":[{"name":"p","type":"Creature *"},{"name":"health","type":"unsigned int"},{"name":"canRevive","type":"bool"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_RestoreAllAttackUses","parameters":[{"name":"p","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetRealTalentIsSecret","parameters":[{"name":"p","type":"const Creature *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetRealTalentIndex","parameters":[{"name":"p","type":"const Creature *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetActiveTalent","parameters":[{"name":"p","type":"const Creature *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_OverrideActiveTalent","parameters":[{"name":"p","type":"Creature *"},{"name":"talent","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_AddExperience","parameters":[{"name":"p","type":"Creature *"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_ClearVolatileScripts","parameters":[{"name":"p","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_AddVolatileScriptByName","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_AddVolatileScript","parameters":[{"name":"p","type":"Creature *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_RemoveVolatileScriptByName","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_RemoveVolatileScript","parameters":[{"name":"p","type":"Creature *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_HasVolatileScript","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetAttacksCount","parameters":[{"name":"p","type":"Creature *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetAttacks","parameters":[{"name":"p","type":"Creature *"}],"returns":"const LearnedAttack * *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_HasAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"scriptName","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetDisplaySpecies","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const CreatureSpecies *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetDisplayVariant","parameters":[{"name":"p","type":"const Creature *"}],"returns":"const SpeciesVariant *"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_SetDisplaySpecies","parameters":[{"name":"p","type":"Creature *"},{"name":"species","type":"const CreatureSpecies *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_SetDisplayVariant","parameters":[{"name":"p","type":"Creature *"},{"name":"variant","type":"const SpeciesVariant *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_ChangeStatBoost","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"},{"name":"diffAmount","type":"signed char"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetFlatStat","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetBoostedStat","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetBaseStat","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetStatBoost","parameters":[{"name":"p","type":"Creature *"},{"name":"stat","type":"Statistic"}],"returns":"signed char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_GetAvailableAttackSlot","parameters":[{"name":"p","type":"const Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_AddAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"attack","type":"LearnedAttack *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_ReplaceAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"index","type":"long unsigned int"},{"name":"attack","type":"LearnedAttack *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Creature_SwapAttack","parameters":[{"name":"p","type":"Creature *"},{"name":"a","type":"long unsigned int"},{"name":"b","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_ConstructWithSize","parameters":[{"name":"size","type":"long unsigned int"}],"returns":"CreatureParty *"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_ConstructFromArray","parameters":[{"name":"creatures","type":"Creature * *"},{"name":"size","type":"long unsigned int"}],"returns":"CreatureParty *"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_Destruct","parameters":[{"name":"p","type":"const CreatureParty *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_GetAtIndex","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"const CreatureParty *"},{"name":"index","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_Switch","parameters":[{"name":"p","type":"CreatureParty *"},{"name":"a","type":"long unsigned int"},{"name":"b","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_PackParty","parameters":[{"name":"p","type":"CreatureParty *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_SwapInto","parameters":[{"name":"out","type":"Creature * &"},{"name":"p","type":"CreatureParty *"},{"name":"index","type":"long unsigned int"},{"name":"creature","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_HasAvailableCreatures","parameters":[{"name":"p","type":"const CreatureParty *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_GetLength","parameters":[{"name":"p","type":"const CreatureParty *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureParty_GetParty","parameters":[{"name":"p","type":"CreatureParty *"}],"returns":"const Creature * *"},{"filename":"libCreatureLib","name":"CreatureLib_DamageLibrary_Construct","parameters":[],"returns":"const DamageLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_DamageLibrary_Destruct","parameters":[{"name":"p","type":"const DamageLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_DamageLibrary_GetDamage","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_DamageLibrary_GetBasePower","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_DamageLibrary_GetStatModifier","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_DamageLibrary_GetDamageModifier","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"const DamageLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitIndex","type":"unsigned char"},{"name":"hitData","type":"HitData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_EventData_Destruct","parameters":[{"name":"p","type":"const EventData *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_EventData_GetKind","parameters":[{"name":"p","type":"const EventData *"}],"returns":"EventDataKind"},{"filename":"libCreatureLib","name":"CreatureLib_DamageEvent_GetCreature","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_DamageEvent_GetDamageSource","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"DamageSource"},{"filename":"libCreatureLib","name":"CreatureLib_DamageEvent_GetOriginalHealth","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_DamageEvent_GetNewHealth","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_DamageEvent_Destruct","parameters":[{"name":"p","type":"const DamageEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_HealEvent_GetCreature","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_HealEvent_GetOriginalHealth","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_HealEvent_GetNewHealth","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_HealEvent_Destruct","parameters":[{"name":"p","type":"const HealEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_FaintEvent_GetCreature","parameters":[{"name":"p","type":"const FaintEvent *"}],"returns":"Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_FaintEvent_Destruct","parameters":[{"name":"p","type":"const FaintEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_SwitchEvent_GetNewCreature","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_SwitchEvent_GetSide","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SwitchEvent_GetIndex","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SwitchEvent_Destruct","parameters":[{"name":"p","type":"const SwitchEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_TurnStartEvent_Destruct","parameters":[{"name":"p","type":"const TurnStartEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_TurnEndEvent_Destruct","parameters":[{"name":"p","type":"const TurnEndEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ExperienceGainEvent_GetCreature","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"const Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_ExperienceGainEvent_GetPreviousExperience","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_ExperienceGainEvent_GetNewExperience","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_ExperienceGainEvent_Destruct","parameters":[{"name":"p","type":"const ExperienceGainEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_MissEvent_GetCreature","parameters":[{"name":"p","type":"const MissEvent *"}],"returns":"const Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_MissEvent_Destruct","parameters":[{"name":"p","type":"const MissEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ChangeSpeciesEvent_GetCreature","parameters":[{"name":"p","type":"const ChangeSpeciesEvent *"}],"returns":"const Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_ChangeSpeciesEvent_GetNewSpecies","parameters":[{"name":"p","type":"const ChangeSpeciesEvent *"}],"returns":"const CreatureSpecies *"},{"filename":"libCreatureLib","name":"CreatureLib_ChangeSpeciesEvent_Destruct","parameters":[{"name":"p","type":"const ChangeSpeciesEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ChangeVariantEvent_GetCreature","parameters":[{"name":"p","type":"const ChangeVariantEvent *"}],"returns":"const Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_ChangeVariantEvent_GetNewVariant","parameters":[{"name":"p","type":"const ChangeVariantEvent *"}],"returns":"const SpeciesVariant *"},{"filename":"libCreatureLib","name":"CreatureLib_ChangeVariantEvent_Destruct","parameters":[{"name":"p","type":"const ChangeVariantEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_AttackUseEvent_GetAttack","parameters":[{"name":"p","type":"const AttackUseEvent *"}],"returns":"const ExecutingAttack *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackUseEvent_Destruct","parameters":[{"name":"p","type":"const AttackUseEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_DisplayTextEvent_GetText","parameters":[{"name":"p","type":"const DisplayTextEvent *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_DisplayTextEvent_Destruct","parameters":[{"name":"p","type":"const DisplayTextEvent *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_Construct","parameters":[{"name":"out","type":"ExecutingAttack * &"},{"name":"targets","type":"const Creature * *"},{"name":"targetCount","type":"long unsigned int"},{"name":"numberHits","type":"unsigned char"},{"name":"user","type":"Creature *"},{"name":"attack","type":"LearnedAttack *"},{"name":"script","type":"Script *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_Destruct","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_GetNumberOfHits","parameters":[{"name":"p","type":"const ExecutingAttack *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_GetHitData","parameters":[{"name":"out","type":"HitData * &"},{"name":"p","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hit","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_IsCreatureTarget","parameters":[{"name":"p","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_GetTargetCount","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_GetTargets","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"const const Creature * *"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_GetUser","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_ExecutingAttack_GetAttack","parameters":[{"name":"p","type":"ExecutingAttack *"}],"returns":"LearnedAttack *"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_IsCritical","parameters":[{"name":"p","type":"const HitData *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_GetBasePower","parameters":[{"name":"p","type":"const HitData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_GetEffectiveness","parameters":[{"name":"p","type":"const HitData *"}],"returns":"float"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_GetDamage","parameters":[{"name":"p","type":"const HitData *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_GetType","parameters":[{"name":"p","type":"const HitData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_SetCritical","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"bool"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_SetBasePower","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"unsigned char"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_SetEffectiveness","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"float"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_SetDamage","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"unsigned int"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_HitData_SetType","parameters":[{"name":"p","type":"HitData *"},{"name":"val","type":"unsigned char"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ExperienceLibrary_Construct","parameters":[],"returns":"const ExperienceLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_ExperienceLibrary_Destruct","parameters":[{"name":"p","type":"const ExperienceLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ExperienceLibrary_HandleExperienceGain","parameters":[{"name":"p","type":"const ExperienceLibrary *"},{"name":"faintedMon","type":"Creature *"},{"name":"opponents","type":"Creature * *"},{"name":"opponentsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_HistoryHandler_GetTopElement","parameters":[{"name":"p","type":"const HistoryHolder *"}],"returns":"const HistoryElement *"},{"filename":"libCreatureLib","name":"CreatureLib_HistoryHandler_GetLastUsedAttack","parameters":[{"name":"p","type":"const HistoryHolder *"}],"returns":"const HistoryElement *"},{"filename":"libCreatureLib","name":"CreatureLib_HistoryElement_GetKind","parameters":[{"name":"p","type":"const HistoryElement *"}],"returns":"HistoryElementKind"},{"filename":"libCreatureLib","name":"CreatureLib_HistoryElement_GetPrevious","parameters":[{"name":"p","type":"const HistoryElement *"}],"returns":"const HistoryElement *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackUseHistory_GetAttack","parameters":[{"name":"p","type":"const AttackUseHistory *"}],"returns":"const ExecutingAttack *"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_Construct","parameters":[{"name":"out","type":"LearnedAttack * &"},{"name":"attack","type":"const AttackData *"},{"name":"maxUses","type":"unsigned char"},{"name":"learnMethod","type":"AttackLearnMethod"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_Destruct","parameters":[{"name":"p","type":"LearnedAttack *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_GetAttack","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"const AttackData *"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_GetMaxUses","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_GetRemainingUses","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_GetLearnMethod","parameters":[{"name":"p","type":"const LearnedAttack *"}],"returns":"AttackLearnMethod"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_TryUse","parameters":[{"name":"p","type":"LearnedAttack *"},{"name":"uses","type":"unsigned char"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_DecreaseUses","parameters":[{"name":"p","type":"LearnedAttack *"},{"name":"uses","type":"unsigned char"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_RestoreUses","parameters":[{"name":"p","type":"LearnedAttack *"},{"name":"uses","type":"unsigned char"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_LearnedAttack_RestoreAllUses","parameters":[{"name":"p","type":"LearnedAttack *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_MiscLibrary_Construct","parameters":[],"returns":"MiscLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_MiscLibrary_Destruct","parameters":[{"name":"p","type":"const MiscLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_MiscLibrary_IsCritical","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"MiscLibrary *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hit","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_MiscLibrary_CanFlee","parameters":[{"name":"out","type":"bool &"},{"name":"p","type":"MiscLibrary *"},{"name":"switchChoice","type":"FleeTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_MiscLibrary_ReplacementAttack","parameters":[{"name":"out","type":"BaseTurnChoice * &"},{"name":"p","type":"MiscLibrary *"},{"name":"user","type":"Creature *"},{"name":"sideTarget","type":"unsigned char"},{"name":"creatureTarget","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_Destruct","parameters":[{"name":"p","type":"Script *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Script_Stack","parameters":[{"name":"p","type":"Script *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OnRemove","parameters":[{"name":"p","type":"Script *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_GetName","parameters":[{"name":"p","type":"Script *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OnBeforeTurn","parameters":[{"name":"p","type":"Script *"},{"name":"choice","type":"const BaseTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_ChangeAttack","parameters":[{"name":"p","type":"Script *"},{"name":"choice","type":"AttackTurnChoice *"},{"name":"outAttack","type":"const char * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_PreventAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_FailAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_StopBeforeAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OnBeforeAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_FailIncomingAttack","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_IsInvulnerable","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OnAttackMiss","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_ChangeAttackType","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"outType","type":"unsigned char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OverrideBasePower","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"basePower","type":"unsigned char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_ChangeDamageStatsUser","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"statsUser","type":"Creature * *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_BypassDefensiveStat","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"bypass","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_BypassOffensiveStat","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"bypass","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_ModifyStatModifier","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"modifier","type":"float *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_ModifyDamageModifier","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"modifier","type":"float *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OverrideDamage","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"damage","type":"unsigned int *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_PreventSecondaryEffects","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OnSecondaryEffect","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hitNumber","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_OnAfterHits","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_PreventSelfSwitch","parameters":[{"name":"p","type":"Script *"},{"name":"choice","type":"const SwitchTurnChoice *"},{"name":"outResult","type":"bool *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_ModifyEffectChance","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"const ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"chance","type":"float *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Script_ModifyIncomingEffectChance","parameters":[{"name":"p","type":"Script *"},{"name":"attack","type":"const ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"chance","type":"float *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ScriptResolver_Construct","parameters":[],"returns":"ScriptResolver *"},{"filename":"libCreatureLib","name":"CreatureLib_ScriptResolver_Destruct","parameters":[{"name":"p","type":"const ScriptResolver *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ScriptResolver_Initialize","parameters":[{"name":"p","type":"ScriptResolver *"},{"name":"library","type":"BattleLibrary *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ScriptResolver_LoadScript","parameters":[{"name":"out","type":"Script * &"},{"name":"p","type":"ScriptResolver *"},{"name":"category","type":"ScriptCategory"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"},{"name":"attack","type":"LearnedAttack *"},{"name":"sideIndex","type":"unsigned char"},{"name":"targetIndex","type":"unsigned char"}],"returns":"AttackTurnChoice *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_FleeTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"}],"returns":"FleeTurnChoice *"},{"filename":"libCreatureLib","name":"CreatureLib_FleeTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_PassTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"}],"returns":"PassTurnChoice *"},{"filename":"libCreatureLib","name":"CreatureLib_PassTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_SwitchTurnChoice_Construct","parameters":[{"name":"user","type":"Creature *"},{"name":"newCreature","type":"Creature *"}],"returns":"SwitchTurnChoice *"},{"filename":"libCreatureLib","name":"CreatureLib_SwitchTurnChoice_Destruct","parameters":[{"name":"p","type":"AttackTurnChoice *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_BaseTurnChoice_GetKind","parameters":[{"name":"p","type":"const BaseTurnChoice *"}],"returns":"TurnChoiceKind"},{"filename":"libCreatureLib","name":"CreatureLib_BaseTurnChoice_GetUser","parameters":[{"name":"p","type":"const BaseTurnChoice *"}],"returns":"Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_GetAttack","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"LearnedAttack *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_GetKind","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"TurnChoiceKind"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_GetPriority","parameters":[{"name":"out","type":"signed char &"},{"name":"p","type":"AttackTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_GetAttackScript","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"Script *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_GetTargetSideIndex","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackTurnChoice_GetTargetCreatureIndex","parameters":[{"name":"p","type":"const AttackTurnChoice *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SwitchTurnChoice_GetNewCreature","parameters":[{"name":"p","type":"const SwitchTurnChoice *"}],"returns":"Creature *"},{"filename":"libCreatureLib","name":"CreatureLib_C_GetLastException","parameters":[],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_C_GetLastExceptionStacktrace","parameters":[],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_Construct","parameters":[{"name":"out","type":"AttackData * &"},{"name":"name","type":"const char *"},{"name":"type","type":"unsigned char"},{"name":"category","type":"AttackCategory"},{"name":"power","type":"unsigned char"},{"name":"accuracy","type":"unsigned char"},{"name":"baseUsage","type":"unsigned char"},{"name":"target","type":"AttackTarget"},{"name":"priority","type":"signed char"},{"name":"effectChance","type":"float"},{"name":"effectName","type":"const char *"},{"name":"effectParameters","type":"EffectParameter * *"},{"name":"effectParameterCount","type":"long unsigned int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_Destruct","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetName","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetType","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetCategory","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"AttackCategory"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetBasePower","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetAccuracy","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetBaseUsages","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetTarget","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"AttackTarget"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetPriority","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"signed char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_HasSecondaryEffect","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetSecondaryEffectChance","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"float"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_GetSecondaryEffectName","parameters":[{"name":"p","type":"const AttackData *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_AttackData_HasFlag","parameters":[{"name":"p","type":"const AttackData *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_Construct","parameters":[{"name":"library","type":"AttackLibrary * &"},{"name":"initialCapacity","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_Destruct","parameters":[{"name":"p","type":"const AttackLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_Insert","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"},{"name":"t","type":"AttackData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_InsertWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"t","type":"AttackData *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_Delete","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_DeleteWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_TryGet","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const AttackData * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_TryGetWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const AttackData * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_Get","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const AttackData * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_GetWithHash","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const AttackData * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_GetCount","parameters":[{"name":"p","type":"AttackLibrary *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_AttackLibrary_GetAtIndex","parameters":[{"name":"p","type":"AttackLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const AttackData * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_Construct","parameters":[{"name":"out","type":"CreatureSpecies * &"},{"name":"id","type":"unsigned short"},{"name":"name","type":"const char *"},{"name":"defaultVariant","type":"SpeciesVariant *"},{"name":"genderRatio","type":"float"},{"name":"growthRate","type":"const char *"},{"name":"captureRate","type":"unsigned char"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_Destruct","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetId","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"unsigned short"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetGenderRate","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"float"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetCaptureRate","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetName","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetGrowthRate","parameters":[{"name":"p","type":"const CreatureSpecies *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_HasVariant","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"name","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_HasVariantWithHash","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"hash","type":"unsigned int"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_TryGetVariant","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"name","type":"const char *"},{"name":"out","type":"const SpeciesVariant * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_TryGetVariantWithHash","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"hash","type":"unsigned int"},{"name":"out","type":"const SpeciesVariant * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetVariant","parameters":[{"name":"out","type":"const SpeciesVariant * &"},{"name":"p","type":"const CreatureSpecies *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetVariantWithHash","parameters":[{"name":"out","type":"const SpeciesVariant * &"},{"name":"p","type":"const CreatureSpecies *"},{"name":"hash","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_SetVariant","parameters":[{"name":"p","type":"CreatureSpecies *"},{"name":"name","type":"const char *"},{"name":"variant","type":"SpeciesVariant *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetRandomGender","parameters":[{"name":"p","type":"CreatureSpecies *"},{"name":"random","type":"Random *"}],"returns":"Gender"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetVariantsCount","parameters":[{"name":"p","type":"CreatureSpecies *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_GetVariants","parameters":[{"name":"p","type":"CreatureSpecies *"}],"returns":"const const SpeciesVariant * *"},{"filename":"libCreatureLib","name":"CreatureLib_CreatureSpecies_HasFlag","parameters":[{"name":"p","type":"const CreatureSpecies *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_Construct","parameters":[{"name":"out","type":"const DataLibrary * &"},{"name":"settings","type":"LibrarySettings *"},{"name":"species","type":"SpeciesLibrary *"},{"name":"attacks","type":"AttackLibrary *"},{"name":"items","type":"ItemLibrary *"},{"name":"growthRates","type":"GrowthRateLibrary *"},{"name":"typeLibrary","type":"TypeLibrary *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_Destruct","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_GetSettings","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const LibrarySettings *"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_GetSpeciesLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const SpeciesLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_GetAttackLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const AttackLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_GetItemLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const ItemLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_GetGrowthRates","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const GrowthRateLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_DataLibrary_GetTypeLibrary","parameters":[{"name":"p","type":"const DataLibrary *"}],"returns":"const TypeLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_FromBool","parameters":[{"name":"b","type":"bool"}],"returns":"EffectParameter *"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_FromInt","parameters":[{"name":"i","type":"long int"}],"returns":"EffectParameter *"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_FromFloat","parameters":[{"name":"f","type":"float"}],"returns":"EffectParameter *"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_FromString","parameters":[{"name":"c","type":"const char *"}],"returns":"EffectParameter *"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_Destruct","parameters":[{"name":"p","type":"const EffectParameter *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_GetType","parameters":[{"name":"p","type":"const EffectParameter *"}],"returns":"EffectParameterType"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_AsBool","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"bool &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_AsInt","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"long int &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_AsFloat","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"float &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_EffectParameter_AsString","parameters":[{"name":"p","type":"const EffectParameter *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_LookupGrowthRate_Construct","parameters":[{"name":"experiencePerLevel","type":"unsigned int *"},{"name":"count","type":"long unsigned int"}],"returns":"GrowthRate *"},{"filename":"libCreatureLib","name":"CreatureLib_ExternGrowthRate_Construct","parameters":[{"name":"out","type":"GrowthRate * &"},{"name":"calcLevel","type":"Function *"},{"name":"calcExperience","type":"Function *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRate_Destruct","parameters":[{"name":"p","type":"const GrowthRate *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_LookupGrowthRate_Destruct","parameters":[{"name":"p","type":"const LookupGrowthRate *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ExternGrowthRate_Destruct","parameters":[{"name":"p","type":"const ExternGrowthRate *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRate_CalculateLevel","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"const GrowthRate *"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRate_CalculateExperience","parameters":[{"name":"out","type":"unsigned int &"},{"name":"p","type":"const GrowthRate *"},{"name":"level","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"GrowthRateLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_Destruct","parameters":[{"name":"p","type":"GrowthRateLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateLevel","parameters":[{"name":"out","type":"unsigned char &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRate","type":"const char *"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateLevelWithHash","parameters":[{"name":"out","type":"unsigned char &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateHash","type":"unsigned int"},{"name":"experience","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateExperience","parameters":[{"name":"out","type":"unsigned int &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRate","type":"const char *"},{"name":"level","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash","parameters":[{"name":"out","type":"unsigned int &"},{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateHash","type":"unsigned int"},{"name":"level","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_AddGrowthRate","parameters":[{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateName","type":"const char *"},{"name":"growthRate","type":"GrowthRate *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash","parameters":[{"name":"library","type":"GrowthRateLibrary *"},{"name":"growthRateHash","type":"unsigned int"},{"name":"growthRate","type":"GrowthRate *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_Item_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"category","type":"ItemCategory"},{"name":"battleCategory","type":"BattleItemCategory"},{"name":"price","type":"int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"Item *"},{"filename":"libCreatureLib","name":"CreatureLib_Item_Destruct","parameters":[{"name":"p","type":"const Item *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_Item_GetName","parameters":[{"name":"p","type":"const Item *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_Item_GetCategory","parameters":[{"name":"p","type":"const Item *"}],"returns":"ItemCategory"},{"filename":"libCreatureLib","name":"CreatureLib_Item_GetBattleCategory","parameters":[{"name":"p","type":"const Item *"}],"returns":"BattleItemCategory"},{"filename":"libCreatureLib","name":"CreatureLib_Item_GetPrice","parameters":[{"name":"p","type":"const Item *"}],"returns":"int"},{"filename":"libCreatureLib","name":"CreatureLib_Item_HasFlag","parameters":[{"name":"p","type":"const Item *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"const ItemLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_Destruct","parameters":[{"name":"p","type":"const ItemLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_Insert","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"},{"name":"t","type":"Item *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_InsertWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"t","type":"Item *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_Delete","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_DeleteWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_TryGet","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const Item * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_TryGetWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const Item * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_Get","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const Item * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_GetWithHash","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const Item * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_GetCount","parameters":[{"name":"p","type":"ItemLibrary *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_ItemLibrary_GetAtIndex","parameters":[{"name":"p","type":"ItemLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const Item * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_Construct","parameters":[{"name":"out","type":"LearnableAttacks * &"},{"name":"levelAttackCapacity","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_Destruct","parameters":[{"name":"p","type":"LearnableAttacks *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_AddLevelAttack","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"},{"name":"attack","type":"const AttackData *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_GetAttacksForLevel","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"}],"returns":"const const AttackData * *"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_HasAttacksForLevel","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_GetAttacksForLevelCount","parameters":[{"name":"p","type":"LearnableAttacks *"},{"name":"level","type":"unsigned char"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_GetDistinctLevelAttacksCount","parameters":[{"name":"p","type":"LearnableAttacks *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_LearnableAttacks_GetDistinctLevelAttacks","parameters":[{"name":"p","type":"LearnableAttacks *"}],"returns":"const const AttackData * *"},{"filename":"libCreatureLib","name":"CreatureLib_LibrarySettings_Construct","parameters":[{"name":"maximalLevel","type":"unsigned char"},{"name":"maximalMoves","type":"unsigned char"}],"returns":"const LibrarySettings *"},{"filename":"libCreatureLib","name":"CreatureLib_LibrarySettings_Destruct","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_LibrarySettings_GetMaximalLevel","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_LibrarySettings_GetMaximalAttacks","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"const SpeciesLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_Destruct","parameters":[{"name":"p","type":"const SpeciesLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_Insert","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"},{"name":"t","type":"CreatureSpecies *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_InsertWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"t","type":"CreatureSpecies *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_Delete","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_DeleteWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_TryGet","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_TryGetWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_Get","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_GetWithHash","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"hashedKey","type":"unsigned int"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_GetCount","parameters":[{"name":"p","type":"SpeciesLibrary *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_GetAtIndex","parameters":[{"name":"p","type":"SpeciesLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const CreatureSpecies * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesLibrary_GetById","parameters":[{"name":"p","type":"const SpeciesLibrary *"},{"name":"id","type":"unsigned short"}],"returns":"const CreatureSpecies *"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"height","type":"float"},{"name":"weight","type":"float"},{"name":"baseExperience","type":"unsigned int"},{"name":"types","type":"unsigned char *"},{"name":"typeLength","type":"long unsigned int"},{"name":"baseHealth","type":"unsigned short"},{"name":"baseAttack","type":"unsigned short"},{"name":"baseDefense","type":"unsigned short"},{"name":"baseMagicalAttack","type":"unsigned short"},{"name":"baseMagicalDefense","type":"unsigned short"},{"name":"baseSpeed","type":"unsigned short"},{"name":"talents","type":"const char * *"},{"name":"talentsLength","type":"long unsigned int"},{"name":"secretTalents","type":"const char * *"},{"name":"secretTalentsLength","type":"long unsigned int"},{"name":"attacks","type":"const LearnableAttacks *"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"SpeciesVariant *"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_Destruct","parameters":[{"name":"p","type":"SpeciesVariant *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetName","parameters":[{"name":"p","type":"SpeciesVariant *"}],"returns":"const char *"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetHeight","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"float"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetWeight","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"float"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetBaseExperience","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetTypeCount","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetType","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"index","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetStatistic","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned short"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetTalentCount","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetSecretTalentCount","parameters":[{"name":"p","type":"const SpeciesVariant *"}],"returns":"long unsigned int"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetTalent","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"secret","type":"bool"},{"name":"index","type":"unsigned char"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetLearnableAttacks","parameters":[{"name":"p","type":"SpeciesVariant *"}],"returns":"const LearnableAttacks *"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_GetRandomTalent","parameters":[{"name":"p","type":"SpeciesVariant *"},{"name":"rand","type":"Random *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_SpeciesVariant_HasFlag","parameters":[{"name":"p","type":"const SpeciesVariant *"},{"name":"key","type":"const char *"}],"returns":"bool"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"TypeLibrary *"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_Destruct","parameters":[{"name":"p","type":"const TypeLibrary *"}],"returns":"void"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_GetTypeId","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"const TypeLibrary *"},{"name":"type","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_RegisterType","parameters":[{"name":"out","type":"unsigned char &"},{"name":"p","type":"TypeLibrary *"},{"name":"type","type":"const char *"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_SetEffectiveness","parameters":[{"name":"p","type":"TypeLibrary *"},{"name":"attacking","type":"unsigned char"},{"name":"defensive","type":"unsigned char"},{"name":"effectiveness","type":"float"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_GetSingleEffectiveness","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"TypeLibrary *"},{"name":"attacking","type":"unsigned char"},{"name":"defensive","type":"unsigned char"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_GetEffectiveness","parameters":[{"name":"out","type":"float &"},{"name":"p","type":"TypeLibrary *"},{"name":"attacking","type":"unsigned char"},{"name":"defensive","type":"unsigned char *"},{"name":"defensiveCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libCreatureLib","name":"CreatureLib_TypeLibrary_GetTypeName","parameters":[{"name":"out","type":"const char * &"},{"name":"p","type":"TypeLibrary *"},{"name":"type","type":"unsigned char"}],"returns":"unsigned char"}]}
diff --git a/PkmnLibSharp/generator.py b/PkmnLibSharp/generator.py
index 0fab564..1e37e50 100644
--- a/PkmnLibSharp/generator.py
+++ b/PkmnLibSharp/generator.py
@@ -9,7 +9,7 @@ def resolve_enum_size(size):
     raise Exception("Unknown size {}".format(size))
 
 def write_enum(enum, enumNames):
-    namespace = str.capitalize(enum["filename"])
+    namespace = str.capitalize(enum["filename"][3:])
     if (enum["name"].startswith("bfd_")):
         return
     if (enum["name"].startswith("float_")):
@@ -24,10 +24,10 @@ def write_enum(enum, enumNames):
         f.write("namespace {}\n{{\n".format(namespace))
         f.write("    [SuppressMessage(\"ReSharper\", \"InconsistentNaming\")]\n")
         f.write("    internal enum {} : {}\n    {{\n".format(enum["name"], resolve_enum_size(enum["byteSize"]) ))
-        vals = enum["values"].items();
+        vals = enum["values"].items()
         dict = {}
         for k, v in vals:
-            dict[int(k)] = v;
+            dict[int(k)] = v
         for k, v in sorted(dict.items(), key=lambda item: item[0]):
             f.write("        {} = {},\n".format(v, k))
         f.write("    }\n")
@@ -54,12 +54,12 @@ def parse_function(function, classDict):
     splitName = function["name"].split("_")
     classKey = "{}_{}".format(function["filename"], splitName[1])
     if (not classKey in classDict):
-        classDict[classKey] = classDef(function["filename"].capitalize(), splitName[1], function["filename"])
+        classDict[classKey] = classDef(function["filename"][3:].capitalize(), splitName[1], function["filename"])
 
     classDict[classKey].register_function(funcDef(function["name"], function["returns"], function["parameters"]))
 
 def parse_type(type, enumSet):
-    type = type.strip();
+    type = type.strip()
     if (type == "void"):
         return "void"
     if (type == "unsigned char"):
@@ -97,7 +97,7 @@ def clean_name(name):
     return name
 
 def write_class(c, enumSet):
-    filename = "Generated/{}/{}.cs".format(c.file.capitalize(), c.name)
+    filename = "Generated/{}/{}.cs".format(c.file[3:].capitalize(), c.name)
     os.makedirs(os.path.dirname(filename), exist_ok=True)
     with open(filename, "w") as f:
         f.write("// AUTOMATICALLY GENERATED, DO NOT EDIT\n")
diff --git a/PkmnLibSharp/pkmnlib.json b/PkmnLibSharp/pkmnlib.json
index 3d7763b..1357080 100644
--- a/PkmnLibSharp/pkmnlib.json
+++ b/PkmnLibSharp/pkmnlib.json
@@ -1 +1 @@
-{"enums":[{"byteSize":4,"filename":"pkmnLib","name":"float_denorm_style","values":{"-1":"denorm_indeterminate","0":"denorm_absent","1":"denorm_present"}},{"byteSize":4,"filename":"pkmnLib","name":"float_round_style","values":{"-1":"round_indeterminate","0":"round_toward_zero","1":"round_to_nearest","2":"round_toward_infinity","3":"round_toward_neg_infinity"}},{"byteSize":1,"filename":"pkmnLib","name":"ScriptCategory","values":{"0":"Attack","1":"Talent","2":"Status","3":"Creature","4":"Battle","5":"Side"}},{"byteSize":4,"filename":"pkmnLib","name":"asEObjTypeFlags","values":{"1":"asOBJ_REF","1024":"asOBJ_APP_CLASS_DESTRUCTOR","1048576":"asOBJ_IMPLICIT_HANDLE","1073741824":"asOBJ_APP_ALIGN16","128":"asOBJ_ASHANDLE","1280":"asOBJ_APP_CLASS_D","131072":"asOBJ_APP_CLASS_ALLFLOATS","134217728":"asOBJ_TEMPLATE_SUBTYPE","16":"asOBJ_NOHANDLE","16384":"asOBJ_APP_FLOAT","16777216":"asOBJ_FUNCDEF","1792":"asOBJ_APP_CLASS_CD","2":"asOBJ_VALUE","2048":"asOBJ_APP_CLASS_ASSIGNMENT","2097151":"asOBJ_MASK_VALID_FLAGS","2097152":"asOBJ_SCRIPT_OBJECT","2304":"asOBJ_APP_CLASS_A","256":"asOBJ_APP_CLASS","262144":"asOBJ_NOCOUNT","268435456":"asOBJ_TYPEDEF","2816":"asOBJ_APP_CLASS_CA","32":"asOBJ_SCOPED","32768":"asOBJ_APP_ARRAY","3328":"asOBJ_APP_CLASS_DA","33554432":"asOBJ_LIST_PATTERN","3840":"asOBJ_APP_CLASS_CDA","4":"asOBJ_GC","4096":"asOBJ_APP_CLASS_COPY_CONSTRUCTOR","4194304":"asOBJ_SHARED","4352":"asOBJ_APP_CLASS_K","4864":"asOBJ_APP_CLASS_CK","512":"asOBJ_APP_CLASS_CONSTRUCTOR","524288":"asOBJ_APP_CLASS_ALIGN8","536870912":"asOBJ_ABSTRACT","5376":"asOBJ_APP_CLASS_DK","5888":"asOBJ_APP_CLASS_CDK","64":"asOBJ_TEMPLATE","6400":"asOBJ_APP_CLASS_AK","65536":"asOBJ_APP_CLASS_ALLINTS","67108864":"asOBJ_ENUM","6912":"asOBJ_APP_CLASS_CAK","7424":"asOBJ_APP_CLASS_DAK","768":"asOBJ_APP_CLASS_C","7936":"asOBJ_APP_CLASS_CDAK","8":"asOBJ_POD","8192":"asOBJ_APP_PRIMITIVE","8388608":"asOBJ_NOINHERIT"}},{"byteSize":4,"filename":"pkmnLib","name":"asECallConvTypes","values":{"0":"asCALL_CDECL","1":"asCALL_STDCALL","2":"asCALL_THISCALL_ASGLOBAL","3":"asCALL_THISCALL","4":"asCALL_CDECL_OBJLAST","5":"asCALL_CDECL_OBJFIRST","6":"asCALL_GENERIC","7":"asCALL_THISCALL_OBJLAST","8":"asCALL_THISCALL_OBJFIRST"}},{"byteSize":1,"filename":"pkmnLib","name":"Statistic","values":{"0":"Health","1":"PhysicalAttack","2":"PhysicalDefense","3":"MagicalAttack","4":"MagicalDefense","5":"Speed"}},{"byteSize":1,"filename":"pkmnLib","name":"MoveCategory","values":{"0":"Physical","1":"Special","2":"Status"}},{"byteSize":1,"filename":"pkmnLib","name":"AttackTarget","values":{"0":"Adjacent","1":"AdjacentAlly","10":"RandomOpponent","11":"Self","2":"AdjacentAllySelf","3":"AdjacentOpponent","4":"All","5":"AllAdjacent","6":"AllAdjacentOpponent","7":"AllAlly","8":"AllOpponent","9":"Any"}},{"byteSize":1,"filename":"pkmnLib","name":"EffectParameterType","values":{"0":"None","1":"Bool","2":"Int","3":"Float","4":"String"}},{"byteSize":4,"filename":"pkmnLib","name":"AttackLearnMethod","values":{"0":"Unknown","1":"Level"}},{"byteSize":1,"filename":"pkmnLib","name":"Gender","values":{"0":"Male","1":"Female","2":"Genderless"}},{"byteSize":1,"filename":"pkmnLib","name":"ItemCategory","values":{"0":"MiscItem","1":"CaptureDevice","2":"Medicine","3":"Berry","4":"MoveLearner","5":"VariantChanger","6":"KeyItem","7":"Mail"}},{"byteSize":1,"filename":"pkmnLib","name":"BattleItemCategory","values":{"0":"None","1":"Healing","2":"StatusHealing","3":"CaptureDevice","4":"MiscBattleItem"}},{"byteSize":1,"filename":"pkmnLib","name":"EvolutionMethod","values":{"0":"Level","1":"HighFriendship","10":"TradeWithHeldItem","11":"TradeWithSpecificPokemon","12":"Custom","2":"KnownMove","3":"LocationBased","4":"TimeBased","5":"HoldsItem","6":"IsGenderAndLevel","7":"EvolutionItemUse","8":"EvolutionItemUseWithGender","9":"Trade"}},{"byteSize":1,"filename":"pkmnLib","name":"TimeOfDay","values":{"0":"Night","1":"Morning","2":"Afternoon","3":"Evening"}},{"byteSize":4,"filename":"pkmnLib","name":"asETypeIdFlags","values":{"0":"asTYPEID_VOID","1":"asTYPEID_BOOL","10":"asTYPEID_FLOAT","1073741824":"asTYPEID_OBJHANDLE","11":"asTYPEID_DOUBLE","134217728":"asTYPEID_SCRIPTOBJECT","2":"asTYPEID_INT8","268435456":"asTYPEID_TEMPLATE","3":"asTYPEID_INT16","4":"asTYPEID_INT32","469762048":"asTYPEID_MASK_OBJECT","5":"asTYPEID_INT64","536870912":"asTYPEID_HANDLETOCONST","6":"asTYPEID_UINT8","67108863":"asTYPEID_MASK_SEQNBR","67108864":"asTYPEID_APPOBJECT","7":"asTYPEID_UINT16","8":"asTYPEID_UINT32","9":"asTYPEID_UINT64"}},{"byteSize":4,"filename":"pkmnLib","name":"asEContextState","values":{"0":"asEXECUTION_FINISHED","1":"asEXECUTION_SUSPENDED","2":"asEXECUTION_ABORTED","3":"asEXECUTION_EXCEPTION","4":"asEXECUTION_PREPARED","5":"asEXECUTION_UNINITIALIZED","6":"asEXECUTION_ACTIVE","7":"asEXECUTION_ERROR"}},{"byteSize":4,"filename":"pkmnLib","name":"asERetCodes","values":{"-1":"asERROR","-10":"asINVALID_DECLARATION","-11":"asINVALID_OBJECT","-12":"asINVALID_TYPE","-13":"asALREADY_REGISTERED","-14":"asMULTIPLE_FUNCTIONS","-15":"asNO_MODULE","-16":"asNO_GLOBAL_VAR","-17":"asINVALID_CONFIGURATION","-18":"asINVALID_INTERFACE","-19":"asCANT_BIND_ALL_FUNCTIONS","-2":"asCONTEXT_ACTIVE","-20":"asLOWER_ARRAY_DIMENSION_NOT_REGISTERED","-21":"asWRONG_CONFIG_GROUP","-22":"asCONFIG_GROUP_IS_IN_USE","-23":"asILLEGAL_BEHAVIOUR_FOR_TYPE","-24":"asWRONG_CALLING_CONV","-25":"asBUILD_IN_PROGRESS","-26":"asINIT_GLOBAL_VARS_FAILED","-27":"asOUT_OF_MEMORY","-28":"asMODULE_IS_IN_USE","-3":"asCONTEXT_NOT_FINISHED","-4":"asCONTEXT_NOT_PREPARED","-5":"asINVALID_ARG","-6":"asNO_FUNCTION","-7":"asNOT_SUPPORTED","-8":"asINVALID_NAME","-9":"asNAME_TAKEN","0":"asSUCCESS"}},{"byteSize":4,"filename":"pkmnLib","name":"asETypeModifiers","values":{"0":"asTM_NONE","1":"asTM_INREF","2":"asTM_OUTREF","3":"asTM_INOUTREF","4":"asTM_CONST"}},{"byteSize":4,"filename":"pkmnLib","name":"asEBehaviours","values":{"0":"asBEHAVE_CONSTRUCT","1":"asBEHAVE_LIST_CONSTRUCT","10":"asBEHAVE_SETGCFLAG","11":"asBEHAVE_GETGCFLAG","12":"asBEHAVE_ENUMREFS","13":"asBEHAVE_RELEASEREFS","14":"asBEHAVE_MAX","2":"asBEHAVE_DESTRUCT","3":"asBEHAVE_FACTORY","4":"asBEHAVE_LIST_FACTORY","5":"asBEHAVE_ADDREF","6":"asBEHAVE_RELEASE","7":"asBEHAVE_GET_WEAKREF_FLAG","8":"asBEHAVE_TEMPLATE_CALLBACK","9":"asBEHAVE_FIRST_GC"}},{"byteSize":4,"filename":"pkmnLib","name":"asEMsgType","values":{"0":"asMSGTYPE_ERROR","1":"asMSGTYPE_WARNING","2":"asMSGTYPE_INFORMATION"}},{"byteSize":4,"filename":"pkmnLib","name":"asEEngineProp","values":{"1":"asEP_ALLOW_UNSAFE_REFERENCES","10":"asEP_REQUIRE_ENUM_SCOPE","11":"asEP_SCRIPT_SCANNER","12":"asEP_INCLUDE_JIT_INSTRUCTIONS","13":"asEP_STRING_ENCODING","14":"asEP_PROPERTY_ACCESSOR_MODE","15":"asEP_EXPAND_DEF_ARRAY_TO_TMPL","16":"asEP_AUTO_GARBAGE_COLLECT","17":"asEP_DISALLOW_GLOBAL_VARS","18":"asEP_ALWAYS_IMPL_DEFAULT_CONSTRUCT","19":"asEP_COMPILER_WARNINGS","2":"asEP_OPTIMIZE_BYTECODE","20":"asEP_DISALLOW_VALUE_ASSIGN_FOR_REF_TYPE","21":"asEP_ALTER_SYNTAX_NAMED_ARGS","22":"asEP_DISABLE_INTEGER_DIVISION","23":"asEP_DISALLOW_EMPTY_LIST_ELEMENTS","24":"asEP_PRIVATE_PROP_AS_PROTECTED","25":"asEP_ALLOW_UNICODE_IDENTIFIERS","26":"asEP_HEREDOC_TRIM_MODE","27":"asEP_MAX_NESTED_CALLS","28":"asEP_GENERIC_CALL_MODE","29":"asEP_INIT_STACK_SIZE","3":"asEP_COPY_SCRIPT_SECTIONS","30":"asEP_INIT_CALL_STACK_SIZE","31":"asEP_MAX_CALL_STACK_SIZE","32":"asEP_LAST_PROPERTY","4":"asEP_MAX_STACK_SIZE","5":"asEP_USE_CHARACTER_LITERALS","6":"asEP_ALLOW_MULTILINE_STRINGS","7":"asEP_ALLOW_IMPLICIT_HANDLE_TYPES","8":"asEP_BUILD_WITHOUT_LINE_CUES","9":"asEP_INIT_GLOBAL_VARS_AFTER_BUILD"}},{"byteSize":4,"filename":"pkmnLib","name":"asEGMFlags","values":{"0":"asGM_ONLY_IF_EXISTS","1":"asGM_CREATE_IF_NOT_EXISTS","2":"asGM_ALWAYS_CREATE"}},{"byteSize":4,"filename":"pkmnLib","name":"asETokenClass","values":{"0":"asTC_UNKNOWN","1":"asTC_KEYWORD","2":"asTC_VALUE","3":"asTC_IDENTIFIER","4":"asTC_COMMENT","5":"asTC_WHITESPACE"}},{"byteSize":4,"filename":"pkmnLib","name":"METADATATYPE","values":{"1":"MDT_TYPE","2":"MDT_FUNC","3":"MDT_VAR","4":"MDT_VIRTPROP","5":"MDT_FUNC_OR_VAR"}},{"byteSize":4,"filename":"pkmnLib","name":"asEFuncType","values":{"-1":"asFUNC_DUMMY","0":"asFUNC_SYSTEM","1":"asFUNC_SCRIPT","2":"asFUNC_INTERFACE","3":"asFUNC_VIRTUAL","4":"asFUNC_FUNCDEF","5":"asFUNC_IMPORTED","6":"asFUNC_DELEGATE"}},{"byteSize":1,"filename":"pkmnLib","name":"PkmnScriptCategory","values":{"128":"Weather","129":"Status"}},{"byteSize":1,"filename":"pkmnLib","name":"EventDataKind","values":{"0":"Damage","1":"Heal","10":"ChangeVariant","11":"AttackUse","2":"Faint","3":"Switch","4":"TurnStart","5":"TurnEnd","6":"ExperienceGain","7":"Miss","8":"DisplayText","9":"ChangeSpecies"}},{"byteSize":1,"filename":"pkmnLib","name":"PkmnEventDataKind","values":{"128":"WeatherChange","129":"StatusChange"}},{"byteSize":1,"filename":"pkmnLib","name":"TurnChoiceKind","values":{"0":"Pass","1":"Attack","2":"Item","3":"Switch","4":"Flee"}},{"byteSize":1,"filename":"pkmnLib","name":"AttackCategory","values":{"0":"Physical","1":"Magical","2":"Status"}},{"byteSize":4,"filename":"pkmnLib","name":"syntax_option_type","values":{}},{"byteSize":4,"filename":"pkmnLib","name":"error_type","values":{"0":"_S_error_collate","1":"_S_error_ctype","10":"_S_error_badrepeat","11":"_S_error_complexity","12":"_S_error_stack","2":"_S_error_escape","3":"_S_error_backref","4":"_S_error_brack","5":"_S_error_paren","6":"_S_error_brace","7":"_S_error_badbrace","8":"_S_error_range","9":"_S_error_space"}},{"byteSize":4,"filename":"pkmnLib","name":"match_flag_type","values":{}},{"byteSize":1,"filename":"pkmnLib","name":"DamageSource","values":{"0":"AttackDamage"}},{"byteSize":1,"filename":"pkmnLib","name":"PkmnDamageSource","values":{"1":"Struggle"}}],"functions":[{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_Construct","parameters":[],"returns":"AngelScriptResolver *"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_Destruct","parameters":[{"name":"p","type":"AngelScriptResolver *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_Initialize","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"lib","type":"BattleLibrary *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_CreateScript","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"name","type":"const char *"},{"name":"script","type":"const char *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_FinalizeModule","parameters":[{"name":"p","type":"AngelScriptResolver *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_LoadScript","parameters":[{"name":"out","type":"Script * &"},{"name":"p","type":"AngelScriptResolver *"},{"name":"category","type":"ScriptCategory"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_WriteByteCodeToFile","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"file","type":"const char *"},{"name":"stripDebugInfo","type":"bool"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_LoadByteCodeFromFile","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"file","type":"const char *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_WriteByteCodeToMemory","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"stripDebugInfo","type":"bool"},{"name":"size","type":"long unsigned int &"},{"name":"out","type":"unsigned char * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_LoadByteCodeFromMemory","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"memory","type":"unsigned char *"},{"name":"size","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_RegisterType","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"typeName","type":"const char *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_RegisterTypeMethod","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"typeName","type":"const char *"},{"name":"decl","type":"const char *"},{"name":"func","type":"Function *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelScriptResolver_RegisterGlobalMethod","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"decl","type":"const char *"},{"name":"func","type":"Function *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_AngelscriptScript_Destruct","parameters":[{"name":"p","type":"AngelScriptScript *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Battle_Construct","parameters":[{"name":"out","type":"Battle * &"},{"name":"library","type":"const BattleLibrary *"},{"name":"parties","type":"const BattleParty * *"},{"name":"partiesCount","type":"long unsigned int"},{"name":"canFlee","type":"bool"},{"name":"numberOfSides","type":"unsigned char"},{"name":"creaturesPerSide","type":"unsigned char"},{"name":"randomSeed","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Battle_Destruct","parameters":[{"name":"p","type":"Battle *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Battle_SetWeather","parameters":[{"name":"p","type":"Battle *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Battle_ClearWeather","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Battle_GetWeatherName","parameters":[{"name":"p","type":"Battle *"}],"returns":"const char *"},{"filename":"pkmnLib","name":"PkmnLib_BattleLibrary_Construct","parameters":[{"name":"out","type":"BattleLibrary * &"},{"name":"staticLib","type":"PokemonLibrary *"},{"name":"statCalculator","type":"StatCalculator *"},{"name":"damageLibrary","type":"DamageLibrary *"},{"name":"experienceLibrary","type":"ExperienceLibrary *"},{"name":"scriptResolver","type":"ScriptResolver *"},{"name":"miscLibrary","type":"MiscLibrary *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_BattleLibrary_Destruct","parameters":[{"name":"p","type":"BattleLibrary *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_DamageLibrary_Construct","parameters":[],"returns":"DamageLibrary *"},{"filename":"pkmnLib","name":"PkmnLib_DamageLibrary_Destruct","parameters":[{"name":"p","type":"DamageLibrary *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_WeatherChangeEvent_Destruct","parameters":[{"name":"p","type":"WeatherChangeEvent *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_WeatherChangeEvent_GetWeatherName","parameters":[{"name":"p","type":"WeatherChangeEvent *"}],"returns":"const char *"},{"filename":"pkmnLib","name":"PkmnLib_ExperienceLibrary_Construct","parameters":[],"returns":"ExperienceLibrary *"},{"filename":"pkmnLib","name":"PkmnLib_ExperienceLibrary_HandleExperienceGain","parameters":[{"name":"p","type":"ExperienceLibrary *"},{"name":"faintedMon","type":"Creature *"},{"name":"opponents","type":"const Creature * *"},{"name":"numberOfOpponents","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_ExperienceLibrary_Destruct","parameters":[{"name":"p","type":"ExperienceLibrary *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_MiscLibrary_Construct","parameters":[],"returns":"MiscLibrary *"},{"filename":"pkmnLib","name":"PkmnLib_MiscLibrary_Destruct","parameters":[{"name":"p","type":"MiscLibrary *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_PkmnScript_ModifyCriticalStage","parameters":[{"name":"script","type":"PkmnScript *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hit","type":"unsigned char"},{"name":"critStage","type":"unsigned char *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_Construct","parameters":[{"name":"library","type":"const BattleLibrary *"},{"name":"species","type":"const PokemonSpecies *"},{"name":"forme","type":"const PokemonForme *"},{"name":"level","type":"unsigned char"},{"name":"experience","type":"unsigned int"},{"name":"uid","type":"unsigned int"},{"name":"gender","type":"Gender"},{"name":"coloring","type":"unsigned char"},{"name":"heldItem","type":"const Item *"},{"name":"nickname","type":"const char *"},{"name":"hiddenAbility","type":"bool"},{"name":"abilityIndex","type":"unsigned char"},{"name":"moves","type":"const LearnedAttack * *"},{"name":"moveCount","type":"long unsigned int"},{"name":"hpIv","type":"unsigned char"},{"name":"attIv","type":"unsigned char"},{"name":"defIv","type":"unsigned char"},{"name":"sAtIv","type":"unsigned char"},{"name":"sDeIv","type":"unsigned char"},{"name":"spIv","type":"unsigned char"},{"name":"hpEv","type":"unsigned char"},{"name":"attEv","type":"unsigned char"},{"name":"defEv","type":"unsigned char"},{"name":"sAtEv","type":"unsigned char"},{"name":"sDeEv","type":"unsigned char"},{"name":"spEv","type":"unsigned char"},{"name":"nature","type":"const Nature *"}],"returns":"Pokemon *"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_Destruct","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_IsShiny","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"bool"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_GetNature","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"const Nature *"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_GetIndividualValue","parameters":[{"name":"p","type":"const Pokemon *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_SetIndividualValue","parameters":[{"name":"p","type":"Pokemon *"},{"name":"stat","type":"Statistic"},{"name":"value","type":"unsigned char"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_GetEffortValue","parameters":[{"name":"p","type":"const Pokemon *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_SetEffortValue","parameters":[{"name":"p","type":"Pokemon *"},{"name":"stat","type":"Statistic"},{"name":"value","type":"unsigned char"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_SetStatus","parameters":[{"name":"p","type":"Pokemon *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_ClearStatus","parameters":[{"name":"p","type":"Pokemon *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_GetStatusName","parameters":[{"name":"p","type":"Pokemon *"}],"returns":"const char *"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_GetFriendship","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_SetFriendship","parameters":[{"name":"p","type":"Pokemon *"},{"name":"value","type":"unsigned char"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_ChangeFriendship","parameters":[{"name":"p","type":"Pokemon *"},{"name":"amount","type":"signed char"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Pokemon_Evolve","parameters":[{"name":"p","type":"Pokemon *"},{"name":"species","type":"const PokemonSpecies *"},{"name":"forme","type":"const PokemonForme *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_StatCalculator_Construct","parameters":[],"returns":"StatCalculator *"},{"filename":"pkmnLib","name":"PkmnLib_StatCalculator_Destruct","parameters":[{"name":"p","type":"StatCalculator *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_C_GetLastException","parameters":[],"returns":"const char *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateLevelEvolution","parameters":[{"name":"level","type":"unsigned char"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateFriendshipEvolution","parameters":[{"name":"friendship","type":"unsigned char"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateKnownMoveEvolution","parameters":[{"name":"move","type":"const MoveData *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateLocationEvolution","parameters":[{"name":"location","type":"const char *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateTimeEvolution","parameters":[{"name":"time","type":"TimeOfDay"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateItemEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateGenderBasedEvolution","parameters":[{"name":"gender","type":"Gender"},{"name":"level","type":"unsigned char"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateItemUseEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateItemUseWithGenderEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"gender","type":"Gender"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateTradeEvolution","parameters":[{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateTradeWithItemEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateTradeWithSpeciesEvolution","parameters":[{"name":"traded","type":"const PokemonSpecies *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_CreateCustomEvolution","parameters":[{"name":"data","type":"const EffectParameter * *"},{"name":"dataLength","type":"long unsigned int"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_GetMethod","parameters":[{"name":"data","type":"const EvolutionData *"}],"returns":"EvolutionMethod"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_GetNewSpecies","parameters":[{"name":"data","type":"const EvolutionData *"}],"returns":"const PokemonSpecies *"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_GetDataCount","parameters":[{"name":"data","type":"const EvolutionData *"}],"returns":"long unsigned int"},{"filename":"pkmnLib","name":"PkmnLib_EvolutionData_GetData","parameters":[{"name":"data","type":"const EvolutionData *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const EffectParameter * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_Item_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"category","type":"ItemCategory"},{"name":"battleCategory","type":"BattleItemCategory"},{"name":"price","type":"int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"},{"name":"flingPower","type":"unsigned char"}],"returns":"Item *"},{"filename":"pkmnLib","name":"PkmnLib_Item_Destruct","parameters":[{"name":"p","type":"const Item *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Item_GetFlingPower","parameters":[{"name":"p","type":"const Item *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_LearnableMoves_Construct","parameters":[{"name":"out","type":"LearnableMoves * &"},{"name":"levelAttackCapacity","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_LearnableMoves_Destruct","parameters":[{"name":"p","type":"const LearnableMoves *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_LearnableMoves_AddEggMove","parameters":[{"name":"p","type":"LearnableMoves *"},{"name":"move","type":"MoveData *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_LearnableMoves_GetEggMovesCount","parameters":[{"name":"p","type":"LearnableMoves *"}],"returns":"long unsigned int"},{"filename":"pkmnLib","name":"PkmnLib_LearnableMoves_GetEggMoves","parameters":[{"name":"p","type":"LearnableMoves *"}],"returns":"const const MoveData * *"},{"filename":"pkmnLib","name":"PkmnLib_LibrarySettings_Construct","parameters":[{"name":"maximalLevel","type":"unsigned char"},{"name":"maximalMoves","type":"unsigned char"},{"name":"shinyRate","type":"unsigned short"}],"returns":"const LibrarySettings *"},{"filename":"pkmnLib","name":"PkmnLib_LibrarySettings_Destruct","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_LibrarySettings_GetShinyRate","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"unsigned short"},{"filename":"pkmnLib","name":"PkmnLib_Nature_Construct","parameters":[{"name":"increasedStat","type":"Statistic"},{"name":"decreasedStat","type":"Statistic"},{"name":"increasedModifier","type":"float"},{"name":"decreasedModifier","type":"float"}],"returns":"Nature *"},{"filename":"pkmnLib","name":"PkmnLib_Nature_Destruct","parameters":[{"name":"p","type":"const Nature *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_Nature_GetIncreaseModifier","parameters":[{"name":"p","type":"const Nature *"}],"returns":"float"},{"filename":"pkmnLib","name":"PkmnLib_Nature_GetDecreaseModifier","parameters":[{"name":"p","type":"const Nature *"}],"returns":"float"},{"filename":"pkmnLib","name":"PkmnLib_Nature_GetIncreasedStat","parameters":[{"name":"p","type":"const Nature *"}],"returns":"Statistic"},{"filename":"pkmnLib","name":"PkmnLib_Nature_GetDecreasedStat","parameters":[{"name":"p","type":"const Nature *"}],"returns":"Statistic"},{"filename":"pkmnLib","name":"PkmnLib_Nature_GetStatModifier","parameters":[{"name":"nature","type":"const Nature *"},{"name":"stat","type":"Statistic"}],"returns":"float"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"NatureLibrary *"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_Destruct","parameters":[{"name":"p","type":"const NatureLibrary *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_LoadNature","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"name","type":"const char *"},{"name":"nature","type":"const Nature *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_GetNatureByName","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const Nature * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_GetRandomNatureName","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"rand","type":"Random *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_GetNatureName","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"nature","type":"const Nature *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_GetNatureCount","parameters":[{"name":"p","type":"const NatureLibrary *"}],"returns":"long unsigned int"},{"filename":"pkmnLib","name":"PkmnLib_NatureLibrary_GetNatureByIndex","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_PokemonForme_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"height","type":"float"},{"name":"weight","type":"float"},{"name":"baseExperience","type":"unsigned int"},{"name":"types","type":"unsigned char *"},{"name":"typeLength","type":"long unsigned int"},{"name":"baseHealth","type":"unsigned short"},{"name":"baseAttack","type":"unsigned short"},{"name":"baseDefense","type":"unsigned short"},{"name":"baseMagicalAttack","type":"unsigned short"},{"name":"baseMagicalDefense","type":"unsigned short"},{"name":"baseSpeed","type":"unsigned short"},{"name":"talents","type":"const char * *"},{"name":"talentsLength","type":"long unsigned int"},{"name":"secretTalents","type":"const char * *"},{"name":"secretTalentsLength","type":"long unsigned int"},{"name":"attacks","type":"const LearnableMoves *"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"PokemonForme *"},{"filename":"pkmnLib","name":"PkmnLib_PokemonLibrary_Construct","parameters":[{"name":"out","type":"PokemonLibrary * &"},{"name":"settings","type":"LibrarySettings *"},{"name":"species","type":"SpeciesLibrary *"},{"name":"moves","type":"MoveLibrary *"},{"name":"items","type":"ItemLibrary *"},{"name":"growthRates","type":"GrowthRateLibrary *"},{"name":"typeLibrary","type":"TypeLibrary *"},{"name":"natures","type":"NatureLibrary *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_PokemonLibrary_Destruct","parameters":[{"name":"p","type":"const PokemonLibrary *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_PokemonLibrary_GetNatureLibrary","parameters":[{"name":"p","type":"const PokemonLibrary *"}],"returns":"const NatureLibrary *"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_Construct","parameters":[{"name":"out","type":"const PokemonSpecies * &"},{"name":"id","type":"unsigned short"},{"name":"name","type":"const char *"},{"name":"defaultForme","type":"const PokemonForme *"},{"name":"genderRatio","type":"float"},{"name":"growthRate","type":"const char *"},{"name":"captureRate","type":"unsigned char"},{"name":"baseHappiness","type":"unsigned char"},{"name":"eggGroupsRaw","type":"const const char * *"},{"name":"eggGroupsLength","type":"long unsigned int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_Destruct","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_GetBaseHappiness","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_AddEvolution","parameters":[{"name":"p","type":"PokemonSpecies *"},{"name":"evo","type":"EvolutionData *"}],"returns":"void"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_GetEvolutionCount","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"long unsigned int"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_GetEvolution","parameters":[{"name":"p","type":"const PokemonSpecies *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const EvolutionData * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_GetEvolutions","parameters":[{"name":"p","type":"const PokemonSpecies *"},{"name":"out","type":"const const EvolutionData * * &"}],"returns":"unsigned char"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_GetEggGroupCount","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"long unsigned int"},{"filename":"pkmnLib","name":"PkmnLib_PokemonSpecies_GetEggGroup","parameters":[{"name":"p","type":"const PokemonSpecies *"},{"name":"index","type":"long unsigned int"}],"returns":"const char *"},{"filename":"pkmnLib","name":"PkmnLib_SpeciesLibrary_FindPreEvolution","parameters":[{"name":"p","type":"const SpeciesLibrary *"},{"name":"species","type":"const PokemonSpecies *"}],"returns":"const PokemonSpecies *"}]}
+{"enums":[{"byteSize":4,"filename":"libpkmnLib","name":"float_denorm_style","values":{"-1":"denorm_indeterminate","0":"denorm_absent","1":"denorm_present"}},{"byteSize":4,"filename":"libpkmnLib","name":"float_round_style","values":{"-1":"round_indeterminate","0":"round_toward_zero","1":"round_to_nearest","2":"round_toward_infinity","3":"round_toward_neg_infinity"}},{"byteSize":1,"filename":"libpkmnLib","name":"ScriptCategory","values":{"0":"Attack","1":"Talent","2":"Status","3":"Creature","4":"Battle","5":"Side"}},{"byteSize":4,"filename":"libpkmnLib","name":"asEObjTypeFlags","values":{"1":"asOBJ_REF","1024":"asOBJ_APP_CLASS_DESTRUCTOR","1048576":"asOBJ_IMPLICIT_HANDLE","1073741824":"asOBJ_APP_ALIGN16","128":"asOBJ_ASHANDLE","1280":"asOBJ_APP_CLASS_D","131072":"asOBJ_APP_CLASS_ALLFLOATS","134217728":"asOBJ_TEMPLATE_SUBTYPE","16":"asOBJ_NOHANDLE","16384":"asOBJ_APP_FLOAT","16777216":"asOBJ_FUNCDEF","1792":"asOBJ_APP_CLASS_CD","2":"asOBJ_VALUE","2048":"asOBJ_APP_CLASS_ASSIGNMENT","2097151":"asOBJ_MASK_VALID_FLAGS","2097152":"asOBJ_SCRIPT_OBJECT","2304":"asOBJ_APP_CLASS_A","256":"asOBJ_APP_CLASS","262144":"asOBJ_NOCOUNT","268435456":"asOBJ_TYPEDEF","2816":"asOBJ_APP_CLASS_CA","32":"asOBJ_SCOPED","32768":"asOBJ_APP_ARRAY","3328":"asOBJ_APP_CLASS_DA","33554432":"asOBJ_LIST_PATTERN","3840":"asOBJ_APP_CLASS_CDA","4":"asOBJ_GC","4096":"asOBJ_APP_CLASS_COPY_CONSTRUCTOR","4194304":"asOBJ_SHARED","4352":"asOBJ_APP_CLASS_K","4864":"asOBJ_APP_CLASS_CK","512":"asOBJ_APP_CLASS_CONSTRUCTOR","524288":"asOBJ_APP_CLASS_ALIGN8","536870912":"asOBJ_ABSTRACT","5376":"asOBJ_APP_CLASS_DK","5888":"asOBJ_APP_CLASS_CDK","64":"asOBJ_TEMPLATE","6400":"asOBJ_APP_CLASS_AK","65536":"asOBJ_APP_CLASS_ALLINTS","67108864":"asOBJ_ENUM","6912":"asOBJ_APP_CLASS_CAK","7424":"asOBJ_APP_CLASS_DAK","768":"asOBJ_APP_CLASS_C","7936":"asOBJ_APP_CLASS_CDAK","8":"asOBJ_POD","8192":"asOBJ_APP_PRIMITIVE","8388608":"asOBJ_NOINHERIT"}},{"byteSize":4,"filename":"libpkmnLib","name":"asECallConvTypes","values":{"0":"asCALL_CDECL","1":"asCALL_STDCALL","2":"asCALL_THISCALL_ASGLOBAL","3":"asCALL_THISCALL","4":"asCALL_CDECL_OBJLAST","5":"asCALL_CDECL_OBJFIRST","6":"asCALL_GENERIC","7":"asCALL_THISCALL_OBJLAST","8":"asCALL_THISCALL_OBJFIRST"}},{"byteSize":1,"filename":"libpkmnLib","name":"Statistic","values":{"0":"Health","1":"PhysicalAttack","2":"PhysicalDefense","3":"MagicalAttack","4":"MagicalDefense","5":"Speed"}},{"byteSize":1,"filename":"libpkmnLib","name":"EventDataKind","values":{"0":"Damage","1":"Heal","10":"ChangeVariant","11":"AttackUse","2":"Faint","3":"Switch","4":"TurnStart","5":"TurnEnd","6":"ExperienceGain","7":"Miss","8":"DisplayText","9":"ChangeSpecies"}},{"byteSize":1,"filename":"libpkmnLib","name":"PkmnEventDataKind","values":{"128":"WeatherChange","129":"StatusChange"}},{"byteSize":1,"filename":"libpkmnLib","name":"MoveCategory","values":{"0":"Physical","1":"Special","2":"Status"}},{"byteSize":1,"filename":"libpkmnLib","name":"AttackTarget","values":{"0":"Adjacent","1":"AdjacentAlly","10":"RandomOpponent","11":"Self","2":"AdjacentAllySelf","3":"AdjacentOpponent","4":"All","5":"AllAdjacent","6":"AllAdjacentOpponent","7":"AllAlly","8":"AllOpponent","9":"Any"}},{"byteSize":1,"filename":"libpkmnLib","name":"EffectParameterType","values":{"0":"None","1":"Bool","2":"Int","3":"Float","4":"String"}},{"byteSize":1,"filename":"libpkmnLib","name":"AttackCategory","values":{"0":"Physical","1":"Magical","2":"Status"}},{"byteSize":4,"filename":"libpkmnLib","name":"AttackLearnMethod","values":{"0":"Unknown","1":"Level"}},{"byteSize":1,"filename":"libpkmnLib","name":"Gender","values":{"0":"Male","1":"Female","2":"Genderless"}},{"byteSize":1,"filename":"libpkmnLib","name":"EvolutionMethod","values":{"0":"Level","1":"HighFriendship","10":"TradeWithHeldItem","11":"TradeWithSpecificPokemon","12":"Custom","2":"KnownMove","3":"LocationBased","4":"TimeBased","5":"HoldsItem","6":"IsGenderAndLevel","7":"EvolutionItemUse","8":"EvolutionItemUseWithGender","9":"Trade"}},{"byteSize":1,"filename":"libpkmnLib","name":"TimeOfDay","values":{"0":"Night","1":"Morning","2":"Afternoon","3":"Evening"}},{"byteSize":1,"filename":"libpkmnLib","name":"ItemCategory","values":{"0":"MiscItem","1":"CaptureDevice","2":"Medicine","3":"Berry","4":"MoveLearner","5":"VariantChanger","6":"KeyItem","7":"Mail"}},{"byteSize":1,"filename":"libpkmnLib","name":"BattleItemCategory","values":{"0":"None","1":"Healing","2":"StatusHealing","3":"CaptureDevice","4":"MiscBattleItem"}},{"byteSize":4,"filename":"libpkmnLib","name":"asETypeIdFlags","values":{"0":"asTYPEID_VOID","1":"asTYPEID_BOOL","10":"asTYPEID_FLOAT","1073741824":"asTYPEID_OBJHANDLE","11":"asTYPEID_DOUBLE","134217728":"asTYPEID_SCRIPTOBJECT","2":"asTYPEID_INT8","268435456":"asTYPEID_TEMPLATE","3":"asTYPEID_INT16","4":"asTYPEID_INT32","469762048":"asTYPEID_MASK_OBJECT","5":"asTYPEID_INT64","536870912":"asTYPEID_HANDLETOCONST","6":"asTYPEID_UINT8","67108863":"asTYPEID_MASK_SEQNBR","67108864":"asTYPEID_APPOBJECT","7":"asTYPEID_UINT16","8":"asTYPEID_UINT32","9":"asTYPEID_UINT64"}},{"byteSize":4,"filename":"libpkmnLib","name":"asEContextState","values":{"0":"asEXECUTION_FINISHED","1":"asEXECUTION_SUSPENDED","2":"asEXECUTION_ABORTED","3":"asEXECUTION_EXCEPTION","4":"asEXECUTION_PREPARED","5":"asEXECUTION_UNINITIALIZED","6":"asEXECUTION_ACTIVE","7":"asEXECUTION_ERROR"}},{"byteSize":4,"filename":"libpkmnLib","name":"asERetCodes","values":{"-1":"asERROR","-10":"asINVALID_DECLARATION","-11":"asINVALID_OBJECT","-12":"asINVALID_TYPE","-13":"asALREADY_REGISTERED","-14":"asMULTIPLE_FUNCTIONS","-15":"asNO_MODULE","-16":"asNO_GLOBAL_VAR","-17":"asINVALID_CONFIGURATION","-18":"asINVALID_INTERFACE","-19":"asCANT_BIND_ALL_FUNCTIONS","-2":"asCONTEXT_ACTIVE","-20":"asLOWER_ARRAY_DIMENSION_NOT_REGISTERED","-21":"asWRONG_CONFIG_GROUP","-22":"asCONFIG_GROUP_IS_IN_USE","-23":"asILLEGAL_BEHAVIOUR_FOR_TYPE","-24":"asWRONG_CALLING_CONV","-25":"asBUILD_IN_PROGRESS","-26":"asINIT_GLOBAL_VARS_FAILED","-27":"asOUT_OF_MEMORY","-28":"asMODULE_IS_IN_USE","-3":"asCONTEXT_NOT_FINISHED","-4":"asCONTEXT_NOT_PREPARED","-5":"asINVALID_ARG","-6":"asNO_FUNCTION","-7":"asNOT_SUPPORTED","-8":"asINVALID_NAME","-9":"asNAME_TAKEN","0":"asSUCCESS"}},{"byteSize":4,"filename":"libpkmnLib","name":"asETypeModifiers","values":{"0":"asTM_NONE","1":"asTM_INREF","2":"asTM_OUTREF","3":"asTM_INOUTREF","4":"asTM_CONST"}},{"byteSize":4,"filename":"libpkmnLib","name":"asEBehaviours","values":{"0":"asBEHAVE_CONSTRUCT","1":"asBEHAVE_LIST_CONSTRUCT","10":"asBEHAVE_SETGCFLAG","11":"asBEHAVE_GETGCFLAG","12":"asBEHAVE_ENUMREFS","13":"asBEHAVE_RELEASEREFS","14":"asBEHAVE_MAX","2":"asBEHAVE_DESTRUCT","3":"asBEHAVE_FACTORY","4":"asBEHAVE_LIST_FACTORY","5":"asBEHAVE_ADDREF","6":"asBEHAVE_RELEASE","7":"asBEHAVE_GET_WEAKREF_FLAG","8":"asBEHAVE_TEMPLATE_CALLBACK","9":"asBEHAVE_FIRST_GC"}},{"byteSize":4,"filename":"libpkmnLib","name":"asEMsgType","values":{"0":"asMSGTYPE_ERROR","1":"asMSGTYPE_WARNING","2":"asMSGTYPE_INFORMATION"}},{"byteSize":4,"filename":"libpkmnLib","name":"asEEngineProp","values":{"1":"asEP_ALLOW_UNSAFE_REFERENCES","10":"asEP_REQUIRE_ENUM_SCOPE","11":"asEP_SCRIPT_SCANNER","12":"asEP_INCLUDE_JIT_INSTRUCTIONS","13":"asEP_STRING_ENCODING","14":"asEP_PROPERTY_ACCESSOR_MODE","15":"asEP_EXPAND_DEF_ARRAY_TO_TMPL","16":"asEP_AUTO_GARBAGE_COLLECT","17":"asEP_DISALLOW_GLOBAL_VARS","18":"asEP_ALWAYS_IMPL_DEFAULT_CONSTRUCT","19":"asEP_COMPILER_WARNINGS","2":"asEP_OPTIMIZE_BYTECODE","20":"asEP_DISALLOW_VALUE_ASSIGN_FOR_REF_TYPE","21":"asEP_ALTER_SYNTAX_NAMED_ARGS","22":"asEP_DISABLE_INTEGER_DIVISION","23":"asEP_DISALLOW_EMPTY_LIST_ELEMENTS","24":"asEP_PRIVATE_PROP_AS_PROTECTED","25":"asEP_ALLOW_UNICODE_IDENTIFIERS","26":"asEP_HEREDOC_TRIM_MODE","27":"asEP_MAX_NESTED_CALLS","28":"asEP_GENERIC_CALL_MODE","29":"asEP_INIT_STACK_SIZE","3":"asEP_COPY_SCRIPT_SECTIONS","30":"asEP_INIT_CALL_STACK_SIZE","31":"asEP_MAX_CALL_STACK_SIZE","32":"asEP_LAST_PROPERTY","4":"asEP_MAX_STACK_SIZE","5":"asEP_USE_CHARACTER_LITERALS","6":"asEP_ALLOW_MULTILINE_STRINGS","7":"asEP_ALLOW_IMPLICIT_HANDLE_TYPES","8":"asEP_BUILD_WITHOUT_LINE_CUES","9":"asEP_INIT_GLOBAL_VARS_AFTER_BUILD"}},{"byteSize":4,"filename":"libpkmnLib","name":"asEGMFlags","values":{"0":"asGM_ONLY_IF_EXISTS","1":"asGM_CREATE_IF_NOT_EXISTS","2":"asGM_ALWAYS_CREATE"}},{"byteSize":4,"filename":"libpkmnLib","name":"asETokenClass","values":{"0":"asTC_UNKNOWN","1":"asTC_KEYWORD","2":"asTC_VALUE","3":"asTC_IDENTIFIER","4":"asTC_COMMENT","5":"asTC_WHITESPACE"}},{"byteSize":4,"filename":"libpkmnLib","name":"METADATATYPE","values":{"1":"MDT_TYPE","2":"MDT_FUNC","3":"MDT_VAR","4":"MDT_VIRTPROP","5":"MDT_FUNC_OR_VAR"}},{"byteSize":4,"filename":"libpkmnLib","name":"asEFuncType","values":{"-1":"asFUNC_DUMMY","0":"asFUNC_SYSTEM","1":"asFUNC_SCRIPT","2":"asFUNC_INTERFACE","3":"asFUNC_VIRTUAL","4":"asFUNC_FUNCDEF","5":"asFUNC_IMPORTED","6":"asFUNC_DELEGATE"}},{"byteSize":1,"filename":"libpkmnLib","name":"PkmnScriptCategory","values":{"128":"Weather","129":"Status"}},{"byteSize":1,"filename":"libpkmnLib","name":"TurnChoiceKind","values":{"0":"Pass","1":"Attack","2":"Item","3":"Switch","4":"Flee"}},{"byteSize":4,"filename":"libpkmnLib","name":"syntax_option_type","values":{}},{"byteSize":4,"filename":"libpkmnLib","name":"error_type","values":{"0":"_S_error_collate","1":"_S_error_ctype","10":"_S_error_badrepeat","11":"_S_error_complexity","12":"_S_error_stack","2":"_S_error_escape","3":"_S_error_backref","4":"_S_error_brack","5":"_S_error_paren","6":"_S_error_brace","7":"_S_error_badbrace","8":"_S_error_range","9":"_S_error_space"}},{"byteSize":4,"filename":"libpkmnLib","name":"match_flag_type","values":{}},{"byteSize":1,"filename":"libpkmnLib","name":"DamageSource","values":{"0":"AttackDamage"}},{"byteSize":1,"filename":"libpkmnLib","name":"PkmnDamageSource","values":{"1":"Struggle"}}],"functions":[{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_Construct","parameters":[],"returns":"AngelScriptResolver *"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_Destruct","parameters":[{"name":"p","type":"AngelScriptResolver *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_Initialize","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"lib","type":"BattleLibrary *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_CreateScript","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"name","type":"const char *"},{"name":"script","type":"const char *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_FinalizeModule","parameters":[{"name":"p","type":"AngelScriptResolver *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_LoadScript","parameters":[{"name":"out","type":"Script * &"},{"name":"p","type":"AngelScriptResolver *"},{"name":"category","type":"ScriptCategory"},{"name":"scriptName","type":"const char *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_WriteByteCodeToFile","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"file","type":"const char *"},{"name":"stripDebugInfo","type":"bool"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_LoadByteCodeFromFile","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"file","type":"const char *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_WriteByteCodeToMemory","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"stripDebugInfo","type":"bool"},{"name":"size","type":"long unsigned int &"},{"name":"out","type":"unsigned char * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_LoadByteCodeFromMemory","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"memory","type":"unsigned char *"},{"name":"size","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_RegisterType","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"typeName","type":"const char *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_RegisterTypeMethod","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"typeName","type":"const char *"},{"name":"decl","type":"const char *"},{"name":"func","type":"Function *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelScriptResolver_RegisterGlobalMethod","parameters":[{"name":"p","type":"AngelScriptResolver *"},{"name":"decl","type":"const char *"},{"name":"func","type":"Function *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_AngelscriptScript_Destruct","parameters":[{"name":"p","type":"AngelScriptScript *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Battle_Construct","parameters":[{"name":"out","type":"Battle * &"},{"name":"library","type":"const BattleLibrary *"},{"name":"parties","type":"const BattleParty * *"},{"name":"partiesCount","type":"long unsigned int"},{"name":"canFlee","type":"bool"},{"name":"numberOfSides","type":"unsigned char"},{"name":"creaturesPerSide","type":"unsigned char"},{"name":"randomSeed","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Battle_Destruct","parameters":[{"name":"p","type":"Battle *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Battle_SetWeather","parameters":[{"name":"p","type":"Battle *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Battle_ClearWeather","parameters":[{"name":"p","type":"Battle *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Battle_GetWeatherName","parameters":[{"name":"p","type":"Battle *"}],"returns":"const char *"},{"filename":"libpkmnLib","name":"PkmnLib_BattleLibrary_Construct","parameters":[{"name":"out","type":"BattleLibrary * &"},{"name":"staticLib","type":"PokemonLibrary *"},{"name":"statCalculator","type":"StatCalculator *"},{"name":"damageLibrary","type":"DamageLibrary *"},{"name":"experienceLibrary","type":"ExperienceLibrary *"},{"name":"scriptResolver","type":"ScriptResolver *"},{"name":"miscLibrary","type":"MiscLibrary *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_BattleLibrary_Destruct","parameters":[{"name":"p","type":"BattleLibrary *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_DamageLibrary_Construct","parameters":[],"returns":"DamageLibrary *"},{"filename":"libpkmnLib","name":"PkmnLib_DamageLibrary_Destruct","parameters":[{"name":"p","type":"DamageLibrary *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_WeatherChangeEvent_Destruct","parameters":[{"name":"p","type":"WeatherChangeEvent *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_WeatherChangeEvent_GetWeatherName","parameters":[{"name":"p","type":"WeatherChangeEvent *"}],"returns":"const char *"},{"filename":"libpkmnLib","name":"PkmnLib_ExperienceLibrary_Construct","parameters":[],"returns":"ExperienceLibrary *"},{"filename":"libpkmnLib","name":"PkmnLib_ExperienceLibrary_HandleExperienceGain","parameters":[{"name":"p","type":"ExperienceLibrary *"},{"name":"faintedMon","type":"Creature *"},{"name":"opponents","type":"const Creature * *"},{"name":"numberOfOpponents","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_ExperienceLibrary_Destruct","parameters":[{"name":"p","type":"ExperienceLibrary *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_MiscLibrary_Construct","parameters":[],"returns":"MiscLibrary *"},{"filename":"libpkmnLib","name":"PkmnLib_MiscLibrary_Destruct","parameters":[{"name":"p","type":"MiscLibrary *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_PkmnScript_ModifyCriticalStage","parameters":[{"name":"script","type":"PkmnScript *"},{"name":"attack","type":"ExecutingAttack *"},{"name":"target","type":"Creature *"},{"name":"hit","type":"unsigned char"},{"name":"critStage","type":"unsigned char *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_Construct","parameters":[{"name":"library","type":"const BattleLibrary *"},{"name":"species","type":"const PokemonSpecies *"},{"name":"forme","type":"const PokemonForme *"},{"name":"level","type":"unsigned char"},{"name":"experience","type":"unsigned int"},{"name":"uid","type":"unsigned int"},{"name":"gender","type":"Gender"},{"name":"coloring","type":"unsigned char"},{"name":"heldItem","type":"const Item *"},{"name":"nickname","type":"const char *"},{"name":"hiddenAbility","type":"bool"},{"name":"abilityIndex","type":"unsigned char"},{"name":"moves","type":"const LearnedAttack * *"},{"name":"moveCount","type":"long unsigned int"},{"name":"hpIv","type":"unsigned char"},{"name":"attIv","type":"unsigned char"},{"name":"defIv","type":"unsigned char"},{"name":"sAtIv","type":"unsigned char"},{"name":"sDeIv","type":"unsigned char"},{"name":"spIv","type":"unsigned char"},{"name":"hpEv","type":"unsigned char"},{"name":"attEv","type":"unsigned char"},{"name":"defEv","type":"unsigned char"},{"name":"sAtEv","type":"unsigned char"},{"name":"sDeEv","type":"unsigned char"},{"name":"spEv","type":"unsigned char"},{"name":"nature","type":"const Nature *"}],"returns":"Pokemon *"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_Destruct","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_IsShiny","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"bool"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_GetNature","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"const Nature *"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_GetIndividualValue","parameters":[{"name":"p","type":"const Pokemon *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_SetIndividualValue","parameters":[{"name":"p","type":"Pokemon *"},{"name":"stat","type":"Statistic"},{"name":"value","type":"unsigned char"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_GetEffortValue","parameters":[{"name":"p","type":"const Pokemon *"},{"name":"stat","type":"Statistic"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_SetEffortValue","parameters":[{"name":"p","type":"Pokemon *"},{"name":"stat","type":"Statistic"},{"name":"value","type":"unsigned char"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_SetStatus","parameters":[{"name":"p","type":"Pokemon *"},{"name":"name","type":"const char *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_ClearStatus","parameters":[{"name":"p","type":"Pokemon *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_GetStatusName","parameters":[{"name":"p","type":"Pokemon *"}],"returns":"const char *"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_GetFriendship","parameters":[{"name":"p","type":"const Pokemon *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_SetFriendship","parameters":[{"name":"p","type":"Pokemon *"},{"name":"value","type":"unsigned char"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_ChangeFriendship","parameters":[{"name":"p","type":"Pokemon *"},{"name":"amount","type":"signed char"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Pokemon_Evolve","parameters":[{"name":"p","type":"Pokemon *"},{"name":"species","type":"const PokemonSpecies *"},{"name":"forme","type":"const PokemonForme *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_StatCalculator_Construct","parameters":[],"returns":"StatCalculator *"},{"filename":"libpkmnLib","name":"PkmnLib_StatCalculator_Destruct","parameters":[{"name":"p","type":"StatCalculator *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_C_GetLastException","parameters":[],"returns":"const char *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateLevelEvolution","parameters":[{"name":"level","type":"unsigned char"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateFriendshipEvolution","parameters":[{"name":"friendship","type":"unsigned char"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateKnownMoveEvolution","parameters":[{"name":"move","type":"const MoveData *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateLocationEvolution","parameters":[{"name":"location","type":"const char *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateTimeEvolution","parameters":[{"name":"time","type":"TimeOfDay"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateItemEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateGenderBasedEvolution","parameters":[{"name":"gender","type":"Gender"},{"name":"level","type":"unsigned char"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateItemUseEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateItemUseWithGenderEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"gender","type":"Gender"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateTradeEvolution","parameters":[{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateTradeWithItemEvolution","parameters":[{"name":"item","type":"const Item *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateTradeWithSpeciesEvolution","parameters":[{"name":"traded","type":"const PokemonSpecies *"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_CreateCustomEvolution","parameters":[{"name":"data","type":"const EffectParameter * *"},{"name":"dataLength","type":"long unsigned int"},{"name":"into","type":"const PokemonSpecies *"}],"returns":"const EvolutionData *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_GetMethod","parameters":[{"name":"data","type":"const EvolutionData *"}],"returns":"EvolutionMethod"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_GetNewSpecies","parameters":[{"name":"data","type":"const EvolutionData *"}],"returns":"const PokemonSpecies *"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_GetDataCount","parameters":[{"name":"data","type":"const EvolutionData *"}],"returns":"long unsigned int"},{"filename":"libpkmnLib","name":"PkmnLib_EvolutionData_GetData","parameters":[{"name":"data","type":"const EvolutionData *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const EffectParameter * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_Item_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"category","type":"ItemCategory"},{"name":"battleCategory","type":"BattleItemCategory"},{"name":"price","type":"int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"},{"name":"flingPower","type":"unsigned char"}],"returns":"Item *"},{"filename":"libpkmnLib","name":"PkmnLib_Item_Destruct","parameters":[{"name":"p","type":"const Item *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Item_GetFlingPower","parameters":[{"name":"p","type":"const Item *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_LearnableMoves_Construct","parameters":[{"name":"out","type":"LearnableMoves * &"},{"name":"levelAttackCapacity","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_LearnableMoves_Destruct","parameters":[{"name":"p","type":"const LearnableMoves *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_LearnableMoves_AddEggMove","parameters":[{"name":"p","type":"LearnableMoves *"},{"name":"move","type":"MoveData *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_LearnableMoves_GetEggMovesCount","parameters":[{"name":"p","type":"LearnableMoves *"}],"returns":"long unsigned int"},{"filename":"libpkmnLib","name":"PkmnLib_LearnableMoves_GetEggMoves","parameters":[{"name":"p","type":"LearnableMoves *"}],"returns":"const const MoveData * *"},{"filename":"libpkmnLib","name":"PkmnLib_LibrarySettings_Construct","parameters":[{"name":"maximalLevel","type":"unsigned char"},{"name":"maximalMoves","type":"unsigned char"},{"name":"shinyRate","type":"unsigned short"}],"returns":"const LibrarySettings *"},{"filename":"libpkmnLib","name":"PkmnLib_LibrarySettings_Destruct","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_LibrarySettings_GetShinyRate","parameters":[{"name":"p","type":"const LibrarySettings *"}],"returns":"unsigned short"},{"filename":"libpkmnLib","name":"PkmnLib_Nature_Construct","parameters":[{"name":"increasedStat","type":"Statistic"},{"name":"decreasedStat","type":"Statistic"},{"name":"increasedModifier","type":"float"},{"name":"decreasedModifier","type":"float"}],"returns":"Nature *"},{"filename":"libpkmnLib","name":"PkmnLib_Nature_Destruct","parameters":[{"name":"p","type":"const Nature *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_Nature_GetIncreaseModifier","parameters":[{"name":"p","type":"const Nature *"}],"returns":"float"},{"filename":"libpkmnLib","name":"PkmnLib_Nature_GetDecreaseModifier","parameters":[{"name":"p","type":"const Nature *"}],"returns":"float"},{"filename":"libpkmnLib","name":"PkmnLib_Nature_GetIncreasedStat","parameters":[{"name":"p","type":"const Nature *"}],"returns":"Statistic"},{"filename":"libpkmnLib","name":"PkmnLib_Nature_GetDecreasedStat","parameters":[{"name":"p","type":"const Nature *"}],"returns":"Statistic"},{"filename":"libpkmnLib","name":"PkmnLib_Nature_GetStatModifier","parameters":[{"name":"nature","type":"const Nature *"},{"name":"stat","type":"Statistic"}],"returns":"float"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_Construct","parameters":[{"name":"initialCapacity","type":"long unsigned int"}],"returns":"NatureLibrary *"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_Destruct","parameters":[{"name":"p","type":"const NatureLibrary *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_LoadNature","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"name","type":"const char *"},{"name":"nature","type":"const Nature *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_GetNatureByName","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"name","type":"const char *"},{"name":"out","type":"const Nature * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_GetRandomNatureName","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"rand","type":"Random *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_GetNatureName","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"nature","type":"const Nature *"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_GetNatureCount","parameters":[{"name":"p","type":"const NatureLibrary *"}],"returns":"long unsigned int"},{"filename":"libpkmnLib","name":"PkmnLib_NatureLibrary_GetNatureByIndex","parameters":[{"name":"p","type":"NatureLibrary *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const char * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonForme_Construct","parameters":[{"name":"name","type":"const char *"},{"name":"height","type":"float"},{"name":"weight","type":"float"},{"name":"baseExperience","type":"unsigned int"},{"name":"types","type":"unsigned char *"},{"name":"typeLength","type":"long unsigned int"},{"name":"baseHealth","type":"unsigned short"},{"name":"baseAttack","type":"unsigned short"},{"name":"baseDefense","type":"unsigned short"},{"name":"baseMagicalAttack","type":"unsigned short"},{"name":"baseMagicalDefense","type":"unsigned short"},{"name":"baseSpeed","type":"unsigned short"},{"name":"talents","type":"const char * *"},{"name":"talentsLength","type":"long unsigned int"},{"name":"secretTalents","type":"const char * *"},{"name":"secretTalentsLength","type":"long unsigned int"},{"name":"attacks","type":"const LearnableMoves *"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"PokemonForme *"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonLibrary_Construct","parameters":[{"name":"out","type":"PokemonLibrary * &"},{"name":"settings","type":"LibrarySettings *"},{"name":"species","type":"SpeciesLibrary *"},{"name":"moves","type":"MoveLibrary *"},{"name":"items","type":"ItemLibrary *"},{"name":"growthRates","type":"GrowthRateLibrary *"},{"name":"typeLibrary","type":"TypeLibrary *"},{"name":"natures","type":"NatureLibrary *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonLibrary_Destruct","parameters":[{"name":"p","type":"const PokemonLibrary *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonLibrary_GetNatureLibrary","parameters":[{"name":"p","type":"const PokemonLibrary *"}],"returns":"const NatureLibrary *"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_Construct","parameters":[{"name":"out","type":"const PokemonSpecies * &"},{"name":"id","type":"unsigned short"},{"name":"name","type":"const char *"},{"name":"defaultForme","type":"const PokemonForme *"},{"name":"genderRatio","type":"float"},{"name":"growthRate","type":"const char *"},{"name":"captureRate","type":"unsigned char"},{"name":"baseHappiness","type":"unsigned char"},{"name":"eggGroupsRaw","type":"const const char * *"},{"name":"eggGroupsLength","type":"long unsigned int"},{"name":"flags","type":"const char * *"},{"name":"flagsCount","type":"long unsigned int"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_Destruct","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_GetBaseHappiness","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_AddEvolution","parameters":[{"name":"p","type":"PokemonSpecies *"},{"name":"evo","type":"EvolutionData *"}],"returns":"void"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_GetEvolutionCount","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"long unsigned int"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_GetEvolution","parameters":[{"name":"p","type":"const PokemonSpecies *"},{"name":"index","type":"long unsigned int"},{"name":"out","type":"const EvolutionData * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_GetEvolutions","parameters":[{"name":"p","type":"const PokemonSpecies *"},{"name":"out","type":"const const EvolutionData * * &"}],"returns":"unsigned char"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_GetEggGroupCount","parameters":[{"name":"p","type":"const PokemonSpecies *"}],"returns":"long unsigned int"},{"filename":"libpkmnLib","name":"PkmnLib_PokemonSpecies_GetEggGroup","parameters":[{"name":"p","type":"const PokemonSpecies *"},{"name":"index","type":"long unsigned int"}],"returns":"const char *"},{"filename":"libpkmnLib","name":"PkmnLib_SpeciesLibrary_FindPreEvolution","parameters":[{"name":"p","type":"const SpeciesLibrary *"},{"name":"species","type":"const PokemonSpecies *"}],"returns":"const PokemonSpecies *"}]}
diff --git a/PkmnLibSharpTests/Library/EffectParameterTests.cs b/PkmnLibSharpTests/Library/EffectParameterTests.cs
index 9b39f12..88267f4 100644
--- a/PkmnLibSharpTests/Library/EffectParameterTests.cs
+++ b/PkmnLibSharpTests/Library/EffectParameterTests.cs
@@ -51,7 +51,7 @@ namespace PkmnLibSharpTests.Library
         {
             var p = new EffectParameter(10);
             var ex = Assert.Throws<NativeException>(() => { p.AsString(); });
-            Assert.AreEqual("[CreatureLibLibrary] - '[CreatureLib_EffectParameter_AsString] [EffectParameter.hpp:52] Cast effect parameter to string, but was Int'", ex.Message);
+            Assert.AreEqual("[CreatureLibLibrary] - '[CreatureLib_EffectParameter_AsString] [EffectParameter.hpp:50] Cast effect parameter to string, but was Int'", ex.Message);
             p.Dispose();
         }
     }