Initial work on battle side.

This commit is contained in:
Deukhoofd 2020-07-18 16:49:11 +02:00
parent 5ad3e2e040
commit 049eb480c0
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
39 changed files with 835 additions and 88 deletions

View File

@ -0,0 +1,31 @@
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public class AngelScriptResolver : ScriptResolver
{
public AngelScriptResolver() : base(Pkmnlib.Generated.AngelScriptResolver.Construct())
{
}
public void Initialize(BattleLibrary library)
{
Pkmnlib.Generated.AngelScriptResolver.Initialize(Ptr, library.Ptr).Assert();
}
public void CreateScript(string name, string script)
{
Pkmnlib.Generated.AngelScriptResolver.CreateScript(Ptr, name.ToPtr(), script.ToPtr()).Assert();
}
public void FinalizeModule()
{
Pkmnlib.Generated.AngelScriptResolver.FinalizeModule(Ptr).Assert();
}
protected override void DeletePtr()
{
Pkmnlib.Generated.AngelScriptResolver.Destruct(Ptr).Assert();
}
}
}

View File

@ -0,0 +1,99 @@
using System;
using PkmnLibSharp.Library;
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public class BattleLibrary : PointerWrapper
{
private PokemonLibrary _static;
private StatCalculator _statCalculator;
private DamageLibrary _damageLibrary;
private MiscLibrary _miscLibrary;
private ExperienceLibrary _experienceLibrary;
public PokemonLibrary StaticLibrary
{
get
{
if (_static != null) return _static;
var ptr = Creaturelibbattling.Generated.BattleLibrary.GetStaticLib(Ptr);
if (TryResolvePointer(ptr, out _static))
return _static;
_static = new PokemonLibrary(ptr);
return _static;
}
}
public StatCalculator StatCalculator
{
get
{
if (_statCalculator != null) return _statCalculator;
var ptr = Creaturelibbattling.Generated.BattleLibrary.GetStatCalculator(Ptr);
if (TryResolvePointer(ptr, out _statCalculator))
return _statCalculator;
_statCalculator = new StatCalculator(ptr);
return _statCalculator;
}
}
public DamageLibrary DamageLibrary
{
get
{
if (_damageLibrary != null) return _damageLibrary;
var ptr = Creaturelibbattling.Generated.BattleLibrary.GetDamageLibrary(Ptr);
if (TryResolvePointer(ptr, out _damageLibrary))
return _damageLibrary;
_damageLibrary = new DamageLibrary(ptr);
return _damageLibrary;
}
}
public MiscLibrary MiscLibrary
{
get
{
if (_miscLibrary != null) return _miscLibrary;
var ptr = Creaturelibbattling.Generated.BattleLibrary.GetMiscLibrary(Ptr);
if (TryResolvePointer(ptr, out _miscLibrary))
return _miscLibrary;
_miscLibrary = new MiscLibrary(ptr);
return _miscLibrary;
}
}
public ExperienceLibrary ExperienceLibrary
{
get
{
if (_experienceLibrary != null) return _experienceLibrary;
var ptr = Creaturelibbattling.Generated.BattleLibrary.GetExperienceLibrary(Ptr);
if (TryResolvePointer(ptr, out _experienceLibrary))
return _experienceLibrary;
_experienceLibrary = new ExperienceLibrary(ptr);
return _experienceLibrary;
}
}
private BattleLibrary(IntPtr ptr) : base(ptr)
{
}
public static BattleLibrary Create(PokemonLibrary staticLibrary, StatCalculator statCalculator,
DamageLibrary damageLibrary, ExperienceLibrary experienceLibrary, ScriptResolver scriptResolver,
MiscLibrary miscLibrary)
{
var ptr = IntPtr.Zero;
Pkmnlib.Generated.BattleLibrary.Construct(ref ptr, staticLibrary.Ptr, statCalculator.Ptr, damageLibrary.Ptr,
experienceLibrary.Ptr, scriptResolver.Ptr, miscLibrary.Ptr).Assert();
return new BattleLibrary(ptr);
}
protected override void DeletePtr()
{
Pkmnlib.Generated.BattleLibrary.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1,54 @@
using System;
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public class DamageLibrary : PointerWrapper
{
internal DamageLibrary(IntPtr ptr) : base(ptr)
{
}
public DamageLibrary() : base(Pkmnlib.Generated.DamageLibrary.Construct())
{
}
public uint GetDamage(IntPtr attack, Pokemon target, byte hitIndex, IntPtr hitData)
{
uint val = 0;
Creaturelibbattling.Generated.DamageLibrary.GetDamage(ref val, Ptr, attack, target.Ptr, hitIndex, hitData)
.Assert();
return val;
}
public byte GetBasePower(IntPtr attack, Pokemon target, byte hitIndex, IntPtr hitData)
{
byte val = 0;
Creaturelibbattling.Generated.DamageLibrary.GetBasePower(ref val, Ptr, attack, target.Ptr, hitIndex, hitData)
.Assert();
return val;
}
public float GetStatModifier(IntPtr attack, Pokemon target, byte hitIndex, IntPtr hitData)
{
float val = 0;
Creaturelibbattling.Generated.DamageLibrary.GetStatModifier(ref val, Ptr, attack, target.Ptr, hitIndex, hitData)
.Assert();
return val;
}
public float GetDamageModifier(IntPtr attack, Pokemon target, byte hitIndex, IntPtr hitData)
{
float val = 0;
Creaturelibbattling.Generated.DamageLibrary
.GetDamageModifier(ref val, Ptr, attack, target.Ptr, hitIndex, hitData)
.Assert();
return val;
}
protected override void DeletePtr()
{
Pkmnlib.Generated.DamageLibrary.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1,30 @@
using System;
using System.Collections.Generic;
using System.Linq;
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public class ExperienceLibrary : PointerWrapper
{
public ExperienceLibrary(IntPtr ptr) : base(ptr)
{
}
public ExperienceLibrary() : base(Pkmnlib.Generated.ExperienceLibrary.Construct())
{
}
void HandleExperienceGain(Pokemon faintedMon, IReadOnlyCollection<Pokemon> opponents)
{
Pkmnlib.Generated.ExperienceLibrary.HandleExperienceGain(Ptr, faintedMon.Ptr,
opponents.Select(x => x.Ptr).ToArray().ArrayPtr(),
(ulong) opponents.Count);
}
protected override void DeletePtr()
{
Pkmnlib.Generated.ExperienceLibrary.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1,7 @@
namespace PkmnLibSharp.Battling
{
public enum Gender
{
Male, Female, Genderless
}
}

View File

@ -0,0 +1,25 @@
using System;
using Creaturelibbattling;
using Creaturelibbattling.Generated;
using PkmnLibSharp.Library.Moves;
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public class LearnedMove : PointerWrapper
{
internal LearnedMove(IntPtr ptr) : base(ptr){}
public static LearnedMove Create(MoveData move, byte maxUses, MoveLearnMethod learnMethod)
{
var ptr = IntPtr.Zero;
LearnedAttack.Construct(ref ptr, move.Ptr, maxUses, (AttackLearnMethod) learnMethod).Assert();
return new LearnedMove(ptr);
}
protected override void DeletePtr()
{
LearnedAttack.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1,43 @@
using System;
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public class MiscLibrary : PointerWrapper
{
internal MiscLibrary(IntPtr ptr) : base(ptr)
{
}
public MiscLibrary() : base(Pkmnlib.Generated.MiscLibrary.Construct())
{
}
public bool IsCritical(IntPtr move, Pokemon target, byte hitNumber)
{
byte b = 0;
Creaturelibbattling.Generated.MiscLibrary.IsCritical(ref b, Ptr, move, target.Ptr, hitNumber).Assert();
return b == MarshalHelper.True;
}
public bool CanFlee(IntPtr switchChoice)
{
byte b = 0;
Creaturelibbattling.Generated.MiscLibrary.CanFlee(ref b, Ptr, switchChoice).Assert();
return b == MarshalHelper.True;
}
public IntPtr ReplacementAttack(Pokemon user, byte sideTarget, byte creatureTarget)
{
var b = IntPtr.Zero;
Creaturelibbattling.Generated.MiscLibrary.ReplacementAttack(ref b, Ptr, user.Ptr, sideTarget, creatureTarget)
.Assert();
return b;
}
protected override void DeletePtr()
{
Pkmnlib.Generated.MiscLibrary.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1,8 @@
namespace PkmnLibSharp.Battling
{
public enum MoveLearnMethod
{
Unknown = 0,
Level = 1,
}
}

View File

@ -0,0 +1,30 @@
using System.Collections.Generic;
using System.Linq;
using PkmnLibSharp.Library;
using PkmnLibSharp.Utilities;
using Item = PkmnLibSharp.Library.Items.Item;
using Nature = PkmnLibSharp.Library.Nature;
namespace PkmnLibSharp.Battling
{
public class Pokemon : PointerWrapper
{
public Pokemon(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) :
base(Pkmnlib.Generated.Pokemon.Construct(library.Ptr, species.Ptr, forme.Ptr, level, experience,
uid, (Pkmnlib.Gender) gender, coloring, heldItem.Ptr, nickname.ToPtr(), hiddenAbility.ToNative(),
abilityIndex,
moves.Select(x => x.Ptr).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))
{}
protected override void DeletePtr()
{
Pkmnlib.Generated.Pokemon.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1,154 @@
using System;
using System.Collections.Generic;
using PkmnLibSharp.Library;
using PkmnLibSharp.Library.Items;
using Random = PkmnLibSharp.Utilities.Random;
namespace PkmnLibSharp.Battling
{
public class PokemonBuilder
{
private BattleLibrary _library;
public string Species { get; }
public string Forme { get; private set; } = "default";
public string Nickname { get; private set; } = "";
public string Ability { get; private set; } = "";
public string Nature { get; private set; } = "";
public Gender Gender { get; private set; } = (Gender) (-1);
public uint Identifier { get; private set; } = 0;
public byte Level { get; }
public StatisticSet<byte> IVs;
public StatisticSet<byte> EVs;
public bool? IsForceShiny { get; private set; }
public string HeldItem { get; private set; }
public List<(string moveName, MoveLearnMethod learnMethod)> LearnedMoves { get; } =
new List<(string moveName, MoveLearnMethod learnMethod)>();
public PokemonBuilder(BattleLibrary library, string species, byte level)
{
_library = library;
Species = species;
Level = level;
}
public PokemonBuilder WithForme(string forme)
{
Forme = forme;
return this;
}
public PokemonBuilder WithGender(Gender gender)
{
Gender = gender;
return this;
}
public PokemonBuilder ForceShiny(bool value)
{
IsForceShiny = value;
return this;
}
public PokemonBuilder WithHeldItem(string heldItem)
{
HeldItem = heldItem;
return this;
}
public PokemonBuilder LearnMove(string moveName, MoveLearnMethod moveLearnMethod)
{
if (LearnedMoves.Count > _library.StaticLibrary.Settings.MaximalMoves)
{
throw new Exception("Too many moves for Pokemon.");
}
LearnedMoves.Add((moveName, moveLearnMethod));
return this;
}
public Pokemon Build()
{
if (!_library.StaticLibrary.SpeciesLibrary.TryGet(Species, out var species))
{
throw new Exception($"Species '{Species}' was not found.");
}
if (!species.TryGetForme(Forme, out var forme))
{
throw new Exception($"Forme '{Forme}' was not found on species '{Species}'");
}
var experience = _library.StaticLibrary.GrowthRateLibrary.CalculateExperience(species.GrowthRate, Level);
var random = new Random();
var uid = random.GetUnsigned(0, uint.MaxValue);
if (Gender == (Gender) (-1))
{
Gender = species.GetRandomGender(random);
}
byte coloring = 0;
if (IsForceShiny.HasValue)
{
coloring = (byte) (IsForceShiny.Value ? 1 : 0);
}
else if (random.Get(_library.StaticLibrary.Settings.ShinyRate) == 0)
{
coloring = 1;
}
Item heldItem = null;
if (HeldItem != null)
{
if (!_library.StaticLibrary.ItemLibrary.TryGet(HeldItem, out heldItem))
{
throw new Exception($"Item '{HeldItem}' was not found.");
}
}
byte abilityIndex = 0;
var isHiddenAbility = false;
if (string.IsNullOrEmpty(Ability))
{
abilityIndex = forme.GetRandomAbility(random);
}
else
{
abilityIndex = (byte) forme.Abilities.IndexOf(Ability);
if (abilityIndex == -1)
{
abilityIndex = (byte) forme.HiddenAbilities.IndexOf(Ability);
if (abilityIndex == -1)
{
throw new Exception(
$"Invalid ability '{Ability}' for Pokemon '{species.Name}' and forme '{forme.Name}'.");
}
isHiddenAbility = true;
}
}
var moves = new LearnedMove[_library.StaticLibrary.Settings.MaximalMoves];
for (var i = 0; i < LearnedMoves.Count; i++)
{
if (!_library.StaticLibrary.MoveLibrary.TryGet(LearnedMoves[i].moveName, out var move))
{
throw new Exception($"Move '{LearnedMoves[i].moveName}' was not found.");
}
moves[i] = LearnedMove.Create(move, move.BaseUsages, LearnedMoves[i].learnMethod);
}
if (string.IsNullOrEmpty(Nature))
{
Nature = _library.StaticLibrary.NatureLibrary.GetRandomNatureName(random);
}
var nature = _library.StaticLibrary.NatureLibrary.GetNature(Nature);
return new Pokemon(_library, species, forme, Level, experience, uid, Gender, coloring, heldItem, Nickname,
isHiddenAbility, abilityIndex, moves, IVs, EVs, nature);
}
}
}

View File

@ -0,0 +1,12 @@
using System;
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public abstract class ScriptResolver : PointerWrapper
{
protected ScriptResolver(IntPtr ptr) : base(ptr)
{
}
}
}

View File

@ -0,0 +1,38 @@
using System;
using PkmnLibSharp.Library;
using PkmnLibSharp.Utilities;
namespace PkmnLibSharp.Battling
{
public class StatCalculator : PointerWrapper
{
internal StatCalculator(IntPtr ptr) : base(ptr)
{
}
public StatCalculator() : base(Pkmnlib.Generated.StatCalculator.Construct())
{
}
public uint CalculateFlatStat(Pokemon pokemon, Statistic stat)
{
uint val = 0;
Creaturelibbattling.Generated.BattleStatCalculator
.CalculateFlatStat(ref val, Ptr, pokemon.Ptr, (Creaturelibbattling.Statistic) stat).Assert();
return val;
}
public uint CalculateBoostedStat(Pokemon pokemon, Statistic stat)
{
uint val = 0;
Creaturelibbattling.Generated.BattleStatCalculator
.CalculateBoostedStat(ref val, Ptr, pokemon.Ptr, (Creaturelibbattling.Statistic) stat).Assert();
return val;
}
protected override void DeletePtr()
{
Pkmnlib.Generated.StatCalculator.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1,75 @@
// AUTOMATICALLY GENERATED, DO NOT EDIT
using System;
using System.Runtime.InteropServices;
namespace Arbutils.Generated
{
internal static class Random
{
/// <returns>Random *</returns>
[DllImport("Arbutils", 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")]
internal static extern IntPtr ConstructWithSeed(ulong seed);
/// <param name="p">Random *</param>
/// <returns>void</returns>
[DllImport("Arbutils", 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")]
internal static extern float GetFloat(IntPtr p);
/// <param name="p">Random *</param>
/// <returns>double</returns>
[DllImport("Arbutils", 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")]
internal static extern int Get(IntPtr p);
/// <param name="p">Random *</param>
/// <param name="max">int</param>
/// <returns>int</returns>
[DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetWithMax")]
internal static extern int GetWithMax(IntPtr p, int max);
/// <param name="p">Random *</param>
/// <param name="min">int</param>
/// <param name="max">int</param>
/// <returns>int</returns>
[DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetInLimits")]
internal static extern int GetInLimits(IntPtr p, int min, int max);
/// <param name="p">Random *</param>
/// <returns>unsigned int</returns>
[DllImport("Arbutils", 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>
/// <returns>unsigned int</returns>
[DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsignedWithMax")]
internal static extern uint GetUnsignedWithMax(IntPtr p, uint max);
/// <param name="p">Random *</param>
/// <param name="min">unsigned int</param>
/// <param name="max">unsigned int</param>
/// <returns>unsigned int</returns>
[DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetUnsignedInLimits")]
internal static extern uint GetUnsignedInLimits(IntPtr p, uint min, uint max);
/// <param name="p">Random *</param>
/// <returns>long unsigned int</returns>
[DllImport("Arbutils", CallingConvention = CallingConvention.Cdecl, EntryPoint= "Arbutils_Random_GetSeed")]
internal static extern ulong GetSeed(IntPtr p);
}
}

View File

@ -211,10 +211,9 @@ namespace Creaturelibbattling.Generated
internal static extern ulong GetAttacksCount(IntPtr p); internal static extern ulong GetAttacksCount(IntPtr p);
/// <param name="p">Creature *</param> /// <param name="p">Creature *</param>
/// <param name="index">long unsigned int</param>
/// <returns>const LearnedAttack * *</returns> /// <returns>const LearnedAttack * *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttack")] [DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttacks")]
internal static extern IntPtr GetAttack(IntPtr p, ulong index); internal static extern IntPtr GetAttacks(IntPtr p);
/// <param name="p">const Creature *</param> /// <param name="p">const Creature *</param>
/// <returns>const CreatureSpecies *</returns> /// <returns>const CreatureSpecies *</returns>

View File

@ -80,12 +80,12 @@ namespace Creatureliblibrary.Generated
[DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariant")] [DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariant")]
internal static extern byte GetVariant(ref IntPtr @out, IntPtr p, IntPtr name); internal static extern byte GetVariant(ref IntPtr @out, IntPtr p, IntPtr name);
/// <param name="out">const SpeciesVariant *</param> /// <param name="out">const SpeciesVariant * &</param>
/// <param name="p">const CreatureSpecies *</param> /// <param name="p">const CreatureSpecies *</param>
/// <param name="hash">unsigned int</param> /// <param name="hash">unsigned int</param>
/// <returns>unsigned char</returns> /// <returns>unsigned char</returns>
[DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariantWithHash")] [DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetVariantWithHash")]
internal static extern byte GetVariantWithHash(IntPtr @out, IntPtr p, uint hash); internal static extern byte GetVariantWithHash(ref IntPtr @out, IntPtr p, uint hash);
/// <param name="p">CreatureSpecies *</param> /// <param name="p">CreatureSpecies *</param>
/// <param name="name">const char *</param> /// <param name="name">const char *</param>
@ -94,5 +94,11 @@ namespace Creatureliblibrary.Generated
[DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_SetVariant")] [DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_SetVariant")]
internal static extern byte SetVariant(IntPtr p, IntPtr name, IntPtr variant); 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("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureSpecies_GetRandomGender")]
internal static extern Gender GetRandomGender(IntPtr p, IntPtr random);
} }
} }

View File

@ -92,5 +92,11 @@ namespace Creatureliblibrary.Generated
[DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetLearnableAttacks")] [DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetLearnableAttacks")]
internal static extern IntPtr GetLearnableAttacks(IntPtr p); internal static extern IntPtr GetLearnableAttacks(IntPtr p);
/// <param name="p">SpeciesVariant *</param>
/// <param name="rand">Random *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_SpeciesVariant_GetRandomTalent")]
internal static extern byte GetRandomTalent(IntPtr p, IntPtr rand);
} }
} }

View File

@ -0,0 +1,27 @@
// AUTOMATICALLY GENERATED, DO NOT EDIT
using System;
using System.Runtime.InteropServices;
namespace Pkmnlib.Generated
{
internal static class ExperienceLibrary
{
/// <returns>ExperienceLibrary *</returns>
[DllImport("pkmnLib", CallingConvention = CallingConvention.Cdecl, EntryPoint= "PkmnLib_ExperienceLibrary_Construct")]
internal static extern IntPtr Construct();
/// <param name="p">ExperienceLibrary *</param>
/// <param name="faintedMon">Creature *</param>
/// <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")]
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")]
internal static extern void Destruct(IntPtr p);
}
}

View File

@ -2,19 +2,23 @@ using System;
using System.Collections.Immutable; using System.Collections.Immutable;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using Creatureliblibrary;
using Creatureliblibrary.Generated; using Creatureliblibrary.Generated;
using PkmnLibSharp.Utilities; using PkmnLibSharp.Utilities;
using Random = PkmnLibSharp.Utilities.Random;
namespace PkmnLibSharp.Library namespace PkmnLibSharp.Library
{ {
public class Forme : PointerWrapper public class Forme : PointerWrapper
{ {
private string _name;
private ImmutableArray<byte> _types;
private ImmutableArray<string> _abilities; private ImmutableArray<string> _abilities;
private ImmutableArray<string> _hiddenAbilities; private ImmutableArray<string> _hiddenAbilities;
private LearnableMoves _moves; private LearnableMoves _moves;
private string _name;
private ImmutableArray<byte> _types;
internal Forme(IntPtr parent) : base(parent)
{
}
public string Name => _name ??= SpeciesVariant.GetName(Ptr).PtrString(); public string Name => _name ??= SpeciesVariant.GetName(Ptr).PtrString();
public float Height => SpeciesVariant.GetHeight(Ptr); public float Height => SpeciesVariant.GetHeight(Ptr);
@ -30,10 +34,7 @@ namespace PkmnLibSharp.Library
var typesCount = SpeciesVariant.GetTypeCount(Ptr); var typesCount = SpeciesVariant.GetTypeCount(Ptr);
var types = new byte[typesCount]; var types = new byte[typesCount];
for (ulong i = 0; i < typesCount; i++) for (ulong i = 0; i < typesCount; i++) types[i] = SpeciesVariant.GetType(Ptr, i);
{
types[i] = SpeciesVariant.GetType(Ptr, i);
}
_types = types.ToImmutableArray(); _types = types.ToImmutableArray();
return _types; return _types;
@ -63,7 +64,7 @@ namespace PkmnLibSharp.Library
var abilities = new string[abilityCount]; var abilities = new string[abilityCount];
for (byte i = 0; i < abilityCount; i++) for (byte i = 0; i < abilityCount; i++)
{ {
IntPtr s = IntPtr.Zero; var s = IntPtr.Zero;
SpeciesVariant.GetTalent(Ptr, MarshalHelper.False, i, ref s).Assert(); SpeciesVariant.GetTalent(Ptr, MarshalHelper.False, i, ref s).Assert();
abilities[i] = s.PtrString(); abilities[i] = s.PtrString();
} }
@ -84,7 +85,7 @@ namespace PkmnLibSharp.Library
var abilities = new string[abilityCount]; var abilities = new string[abilityCount];
for (byte i = 0; i < abilityCount; i++) for (byte i = 0; i < abilityCount; i++)
{ {
IntPtr s = IntPtr.Zero; var s = IntPtr.Zero;
SpeciesVariant.GetTalent(Ptr, MarshalHelper.True, i, ref s).Assert(); SpeciesVariant.GetTalent(Ptr, MarshalHelper.True, i, ref s).Assert();
abilities[i] = s.PtrString(); abilities[i] = s.PtrString();
} }
@ -100,10 +101,7 @@ namespace PkmnLibSharp.Library
{ {
if (_moves != null) return _moves; if (_moves != null) return _moves;
var movesPtr = SpeciesVariant.GetLearnableAttacks(Ptr); var movesPtr = SpeciesVariant.GetLearnableAttacks(Ptr);
if (!TryResolvePointer(movesPtr, out _moves)) if (!TryResolvePointer(movesPtr, out _moves)) _moves = new LearnableMoves(movesPtr);
{
_moves = new LearnableMoves(movesPtr);
}
return _moves; return _moves;
} }
@ -114,33 +112,30 @@ namespace PkmnLibSharp.Library
return Types[index]; return Types[index];
} }
public static unsafe Forme Create(string name, float height, float weight, uint baseExperience, byte[] types, public static Forme Create(string name, float height, float weight, uint baseExperience, byte[] types,
ushort baseHealth, ushort baseAttack, ushort baseDefense, ushort baseSpecialAttack, ushort baseHealth, ushort baseAttack, ushort baseDefense, ushort baseSpecialAttack,
ushort baseSpecialDefense, ushort baseSpeed, string[] abilities, string[] hiddenAbilities, ushort baseSpecialDefense, ushort baseSpeed, string[] abilities, string[] hiddenAbilities,
LearnableMoves moves) LearnableMoves moves)
{ {
var abilitiesConverted = abilities.Select(x => x.ToPtr()).ToArray(); var abilitiesConverted = abilities.Select(x => x.ToPtr()).ToArray();
var hiddenAbilitiesConverted = hiddenAbilities.Select(x => x.ToPtr()).ToArray(); var hiddenAbilitiesConverted = hiddenAbilities.Select(x => x.ToPtr()).ToArray();
fixed (IntPtr* ab = abilitiesConverted) var ab = abilitiesConverted.ArrayPtr();
{ var hab = abilitiesConverted.ArrayPtr();
fixed (IntPtr* hab = hiddenAbilitiesConverted) var ptr = SpeciesVariant.Construct(name.ToPtr(), height, weight, baseExperience, types.ArrayPtr(),
{ (ulong) types.Length, baseHealth, baseAttack, baseDefense, baseSpecialAttack,
var ptr = SpeciesVariant.Construct(name.ToPtr(), height, weight, baseExperience, types.ArrayPtr(), baseSpecialDefense, baseSpeed, (IntPtr) ab, (ulong) abilities.Length, (IntPtr) hab,
(ulong) types.Length, baseHealth, baseAttack, baseDefense, baseSpecialAttack, (ulong) hiddenAbilities.Length, moves.Ptr);
baseSpecialDefense, baseSpeed, (IntPtr) ab, (ulong) abilities.Length, (IntPtr) hab, var f = new Forme(ptr);
(ulong) hiddenAbilities.Length, moves.Ptr); foreach (var intPtr in abilitiesConverted)
var f = new Forme(ptr); Marshal.FreeHGlobal(intPtr);
foreach (var intPtr in abilitiesConverted) foreach (var intPtr in hiddenAbilitiesConverted)
Marshal.FreeHGlobal(intPtr); Marshal.FreeHGlobal(intPtr);
foreach (var intPtr in hiddenAbilitiesConverted) return f;
Marshal.FreeHGlobal(intPtr);
return f;
}
}
} }
internal Forme(IntPtr parent) : base(parent) public byte GetRandomAbility(Random rand)
{ {
return SpeciesVariant.GetRandomTalent(Ptr, rand.Ptr);
} }
protected internal override void MarkAsDeleted() protected internal override void MarkAsDeleted()

View File

@ -6,6 +6,6 @@ namespace PkmnLibSharp.Library.Items
Healing = 1, Healing = 1,
StatusHealing = 2, StatusHealing = 2,
Pokeball = 3, Pokeball = 3,
MiscBattleItem = 4, MiscBattleItem = 4
} }
} }

View File

@ -8,6 +8,10 @@ namespace PkmnLibSharp.Library.Items
{ {
private string _name; private string _name;
internal Item(IntPtr ptr) : base(ptr)
{
}
public string Name => _name ??= Creatureliblibrary.Generated.Item.GetName(Ptr).PtrString(); public string Name => _name ??= Creatureliblibrary.Generated.Item.GetName(Ptr).PtrString();
public ItemCategory Category => (ItemCategory) Creatureliblibrary.Generated.Item.GetCategory(Ptr); public ItemCategory Category => (ItemCategory) Creatureliblibrary.Generated.Item.GetCategory(Ptr);
@ -22,10 +26,6 @@ namespace PkmnLibSharp.Library.Items
return Creatureliblibrary.Generated.Item.HasFlag(Ptr, s.ToPtr()) == MarshalHelper.True; return Creatureliblibrary.Generated.Item.HasFlag(Ptr, s.ToPtr()) == MarshalHelper.True;
} }
internal Item(IntPtr ptr) : base(ptr)
{
}
public static Item Create(string name, ItemCategory category, BattleItemCategory battleCategory, public static Item Create(string name, ItemCategory category, BattleItemCategory battleCategory,
int price, int price,
string[] flags, byte flingPower) string[] flags, byte flingPower)

View File

@ -9,6 +9,6 @@ namespace PkmnLibSharp.Library
TechnicalMachine = 4, TechnicalMachine = 4,
FormeChanger = 5, FormeChanger = 5,
KeyItem = 6, KeyItem = 6,
Mail = 7, Mail = 7
} }
} }

View File

@ -6,7 +6,18 @@ namespace PkmnLibSharp.Library.Items
{ {
public class ItemLibrary : PointerWrapper public class ItemLibrary : PointerWrapper
{ {
private readonly Dictionary<string, Item> _cache = new Dictionary<string, Item>(StringComparer.InvariantCultureIgnoreCase); private readonly Dictionary<string, Item> _cache =
new Dictionary<string, Item>(StringComparer.InvariantCultureIgnoreCase);
internal ItemLibrary(IntPtr ptr) : base(ptr)
{
}
public ItemLibrary(ulong initialCapacity) : base(
Creatureliblibrary.Generated.ItemLibrary.Construct(initialCapacity))
{
}
public ulong Count => Creatureliblibrary.Generated.ItemLibrary.GetCount(Ptr); public ulong Count => Creatureliblibrary.Generated.ItemLibrary.GetCount(Ptr);
public void Insert(string key, Item item) public void Insert(string key, Item item)
@ -33,6 +44,7 @@ namespace PkmnLibSharp.Library.Items
_cache.Add(key, item); _cache.Add(key, item);
return true; return true;
} }
item = new Item(ptr); item = new Item(ptr);
_cache.Add(key, item); _cache.Add(key, item);
return true; return true;
@ -49,33 +61,21 @@ namespace PkmnLibSharp.Library.Items
_cache.Add(key, item); _cache.Add(key, item);
return item; return item;
} }
item = new Item(ptr); item = new Item(ptr);
_cache.Add(key, item); _cache.Add(key, item);
return item; return item;
} }
internal ItemLibrary(IntPtr ptr) : base(ptr)
{
}
public ItemLibrary(ulong initialCapacity) : base(
Creatureliblibrary.Generated.ItemLibrary.Construct(initialCapacity))
{
}
protected internal override void MarkAsDeleted() protected internal override void MarkAsDeleted()
{ {
base.MarkAsDeleted(); base.MarkAsDeleted();
foreach (var item in _cache) foreach (var item in _cache) item.Value.MarkAsDeleted();
{
item.Value.MarkAsDeleted();
}
} }
protected override void DeletePtr() protected override void DeletePtr()
{ {
Creatureliblibrary.Generated.ItemLibrary.Destruct(Ptr); Creatureliblibrary.Generated.ItemLibrary.Destruct(Ptr);
} }
} }
} }

View File

@ -4,6 +4,6 @@ namespace PkmnLibSharp.Library.Moves
{ {
Physical = 0, Physical = 0,
Special = 1, Special = 1,
Status = 2, Status = 2
} }
} }

