Initial commit, implements Forme

master
Deukhoofd 3 years ago
commit 35388de524
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
  1. 2
      .gitattributes
  2. 334
      .gitignore
  3. 22
      PkmnLibSharp.sln
  4. 12
      PkmnLibSharp/Generated/Creaturelibbattling/AttackCategory.cs
  5. 11
      PkmnLibSharp/Generated/Creaturelibbattling/AttackLearnMethod.cs
  6. 21
      PkmnLibSharp/Generated/Creaturelibbattling/AttackTarget.cs
  7. 32
      PkmnLibSharp/Generated/Creaturelibbattling/AttackTurnChoice.cs
  8. 40
      PkmnLibSharp/Generated/Creaturelibbattling/BaseTurnChoice.cs
  9. 180
      PkmnLibSharp/Generated/Creaturelibbattling/Battle.cs
  10. 14
      PkmnLibSharp/Generated/Creaturelibbattling/BattleItemCategory.cs
  11. 50
      PkmnLibSharp/Generated/Creaturelibbattling/BattleLibrary.cs
  12. 35
      PkmnLibSharp/Generated/Creaturelibbattling/BattleParty.cs
  13. 55
      PkmnLibSharp/Generated/Creaturelibbattling/BattleRandom.cs
  14. 95
      PkmnLibSharp/Generated/Creaturelibbattling/BattleSide.cs
  15. 34
      PkmnLibSharp/Generated/Creaturelibbattling/BattleStatCalculator.cs
  16. 13
      PkmnLibSharp/Generated/Creaturelibbattling/C.cs
  17. 274
      PkmnLibSharp/Generated/Creaturelibbattling/Creature.cs
  18. 54
      PkmnLibSharp/Generated/Creaturelibbattling/CreatureParty.cs
  19. 29
      PkmnLibSharp/Generated/Creaturelibbattling/DamageEvent.cs
  20. 58
      PkmnLibSharp/Generated/Creaturelibbattling/DamageLibrary.cs
  21. 10
      PkmnLibSharp/Generated/Creaturelibbattling/DamageSource.cs
  22. 14
      PkmnLibSharp/Generated/Creaturelibbattling/DisplayTextEvent.cs
  23. 14
      PkmnLibSharp/Generated/Creaturelibbattling/EffectParameterType.cs
  24. 19
      PkmnLibSharp/Generated/Creaturelibbattling/EventData.cs
  25. 13
      PkmnLibSharp/Generated/Creaturelibbattling/EventDataKind.cs
  26. 49
      PkmnLibSharp/Generated/Creaturelibbattling/ExecutingAttack.cs
  27. 26
      PkmnLibSharp/Generated/Creaturelibbattling/ExperienceLibrary.cs
  28. 14
      PkmnLibSharp/Generated/Creaturelibbattling/FaintEvent.cs
  29. 14
      PkmnLibSharp/Generated/Creaturelibbattling/FleeTurnChoice.cs
  30. 12
      PkmnLibSharp/Generated/Creaturelibbattling/Gender.cs
  31. 24
      PkmnLibSharp/Generated/Creaturelibbattling/HealEvent.cs
  32. 64
      PkmnLibSharp/Generated/Creaturelibbattling/HitData.cs
  33. 17
      PkmnLibSharp/Generated/Creaturelibbattling/ItemCategory.cs
  34. 65
      PkmnLibSharp/Generated/Creaturelibbattling/LearnedAttack.cs
  35. 43
      PkmnLibSharp/Generated/Creaturelibbattling/MiscLibrary.cs
  36. 14
      PkmnLibSharp/Generated/Creaturelibbattling/PassTurnChoice.cs
  37. 211
      PkmnLibSharp/Generated/Creaturelibbattling/Script.cs
  38. 15
      PkmnLibSharp/Generated/Creaturelibbattling/ScriptCategory.cs
  39. 32
      PkmnLibSharp/Generated/Creaturelibbattling/ScriptResolver.cs
  40. 15
      PkmnLibSharp/Generated/Creaturelibbattling/Statistic.cs
  41. 20
      PkmnLibSharp/Generated/Creaturelibbattling/SwitchTurnChoice.cs
  42. 14
      PkmnLibSharp/Generated/Creaturelibbattling/TurnChoiceKind.cs
  43. 15
      PkmnLibSharp/Generated/Creaturelibbattling/memory_order.cs
  44. 12
      PkmnLibSharp/Generated/Creatureliblibrary/AttackCategory.cs
  45. 94
      PkmnLibSharp/Generated/Creatureliblibrary/AttackData.cs
  46. 79
      PkmnLibSharp/Generated/Creatureliblibrary/AttackLibrary.cs
  47. 21
      PkmnLibSharp/Generated/Creatureliblibrary/AttackTarget.cs
  48. 14
      PkmnLibSharp/Generated/Creatureliblibrary/BattleItemCategory.cs
  49. 13
      PkmnLibSharp/Generated/Creatureliblibrary/C.cs
  50. 90
      PkmnLibSharp/Generated/Creatureliblibrary/CreatureSpecies.cs
  51. 55
      PkmnLibSharp/Generated/Creatureliblibrary/DataLibrary.cs
  52. 14
      PkmnLibSharp/Generated/Creatureliblibrary/EffectParameterType.cs
  53. 16
      PkmnLibSharp/Generated/Creatureliblibrary/ExternGrowthRate.cs
  54. 12
      PkmnLibSharp/Generated/Creatureliblibrary/Gender.cs
  55. 28
      PkmnLibSharp/Generated/Creatureliblibrary/GrowthRate.cs
  56. 65
      PkmnLibSharp/Generated/Creatureliblibrary/GrowthRateLibrary.cs
  57. 50
      PkmnLibSharp/Generated/Creatureliblibrary/Item.cs
  58. 17
      PkmnLibSharp/Generated/Creatureliblibrary/ItemCategory.cs
  59. 78
      PkmnLibSharp/Generated/Creatureliblibrary/ItemLibrary.cs
  60. 39
      PkmnLibSharp/Generated/Creatureliblibrary/LearnableAttacks.cs
  61. 30
      PkmnLibSharp/Generated/Creatureliblibrary/LibrarySettings.cs
  62. 15
      PkmnLibSharp/Generated/Creatureliblibrary/LookupGrowthRate.cs
  63. 78
      PkmnLibSharp/Generated/Creatureliblibrary/SpeciesLibrary.cs
  64. 94
      PkmnLibSharp/Generated/Creatureliblibrary/SpeciesVariant.cs
  65. 15
      PkmnLibSharp/Generated/Creatureliblibrary/Statistic.cs
  66. 72
      PkmnLibSharp/Generated/Creatureliblibrary/TypeLibrary.cs
  67. 15
      PkmnLibSharp/Generated/Creatureliblibrary/memory_order.cs
  68. 93
      PkmnLibSharp/Generated/Pkmnlib/AngelScriptResolver.cs
  69. 12
      PkmnLibSharp/Generated/Pkmnlib/AttackCategory.cs
  70. 11
      PkmnLibSharp/Generated/Pkmnlib/AttackLearnMethod.cs
  71. 21
      PkmnLibSharp/Generated/Pkmnlib/AttackTarget.cs
  72. 41
      PkmnLibSharp/Generated/Pkmnlib/Battle.cs
  73. 14
      PkmnLibSharp/Generated/Pkmnlib/BattleItemCategory.cs
  74. 25
      PkmnLibSharp/Generated/Pkmnlib/BattleLibrary.cs
  75. 13
      PkmnLibSharp/Generated/Pkmnlib/C.cs
  76. 18
      PkmnLibSharp/Generated/Pkmnlib/DamageLibrary.cs
  77. 10
      PkmnLibSharp/Generated/Pkmnlib/DamageSource.cs
  78. 14
      PkmnLibSharp/Generated/Pkmnlib/EffectParameterType.cs
  79. 13
      PkmnLibSharp/Generated/Pkmnlib/EventDataKind.cs
  80. 87
      PkmnLibSharp/Generated/Pkmnlib/Evolution.cs
  81. 33
      PkmnLibSharp/Generated/Pkmnlib/EvolutionData.cs
  82. 22
      PkmnLibSharp/Generated/Pkmnlib/EvolutionMethod.cs
  83. 12
      PkmnLibSharp/Generated/Pkmnlib/Gender.cs
  84. 15
      PkmnLibSharp/Generated/Pkmnlib/GetLastException.cs
  85. 30
      PkmnLibSharp/Generated/Pkmnlib/Item.cs
  86. 17
      PkmnLibSharp/Generated/Pkmnlib/ItemCategory.cs
  87. 26
      PkmnLibSharp/Generated/Pkmnlib/LibrarySettings.cs
  88. 14
      PkmnLibSharp/Generated/Pkmnlib/METADATATYPE.cs
  89. 18
      PkmnLibSharp/Generated/Pkmnlib/MiscLibrary.cs
  90. 12
      PkmnLibSharp/Generated/Pkmnlib/MoveCategory.cs
  91. 48
      PkmnLibSharp/Generated/Pkmnlib/Nature.cs
  92. 46
      PkmnLibSharp/Generated/Pkmnlib/NatureLibrary.cs
  93. 10
      PkmnLibSharp/Generated/Pkmnlib/PkmnDamageSource.cs
  94. 10
      PkmnLibSharp/Generated/Pkmnlib/PkmnEventDataKind.cs
  95. 18
      PkmnLibSharp/Generated/Pkmnlib/PkmnScript.cs
  96. 10
      PkmnLibSharp/Generated/Pkmnlib/PkmnScriptCategory.cs
  97. 67
      PkmnLibSharp/Generated/Pkmnlib/Pokemon.cs
  98. 48
      PkmnLibSharp/Generated/Pkmnlib/PokemonSpecies.cs
  99. 15
      PkmnLibSharp/Generated/Pkmnlib/ScriptCategory.cs
  100. 18
      PkmnLibSharp/Generated/Pkmnlib/StatCalculator.cs
  101. Some files were not shown because too many files have changed in this diff Show More