View File

@ -1,9 +1,8 @@
using System; using System;
using System.Linq; using System.Linq;
using Creatureliblibrary;
using Creatureliblibrary.Generated; using Creatureliblibrary.Generated;
using Pkmnlib;
using PkmnLibSharp.Utilities; using PkmnLibSharp.Utilities;
using AttackCategory = Creatureliblibrary.AttackCategory;
namespace PkmnLibSharp.Library.Moves namespace PkmnLibSharp.Library.Moves
{ {
@ -12,6 +11,10 @@ namespace PkmnLibSharp.Library.Moves
private string _name; private string _name;
private string _secondaryEffectName; private string _secondaryEffectName;
internal MoveData(IntPtr ptr) : base(ptr)
{
}
public string Name => _name ??= AttackData.GetName(Ptr).PtrString(); public string Name => _name ??= AttackData.GetName(Ptr).PtrString();
public byte Type => AttackData.GetType(Ptr); public byte Type => AttackData.GetType(Ptr);
public MoveCategory Category => (MoveCategory) AttackData.GetCategory(Ptr); public MoveCategory Category => (MoveCategory) AttackData.GetCategory(Ptr);
@ -40,15 +43,11 @@ namespace PkmnLibSharp.Library.Moves
var f = flags.Select(x => x.ToPtr()).ToArray().ArrayPtr(); var f = flags.Select(x => x.ToPtr()).ToArray().ArrayPtr();
AttackData.Construct(ref ptr, name.ToPtr(), type, (AttackCategory) category, power, accuracy, baseUsage, AttackData.Construct(ref ptr, name.ToPtr(), type, (AttackCategory) category, power, accuracy, baseUsage,
(Creatureliblibrary.AttackTarget) target, priority, effectChance, effectName.ToPtr(), pars, (AttackTarget) target, priority, effectChance, effectName.ToPtr(), pars,
(ulong) parameters.Length, f, (ulong) flags.Length).Assert(); (ulong) parameters.Length, f, (ulong) flags.Length).Assert();
return new MoveData(ptr); return new MoveData(ptr);
} }
internal MoveData(IntPtr ptr) : base(ptr)
{
}
protected override void DeletePtr() protected override void DeletePtr()
{ {
AttackData.Destruct(Ptr); AttackData.Destruct(Ptr);

View File

@ -7,7 +7,13 @@ namespace PkmnLibSharp.Library.Moves
{ {
public class MoveLibrary : PointerWrapper public class MoveLibrary : PointerWrapper
{ {
private readonly Dictionary<string, MoveData> _cache = new Dictionary<string, MoveData>(StringComparer.InvariantCultureIgnoreCase); private readonly Dictionary<string, MoveData> _cache =
new Dictionary<string, MoveData>(StringComparer.InvariantCultureIgnoreCase);
internal MoveLibrary(IntPtr ptr) : base(ptr)
{
}
public ulong Count => AttackLibrary.GetCount(Ptr); public ulong Count => AttackLibrary.GetCount(Ptr);
public void Insert(string key, MoveData move) public void Insert(string key, MoveData move)
@ -34,6 +40,7 @@ namespace PkmnLibSharp.Library.Moves
_cache.Add(key, move); _cache.Add(key, move);
return true; return true;
} }
move = new MoveData(ptr); move = new MoveData(ptr);
_cache.Add(key, move); _cache.Add(key, move);
return true; return true;
@ -50,6 +57,7 @@ namespace PkmnLibSharp.Library.Moves
_cache.Add(key, move); _cache.Add(key, move);
return move; return move;
} }
move = new MoveData(ptr); move = new MoveData(ptr);
_cache.Add(key, move); _cache.Add(key, move);
return move; return move;
@ -62,17 +70,10 @@ namespace PkmnLibSharp.Library.Moves
return new MoveLibrary(ptr); return new MoveLibrary(ptr);
} }
internal MoveLibrary(IntPtr ptr) : base(ptr)
{
}
protected internal override void MarkAsDeleted() protected internal override void MarkAsDeleted()
{ {
base.MarkAsDeleted(); base.MarkAsDeleted();
foreach (var moveData in _cache) foreach (var moveData in _cache) moveData.Value.MarkAsDeleted();
{
moveData.Value.MarkAsDeleted();
}
} }
protected override void DeletePtr() protected override void DeletePtr()