2
.gitattributes vendored

@ -0,0 +1,2 @@
*.dll filter=lfs diff=lfs merge=lfs -text
*.so filter=lfs diff=lfs merge=lfs -text

334
.gitignore vendored

@ -0,0 +1,334 @@
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
##
## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
# User-specific files
*.rsuser
*.suo
*.user
*.userosscache
*.sln.docstates
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
# Visual Studio 2015/2017 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# Visual Studio 2017 auto generated files
Generated\ Files/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# Benchmark Results
BenchmarkDotNet.Artifacts/
# .NET Core
project.lock.json
project.fragment.lock.json
artifacts/
# StyleCop
StyleCopReport.xml
# Files built by Visual Studio
*_i.c
*_p.c
*_h.h
*.ilk
*.meta
*.obj
*.iobj
*.pch
*.pdb
*.ipdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*_wpftmp.csproj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# Visual Studio Trace Files
*.e2e
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding add-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# AxoCover is a Code Coverage Tool
.axoCover/*
!.axoCover/settings.json
# Visual Studio code coverage results
*.coverage
*.coveragexml
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# Note: Comment the next line if you want to checkin your web deploy settings,
# but database connection strings (with potential passwords) will be unencrypted
*.pubxml
*.publishproj
# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/
# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/[Pp]ackages/*
# except build/, which is used as an MSBuild target.
!**/[Pp]ackages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/[Pp]ackages/repositories.config
# NuGet v3's project.json files produces more ignorable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
*.appx
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!*.[Cc]ache/
# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
orleans.codegen.cs
# Including strong name files can present a security risk
# (https://github.com/github/gitignore/pull/2483#issue-259490424)
#*.snk
# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
ServiceFabricBackup/
*.rptproj.bak
# SQL Server files
*.mdf
*.ldf
*.ndf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
*.rptproj.rsuser
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
node_modules/
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
*.vbw
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# Paket dependency manager
.paket/paket.exe
paket-files/
# FAKE - F# Make
.fake/
# JetBrains Rider
.idea/
*.sln.iml
# CodeRush personal settings
.cr/personal
# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
# Cake - Uncomment if you are using it
# tools/**
# !tools/packages.config
# Tabs Studio
*.tss
# Telerik's JustMock configuration file
*.jmconfig
# BizTalk build output
*.btp.cs
*.btm.cs
*.odx.cs
*.xsd.cs
# OpenCover UI analysis results
OpenCover/
# Azure Stream Analytics local run output
ASALocalRun/
# MSBuild Binary and Structured Log
*.binlog
# NVidia Nsight GPU debugger configuration file
*.nvuser
# MFractors (Xamarin productivity tool) working folder
.mfractor/
# Local History for Visual Studio
.localhistory/

@ -0,0 +1,22 @@

Microsoft Visual Studio Solution File, Format Version 12.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PkmnLibSharp", "PkmnLibSharp\PkmnLibSharp.csproj", "{4CB6DA3C-017B-4AE0-B889-3DFE6B969CD0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PkmnLibSharpTests", "PkmnLibSharpTests\PkmnLibSharpTests.csproj", "{0D15FD33-1AEA-44F4-8211-AA8AF97EA534}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{4CB6DA3C-017B-4AE0-B889-3DFE6B969CD0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{4CB6DA3C-017B-4AE0-B889-3DFE6B969CD0}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4CB6DA3C-017B-4AE0-B889-3DFE6B969CD0}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4CB6DA3C-017B-4AE0-B889-3DFE6B969CD0}.Release|Any CPU.Build.0 = Release|Any CPU
{0D15FD33-1AEA-44F4-8211-AA8AF97EA534}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0D15FD33-1AEA-44F4-8211-AA8AF97EA534}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0D15FD33-1AEA-44F4-8211-AA8AF97EA534}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0D15FD33-1AEA-44F4-8211-AA8AF97EA534}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
EndGlobal

@ -0,0 +1,12 @@
using System.Diagnostics.CodeAnalysis;
namespace Creaturelibbattling
{
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum AttackCategory : byte
{
Physical = 0,
Magical = 1,
Status = 2,
}
}