View File

@ -13,6 +13,6 @@ namespace PkmnLibSharp.Library.Moves
AllOpponent = 8, AllOpponent = 8,
Any = 9, Any = 9,
RandomOpponent = 10, RandomOpponent = 10,
Self = 11, Self = 11
} }
} }

View File

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using PkmnLibSharp.Utilities; using PkmnLibSharp.Utilities;
using Random = PkmnLibSharp.Utilities.Random;
namespace PkmnLibSharp.Library namespace PkmnLibSharp.Library
{ {
@ -54,6 +55,11 @@ namespace PkmnLibSharp.Library
return ptr.PtrString(); return ptr.PtrString();
} }
public string GetRandomNatureName(Random random)
{
return Pkmnlib.Generated.NatureLibrary.GetRandomNatureName(Ptr, random.Ptr).PtrString();
}
protected override void DeletePtr() protected override void DeletePtr()
{ {
Pkmnlib.Generated.NatureLibrary.Destruct(Ptr); Pkmnlib.Generated.NatureLibrary.Destruct(Ptr);

View File

@ -115,7 +115,7 @@ namespace PkmnLibSharp.Library
} }
private PokemonLibrary(IntPtr ptr) : base(ptr) internal PokemonLibrary(IntPtr ptr) : base(ptr)
{ {
} }