@ -0,0 +1,11 @@
using System.Diagnostics.CodeAnalysis;
namespace Creaturelibbattling
{
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum AttackLearnMethod : int
{
Unknown = 0,
Level = 1,
}
}

@ -0,0 +1,21 @@
using System.Diagnostics.CodeAnalysis;
namespace Creaturelibbattling
{
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum AttackTarget : byte
{
Adjacent = 0,
AdjacentAlly = 1,
RandomOpponent = 10,
Self = 11,
AdjacentAllySelf = 2,
AdjacentOpponent = 3,
All = 4,
AllAdjacent = 5,
AllAdjacentOpponent = 6,
AllAlly = 7,
AllOpponent = 8,
Any = 9,
}
}

@ -0,0 +1,32 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class AttackTurnChoice
{
/// <param name="user">Creature *</param>
/// <param name="attack">LearnedAttack *</param>
/// <param name="sideIndex">unsigned char</param>
/// <param name="targetIndex">unsigned char</param>
/// <returns>AttackTurnChoice *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_Construct")]
internal static extern IntPtr Construct(IntPtr user, IntPtr attack, byte sideIndex, byte targetIndex);
/// <param name="p">const AttackTurnChoice *</param>
/// <returns>LearnedAttack *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetAttack")]
internal static extern IntPtr GetAttack(IntPtr p);
/// <param name="p">const AttackTurnChoice *</param>
/// <returns>TurnChoiceKind</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetKind")]
internal static extern TurnChoiceKind GetKind(IntPtr p);
/// <param name="p">const AttackTurnChoice *</param>
/// <returns>Script *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_AttackTurnChoice_GetAttackScript")]
internal static extern IntPtr GetAttackScript(IntPtr p);
}
}

@ -0,0 +1,40 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class BaseTurnChoice
{
/// <param name="p">const BaseTurnChoice *</param>
/// <returns>void</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_Destruct")]
internal static extern void Destruct(IntPtr p);
/// <param name="p">const BaseTurnChoice *</param>
/// <returns>TurnChoiceKind</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetKind")]
internal static extern TurnChoiceKind GetKind(IntPtr p);
/// <param name="p">const BaseTurnChoice *</param>
/// <returns>Creature *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetUser")]
internal static extern IntPtr GetUser(IntPtr p);
/// <param name="out">signed char&</param>
/// <param name="p">AttackTurnChoice *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetPriority")]
internal static extern byte GetPriority(ref sbyte @out, IntPtr p);
/// <param name="p">const AttackTurnChoice *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetTargetSideIndex")]
internal static extern byte GetTargetSideIndex(IntPtr p);
/// <param name="p">const AttackTurnChoice *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BaseTurnChoice_GetTargetCreatureIndex")]
internal static extern byte GetTargetCreatureIndex(IntPtr p);
}
}