View File

@ -1,8 +1,11 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Creatureliblibrary.Generated; using Creatureliblibrary.Generated;
using Pkmnlib;
using Pkmnlib.Generated; using Pkmnlib.Generated;
using PkmnLibSharp.Utilities; using PkmnLibSharp.Utilities;
using Gender = PkmnLibSharp.Battling.Gender;
using Random = PkmnLibSharp.Utilities.Random;
namespace PkmnLibSharp.Library namespace PkmnLibSharp.Library
{ {
@ -68,6 +71,11 @@ namespace PkmnLibSharp.Library
CreatureSpecies.SetVariant(Ptr, s.ToPtr(), forme.Ptr).Assert(); CreatureSpecies.SetVariant(Ptr, s.ToPtr(), forme.Ptr).Assert();
} }
public Gender GetRandomGender(Random random)
{
return (Gender) CreatureSpecies.GetRandomGender(Ptr, random.Ptr);
}
internal Species(IntPtr ptr) : base(ptr) internal Species(IntPtr ptr) : base(ptr)
{ {

View File

@ -0,0 +1,24 @@
using System;
namespace PkmnLibSharp.Library
{
public class StatisticSet<T> where T : IComparable<T>
{
public T HP { get; set; }
public T Attack { get; set; }
public T Defense { get; set; }
public T SpecialAttack { get; set; }
public T SpecialDefense { get; set; }
public T Speed { get; set; }
public StatisticSet(T hp, T attack, T defense, T specialAttack, T specialDefense, T speed)
{
HP = hp;
Attack = attack;
Defense = defense;
SpecialAttack = specialAttack;
SpecialDefense = specialDefense;
Speed = speed;
}
}
}

BIN
PkmnLibSharp/Native/libArubtils.so (Stored with Git LFS) Executable file

Binary file not shown.

Binary file not shown.

Binary file not shown.

BIN
PkmnLibSharp/Native/libpkmnLib.so (Stored with Git LFS)

Binary file not shown.

View File

@ -0,0 +1,59 @@
namespace PkmnLibSharp.Utilities
{
public class Random : PointerWrapper
{
public Random() : base(Arbutils.Generated.Random.Construct())
{
}
public Random(ulong seed) : base(Arbutils.Generated.Random.ConstructWithSeed(seed))
{
}
public float GetFloat()
{
return Arbutils.Generated.Random.GetFloat(Ptr);
}
public double GetDouble()
{
return Arbutils.Generated.Random.GetDouble(Ptr);
}
public int Get()
{
return Arbutils.Generated.Random.Get(Ptr);
}
public int Get(int max)
{
return Arbutils.Generated.Random.GetWithMax(Ptr, max);
}
public int Get(int min, int max)
{
return Arbutils.Generated.Random.GetInLimits(Ptr, min, max);
}
public uint GetUnsigned()
{
return Arbutils.Generated.Random.GetUnsigned(Ptr);
}
public uint GetUnsigned(uint max)
{
return Arbutils.Generated.Random.GetUnsignedWithMax(Ptr, max);
}
public uint GetUnsigned(uint min, uint max)
{
return Arbutils.Generated.Random.GetUnsignedInLimits(Ptr, min, max);
}
protected override void DeletePtr()
{
Arbutils.Generated.Random.Destruct(Ptr);
}
}
}

View File

@ -0,0 +1 @@
{"enums":[],"functions":[{"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"}],"returns":"int"},{"filename":"Arbutils","name":"Arbutils_Random_GetInLimits","parameters":[{"name":"p","type":"Random *"},{"name":"min","type":"int"},{"name":"max","type":"int"}],"returns":"int"},{"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"}],"returns":"unsigned int"},{"filename":"Arbutils","name":"Arbutils_Random_GetUnsignedInLimits","parameters":[{"name":"p","type":"Random *"},{"name":"min","type":"unsigned int"},{"name":"max","type":"unsigned int"}],"returns":"unsigned int"},{"filename":"Arbutils","name":"Arbutils_Random_GetSeed","parameters":[{"name":"p","type":"Random *"}],"returns":"long unsigned int"}]}