@ -0,0 +1,180 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class Battle
{
/// <param name="out">Battle *&</param>
/// <param name="library">const BattleLibrary *</param>
/// <param name="partyArr">BattleParty * *</param>
/// <param name="numberOfParties">long unsigned int</param>
/// <param name="canFlee">bool</param>
/// <param name="numberOfSides">unsigned char</param>
/// <param name="creaturesPerSide">unsigned char</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_Construct")]
internal static extern byte Construct(ref IntPtr @out, IntPtr library, IntPtr partyArr, ulong numberOfParties, bool canFlee, byte numberOfSides, byte creaturesPerSide);
/// <param name="p">const Battle *</param>
/// <returns>void</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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">const BaseTurnChoice *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanUse")]
internal static extern byte CanUse(ref bool @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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_TrySetChoice")]
internal static extern byte TrySetChoice(ref bool @out, IntPtr p, IntPtr turnChoice);
/// <param name="p">const Battle *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanFlee")]
internal static extern bool CanFlee(IntPtr p);
/// <param name="p">Battle *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CheckChoicesSetAndRun")]
internal static extern byte CheckChoicesSetAndRun(IntPtr p);
/// <param name="p">const Battle *</param>
/// <returns>ChoiceQueue *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetCurrentTurnQueue")]
internal static extern IntPtr GetCurrentTurnQueue(IntPtr p);
/// <param name="p">Battle *</param>
/// <returns>BattleRandom *</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CreatureInField")]
internal static extern byte CreatureInField(ref bool @out, IntPtr p, IntPtr c);
/// <param name="out">Creature *&</param>
/// <param name="p">const Battle *</param>
/// <param name="side">unsigned char</param>
/// <param name="target">unsigned char</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_ForceRecall")]
internal static extern byte ForceRecall(IntPtr p, byte side, byte target);
/// <param name="p">Battle *</param>
/// <param name="side">unsigned char</param>
/// <param name="target">unsigned char</param>
/// <param name="c">Creature *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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>
/// <param name="p">const Battle *</param>
/// <param name="side">unsigned char</param>
/// <param name="target">unsigned char</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_CanSlotBeFilled")]
internal static extern byte CanSlotBeFilled(ref bool @out, IntPtr p, byte side, byte target);
/// <param name="p">Battle *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_ValidateBattleState")]
internal static extern byte ValidateBattleState(IntPtr p);
/// <param name="p">const Battle *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasEnded")]
internal static extern bool HasEnded(IntPtr p);
/// <param name="p">const Battle *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasConclusiveResult")]
internal static extern bool HasConclusiveResult(IntPtr p);
/// <param name="p">const Battle *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetWinningSide")]
internal static extern bool GetWinningSide(IntPtr p);
/// <param name="p">const Battle *</param>
/// <returns>long unsigned int</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetSides")]
internal static extern IntPtr GetSides(IntPtr p);
/// <param name="p">Battle *</param>
/// <param name="key">const char *</param>
/// <returns>Script *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_GetVolatileScript")]
internal static extern IntPtr GetVolatileScript(IntPtr p, string key);
/// <param name="p">Battle *</param>
/// <param name="key">const char *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_AddVolatileScriptByName")]
internal static extern byte AddVolatileScriptByName(IntPtr p, string key);
/// <param name="p">Battle *</param>
/// <param name="script">Script *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RemoveVolatileScript")]
internal static extern byte RemoveVolatileScript(IntPtr p, string key);
/// <param name="p">Battle *</param>
/// <param name="script">Script *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_HasVolatileScript")]
internal static extern bool HasVolatileScript(IntPtr p, string key);
/// <param name="p">Battle *</param>
/// <param name="func">Function *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_RegisterEventListener")]
internal static extern byte RegisterEventListener(IntPtr p, IntPtr func);
/// <param name="p">Battle *</param>
/// <param name="data">EventData *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Battle_TriggerEventListener")]
internal static extern byte TriggerEventListener(IntPtr p, IntPtr data);
}
}

@ -0,0 +1,14 @@
using System.Diagnostics.CodeAnalysis;
namespace Creaturelibbattling
{
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum BattleItemCategory : byte
{
None = 0,
Healing = 1,
StatusHealing = 2,
CaptureDevice = 3,
MiscBattleItem = 4,
}
}

@ -0,0 +1,50 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class BattleLibrary
{
/// <param name="out">const BattleLibrary *&</param>
/// <param name="staticLib">const DataLibrary *</param>
/// <param name="statCalculator">BattleStatCalculator *</param>
/// <param name="damageLibrary">DamageLibrary *</param>
/// <param name="experienceLibrary">ExperienceLibrary *</param>
/// <param name="scriptResolver">ScriptResolver *</param>
/// <param name="miscLibrary">MiscLibrary *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleLibrary_GetExperienceLibrary")]
internal static extern IntPtr GetExperienceLibrary(IntPtr p);
}
}

@ -0,0 +1,35 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class BattleParty
{
/// <param name="out">BattleParty *&</param>
/// <param name="p">CreatureParty *</param>
/// <param name="creatureIndices">unsigned char *</param>
/// <param name="numberOfIndices">long unsigned int</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_Destruct")]
internal static extern void Destruct(IntPtr p);
/// <param name="out">bool&</param>
/// <param name="p">const BattleParty *</param>
/// <param name="side">unsigned char</param>
/// <param name="creature">unsigned char</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_IsResponsibleForIndex")]
internal static extern byte IsResponsibleForIndex(ref bool @out, IntPtr p, byte side, byte creature);
/// <param name="p">const BattleParty *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleParty_HasCreaturesNotInField")]
internal static extern bool HasCreaturesNotInField(IntPtr p);
}
}

@ -0,0 +1,55 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class BattleRandom
{
/// <returns>BattleRandom *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Construct")]
internal static extern IntPtr Construct();
/// <param name="seed">long unsigned int</param>
/// <returns>BattleRandom *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_ConstructWithSeed")]
internal static extern IntPtr ConstructWithSeed(ulong seed);
/// <param name="p">BattleRandom *</param>
/// <returns>void</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_Destruct")]
internal static extern void Destruct(IntPtr p);
/// <param name="out">bool&</param>
/// <param name="p">BattleRandom *</param>
/// <param name="chance">float</param>
/// <param name="attack">ExecutingAttack *</param>
/// <param name="target">Creature *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_EffectChance")]
internal static extern byte EffectChance(ref bool @out, IntPtr p, float chance, IntPtr attack, IntPtr target);
/// <param name="p">BattleRandom *</param>
/// <returns>int</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleRandom_GetSeed")]
internal static extern ulong GetSeed(IntPtr p);
}
}

@ -0,0 +1,95 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class BattleSide
{
/// <param name="index">unsigned char</param>
/// <param name="battle">Battle *</param>
/// <param name="creaturesPerSide">unsigned char</param>
/// <returns>BattleSide *</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_Destruct")]
internal static extern void Destruct(IntPtr p);
/// <param name="p">BattleSide *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_AllChoicesSet")]
internal static extern bool AllChoicesSet(IntPtr p);
/// <param name="p">BattleSide *</param>
/// <returns>const BaseTurnChoice * *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_GetChoices")]
internal static extern IntPtr GetChoices(IntPtr p);
/// <param name="out">bool&</param>
/// <param name="p">BattleSide *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_AllPossibleSlotsFilled")]
internal static extern byte AllPossibleSlotsFilled(ref bool @out, IntPtr p);
/// <param name="p">BattleSide *</param>
/// <param name="choice">BaseTurnChoice *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_IsDefeated")]
internal static extern bool IsDefeated(IntPtr p);
/// <param name="p">BattleSide *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_HasFled")]
internal static extern bool HasFled(IntPtr p);
/// <param name="p">BattleSide *</param>
/// <returns>void</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleSide_MarkAsFled")]
internal static extern void MarkAsFled(IntPtr p);
}
}

@ -0,0 +1,34 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class BattleStatCalculator
{
/// <returns>const BattleStatCalculator *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_Construct")]
internal static extern IntPtr Construct();
/// <param name="p">const BattleStatCalculator *</param>
/// <returns>void</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_Destruct")]
internal static extern void Destruct(IntPtr p);
/// <param name="out">unsigned int&</param>
/// <param name="p">const BattleStatCalculator *</param>
/// <param name="creature">Creature *</param>
/// <param name="stat">Statistic</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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>
/// <param name="p">const BattleStatCalculator *</param>
/// <param name="creature">Creature *</param>
/// <param name="stat">Statistic</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_BattleStatCalculator_CalculateBoostedStat")]
internal static extern byte CalculateBoostedStat(ref uint @out, IntPtr p, IntPtr creature, Statistic stat);
}
}