File diff suppressed because one or more lines are too long

View File

@ -62,6 +62,8 @@ def parse_type(type, enumSet):
return "byte" return "byte"
if (type == "float"): if (type == "float"):
return "float" return "float"
if (type == "double"):
return "double"
if (type == "long unsigned int"): if (type == "long unsigned int"):
return "ulong" return "ulong"
if (type == "long int"): if (type == "long int"):
@ -112,23 +114,24 @@ def write_class(c, enumSet):
f.write("}\n") f.write("}\n")
def parse_create(data): def parse_create(data, filepath):
enumSet = set() enumSet = set()
for enum in data["enums"]: for enum in data["enums"]:
write_enum(enum, enumSet) write_enum(enum, enumSet)
classDict = dict() classDict = dict()
for function in data["functions"]: for function in data["functions"]:
parse_function(function, classDict) parse_function(function, classDict)
print("Registered {} classes.".format(len(classDict))) print("Registered {} classes from file {}.".format(len(classDict), filepath))
for _, v in classDict.items(): for _, v in classDict.items():
write_class(v, enumSet) write_class(v, enumSet)
def handle_file(filepath): def handle_file(filepath):
with open(filepath) as json_file: with open(filepath) as json_file:
data = json.load(json_file) data = json.load(json_file)
parse_create(data) parse_create(data, filepath)
def main(): def main():
handle_file("arbutils.json")
handle_file("creaturelib.json") handle_file("creaturelib.json")
handle_file("pkmnlib.json") handle_file("pkmnlib.json")

View File

@ -16,4 +16,8 @@
<ProjectReference Include="..\PkmnLibSharp\PkmnLibSharp.csproj" /> <ProjectReference Include="..\PkmnLibSharp\PkmnLibSharp.csproj" />
</ItemGroup> </ItemGroup>
<ItemGroup>
<Folder Include="Battling" />
</ItemGroup>
</Project> </Project>