@ -0,0 +1,13 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class C
{
/// <returns>const char *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_C_GetLastException")]
internal static extern string GetLastException();
}
}

@ -0,0 +1,274 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class Creature
{
/// <param name="out">Creature *&</param>
/// <param name="library">const BattleLibrary *</param>
/// <param name="species">const CreatureSpecies *</param>
/// <param name="variant">const SpeciesVariant *</param>
/// <param name="level">unsigned char</param>
/// <param name="experience">unsigned int</param>
/// <param name="uid">unsigned int</param>
/// <param name="gender">Gender</param>
/// <param name="coloring">unsigned char</param>
/// <param name="heldItem">const Item *</param>
/// <param name="nickname">const char *</param>
/// <param name="secretTalent">bool</param>
/// <param name="talent">unsigned char</param>
/// <param name="attacks">LearnedAttack * *</param>
/// <param name="attacksNum">long unsigned int</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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, string nickname, bool secretTalent, byte talent, IntPtr attacks, ulong attacksNum);
/// <param name="p">const Creature *</param>
/// <returns>void</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Destruct")]
internal static extern void Destruct(IntPtr p);
/// <param name="p">const Creature *</param>
/// <returns>const CreatureSpecies *</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetVariant")]
internal static extern IntPtr GetVariant(IntPtr p);
/// <param name="p">const Creature *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetExperience")]
internal static extern uint GetExperience(IntPtr p);
/// <param name="p">const Creature *</param>
/// <returns>Gender</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasHeldItem")]
internal static extern bool HasHeldItem(IntPtr p, string name);
/// <param name="p">const Creature *</param>
/// <param name="hash">unsigned int</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasHeldItemWithHash")]
internal static extern bool HasHeldItemWithHash(IntPtr p, uint hash);
/// <param name="p">const Creature *</param>
/// <returns>const Item *</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_SetHeldItem")]
internal static extern byte SetHeldItem(IntPtr p, string name);
/// <param name="p">Creature *</param>
/// <param name="hash">unsigned int</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetCurrentHealth")]
internal static extern uint GetCurrentHealth(IntPtr p);
/// <param name="p">const Creature *</param>
/// <returns>Battle *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBattle")]
internal static extern IntPtr GetBattle(IntPtr p);
/// <param name="p">const Creature *</param>
/// <returns>BattleSide *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetBattleSide")]
internal static extern IntPtr GetBattleSide(IntPtr p);
/// <param name="p">const Creature *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_IsOnBattleField")]
internal static extern bool IsOnBattleField(IntPtr p);
/// <param name="p">Creature *</param>
/// <returns>const char *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetNickname")]
internal static extern string GetNickname(IntPtr p);
/// <param name="p">Creature *</param>
/// <returns>long unsigned int</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetTypesCount")]
internal static extern ulong GetTypesCount(IntPtr p);
/// <param name="p">Creature *</param>
/// <returns>const unsigned char *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetTypes")]
internal static extern IntPtr GetTypes(IntPtr p);
/// <param name="p">Creature *</param>
/// <param name="type">unsigned char</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasType")]
internal static extern bool HasType(IntPtr p, byte type);
/// <param name="p">const Creature *</param>
/// <returns>unsigned int</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_Heal")]
internal static extern byte Heal(IntPtr p, uint health, bool canRevive);
/// <param name="p">Creature *</param>
/// <param name="talent">const char *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_OverrideActiveTalent")]
internal static extern byte OverrideActiveTalent(IntPtr p, string talent);
/// <param name="p">Creature *</param>
/// <param name="experience">unsigned int</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_AddVolatileScriptByName")]
internal static extern byte AddVolatileScriptByName(IntPtr p, string scriptName);
/// <param name="p">Creature *</param>
/// <param name="script">Script *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_RemoveVolatileScriptByName")]
internal static extern byte RemoveVolatileScriptByName(IntPtr p, string scriptName);
/// <param name="p">Creature *</param>
/// <param name="script">Script *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_HasVolatileScript")]
internal static extern bool HasVolatileScript(IntPtr p, string scriptName);
/// <param name="p">Creature *</param>
/// <returns>long unsigned int</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttacksCount")]
internal static extern ulong GetAttacksCount(IntPtr p);
/// <param name="p">Creature *</param>
/// <returns>const LearnedAttack * *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetAttacks")]
internal static extern IntPtr GetAttacks(IntPtr p);
/// <param name="p">const Creature *</param>
/// <returns>const CreatureSpecies *</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_Creature_GetStatBoost")]
internal static extern sbyte GetStatBoost(IntPtr p, Statistic stat);
}
}

@ -0,0 +1,54 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class CreatureParty
{
/// <param name="size">long unsigned int</param>
/// <returns>CreatureParty *</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_Switch")]
internal static extern byte Switch(IntPtr p, ulong a, ulong b);
/// <param name="p">const CreatureParty *</param>
/// <returns>bool</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_HasAvailableCreatures")]
internal static extern bool HasAvailableCreatures(IntPtr p);
/// <param name="p">const CreatureParty *</param>
/// <returns>long unsigned int</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetLength")]
internal static extern ulong GetLength(IntPtr p);
/// <param name="p">CreatureParty *</param>
/// <returns>const Creature * *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_CreatureParty_GetParty")]
internal static extern IntPtr GetParty(IntPtr p);
}
}

@ -0,0 +1,29 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class DamageEvent
{
/// <param name="p">const DamageEvent *</param>
/// <returns>Creature *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetCreature")]
internal static extern IntPtr GetCreature(IntPtr p);
/// <param name="p">const DamageEvent *</param>
/// <returns>DamageSource</returns>
[DllImport("CreatureLibBattling", 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("CreatureLibBattling", 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("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageEvent_GetNewHealth")]
internal static extern uint GetNewHealth(IntPtr p);
}
}

@ -0,0 +1,58 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class DamageLibrary
{
/// <returns>const DamageLibrary *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_Construct")]
internal static extern IntPtr Construct();
/// <param name="p">const DamageLibrary *</param>
/// <returns>void</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_Destruct")]
internal static extern void Destruct(IntPtr p);
/// <param name="out">unsigned int&</param>
/// <param name="p">const DamageLibrary *</param>
/// <param name="attack">ExecutingAttack *</param>
/// <param name="target">Creature *</param>
/// <param name="hitIndex">unsigned char</param>
/// <param name="hitData">HitData *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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>
/// <param name="p">const DamageLibrary *</param>
/// <param name="attack">ExecutingAttack *</param>
/// <param name="target">Creature *</param>
/// <param name="hitIndex">unsigned char</param>
/// <param name="hitData">HitData *</param>
/// <returns>unsigned char</returns>
[DllImport("CreatureLibBattling", 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>
/// <param name="p">const DamageLibrary *</param>
/// <param name="attack">ExecutingAttack *</param>
/// <param name="target">Creature *</param>
/// <param name="hitIndex">unsigned char</param>
/// <param name="hitData">HitData *</param>
/// <returns>float</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetStatModifier")]
internal static extern float GetStatModifier(ref float @out, IntPtr p, IntPtr attack, IntPtr target, byte hitIndex, IntPtr hitData);
/// <param name="out">float&</param>
/// <param name="p">const DamageLibrary *</param>
/// <param name="attack">ExecutingAttack *</param>
/// <param name="target">Creature *</param>
/// <param name="hitIndex">unsigned char</param>
/// <param name="hitData">HitData *</param>
/// <returns>float</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DamageLibrary_GetDamageModifier")]
internal static extern float GetDamageModifier(ref float @out, IntPtr p, IntPtr attack, IntPtr target, byte hitIndex, IntPtr hitData);
}
}

@ -0,0 +1,10 @@
using System.Diagnostics.CodeAnalysis;
namespace Creaturelibbattling
{
[SuppressMessage("ReSharper", "InconsistentNaming")]
public enum DamageSource : byte
{
AttackDamage = 0,
}
}

@ -0,0 +1,14 @@
using System;
using System.Runtime.InteropServices;
namespace Creaturelibbattling.Generated
{
internal static class DisplayTextEvent
{
/// <param name="p">const DisplayTextEvent *</param>
/// <returns>const char *</returns>
[DllImport("CreatureLibBattling", CallingConvention = CallingConvention.Cdecl, EntryPoint= "CreatureLib_DisplayTextEvent_GetText")]
internal static extern string GetText(IntPtr p);
}
}

@ -0,0 +1,14 @@
using System.Diagnostics.CodeAnalysis;
namespace Creaturelibbattling
{
[SuppressMessage("ReSharper", "InconsistentNaming")]