Update BuildData

CMakeLists.txt

@@ -21,7 +21,6 @@ endif ()
 
 file(GLOB_RECURSE SRC_FILES src/*.cpp src/*.hpp extern/AngelscriptDebugger/src/*.cpp)
 add_executable(PokemonScriptTester ${SRC_FILES})
-target_precompile_headers(PokemonScriptTester PUBLIC src/Precompiled.hxx)
 add_definitions(-DLEVEL_U8)
 
 SET(_LINKS -static pkmnLib)

CMakeLists.txt.in

@@ -40,6 +40,8 @@ function(include_pkmnlib)
     execute_process(COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/PkmnLib/include)
     execute_process(COMMAND ln -s ${CMAKE_CURRENT_BINARY_DIR}/PkmnLib/src/pkmnlib/src
             ${CMAKE_CURRENT_BINARY_DIR}/PkmnLib/include/PkmnLib)
+    execute_process(COMMAND ln -s ${CMAKE_CURRENT_BINARY_DIR}/PkmnLib/src/pkmnlib/extern
+            ${CMAKE_CURRENT_BINARY_DIR}/PkmnLib/include/extern)
     execute_process(COMMAND cp -r ${CMAKE_CURRENT_BINARY_DIR}/PkmnLib/src/pkmnlib/extern
             ${CMAKE_CURRENT_BINARY_DIR}/PkmnLib/include/PkmnLib/extern)
 

src/Precompiled.hxx

@@ -1,6 +0,0 @@
-#ifndef POKEMONSCRIPTTESTER_PRECOMPILED_HXX
-#define POKEMONSCRIPTTESTER_PRECOMPILED_HXX
-
-#include <PkmnLib/Precompiled.hxx>
-
-#endif // POKEMONSCRIPTTESTER_PRECOMPILED_HXX

src/Tester/AngelScript/BattleFunctions.hpp

@@ -31,6 +31,21 @@ class BattleFunctions {
         return p1;
     }
 
+    static CreatureLib::Battling::CreatureParty* CreateParty(CScriptArray* mons) {
+        auto* ctx = asGetActiveContext();
+        TestEnvironment* env = static_cast<TestEnvironment*>(ctx->GetUserData(684));
+
+        auto p1 = new PkmnLib::Battling::PokemonParty(mons->GetSize());
+        for (u32 i = 0; i < mons->GetSize(); ++i) {
+            auto s = *reinterpret_cast<PkmnLib::Battling::Pokemon**>(mons->At(i));
+            p1->SwapInto(i, s);
+            // Party becomes owner of mon, so take it from GC.
+            env->TakeOwnershipOfGarbage(s);
+        }
+        env->AddGarbage(p1);
+        return p1;
+    }
+
     static PkmnLib::Battling::Battle* CreateSimpleBattle(u32 seed, const ArbUt::StringView& species1,
                                                          const ArbUt::StringView& species2, u8 level) {
         auto* ctx = asGetActiveContext();
@@ -152,6 +167,8 @@ public:
         Ensure(
             engine->RegisterGlobalFunction("Party@ CreateSimpleParty(const array<constString>&in species, uint8 level)",
                                            asFUNCTION(CreateSimpleParty), asCALL_CDECL) >= 0);
+        Ensure(engine->RegisterGlobalFunction("Party@ CreateParty(const array<Pokemon@>&in mons)",
+                                              asFUNCTION(CreateParty), asCALL_CDECL) >= 0);
         Ensure(engine->RegisterGlobalFunction("Battle@ CreateSimpleBattle(uint seed, const constString&in species1, "
                                               "const constString&in species2, uint8 level)",
                                               asFUNCTION(CreateSimpleBattle), asCALL_CDECL) >= 0);

src/Tester/AngelScript/MiscMockFunctions.hpp

@@ -5,7 +5,7 @@
 
 class MiscMockFunctions {
     static CScriptHandle CreateMoveScript(const ArbUt::StringView& name) {
-        auto script = Globals::Library.GetValue()->GetScriptResolver()->LoadScript(ScriptCategory::Attack, name);
+        auto script = Globals::Library.GetValue()->GetScriptResolver()->LoadScript(nullptr, ScriptCategory::Attack, name);
         if (script != nullptr) {
             auto* ctx = asGetActiveContext();
             TestEnvironment* env = static_cast<TestEnvironment*>(ctx->GetUserData(684));
@@ -25,7 +25,7 @@ class MiscMockFunctions {
 
         auto move = Globals::Library.GetValue()->GetMoveLibrary()->TryGet(moveName);
         if (!move.has_value()) {
-            return {};
+            THROW("Unknown move: " << moveName);
         }
         auto learnedMove =
             new PkmnLib::Battling::LearnedMove(move.value(), CreatureLib::Battling::AttackLearnMethod::Unknown);

src/Tester/AngelScript/PokemonBuilder.hpp

@@ -0,0 +1,83 @@
+#ifndef POKEMONSCRIPTTESTER_POKEMONBUILDER_HPP
+#define POKEMONSCRIPTTESTER_POKEMONBUILDER_HPP
+#include <PkmnLib/Battling/Pokemon/CreatePokemon.hpp>
+#include <angelscript.h>
+
+class PokemonBuilderRegistration {
+public:
+    static PkmnLib::Battling::CreatePokemon* CreatePokemonBuilder(const ArbUt::StringView& species, uint8_t level) {
+        auto* ctx = asGetActiveContext();
+        TestEnvironment* env = static_cast<TestEnvironment*>(ctx->GetUserData(684));
+        auto lib = Globals::Library.GetValue();
+
+        auto builder = new PkmnLib::Battling::CreatePokemon(lib, species, level);
+        env->AddGarbage(builder);
+        return builder;
+    }
+
+    static PkmnLib::Battling::CreatePokemon& WithGenderWrapper(PkmnLib::Battling::CreatePokemon* builder, i32 gender) {
+        return builder->WithGender((CreatureLib::Library::Gender)gender);
+    }
+
+    static PkmnLib::Battling::Pokemon* BuildWrapper(PkmnLib::Battling::CreatePokemon* builder, u32 seed) {
+        auto rand = ArbUt::Random(seed);
+        auto p = builder->Build(rand);
+        auto* ctx = asGetActiveContext();
+        TestEnvironment* env = static_cast<TestEnvironment*>(ctx->GetUserData(684));
+        env->AddGarbage(p);
+        return p;
+    }
+
+    static void Register(AngelScriptResolver* resolver) {
+        auto engine = resolver->GetEngine();
+        Ensure(engine->RegisterObjectType("PokemonBuilder", 0, asOBJ_REF | asOBJ_NOCOUNT) >= 0);
+        Ensure(engine->RegisterGlobalFunction(
+                   "PokemonBuilder@ CreatePokemonBuilder(const constString&in species, uint8 level)",
+                   asFUNCTION(CreatePokemonBuilder), asCALL_CDECL) >= 0);
+
+        Ensure(engine->RegisterObjectMethod("PokemonBuilder", "PokemonBuilder@ WithForme(const constString&in forme)",
+                                            asMETHODPR(PkmnLib::Battling::CreatePokemon, WithForme,
+                                                       (const ArbUt::StringView&), PkmnLib::Battling::CreatePokemon&),
+                                            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod("PokemonBuilder", "PokemonBuilder@ WithGender(Gender gender)",
+                                            asFUNCTION(WithGenderWrapper), asCALL_CDECL_OBJFIRST));
+        Ensure(engine->RegisterObjectMethod(
+            "PokemonBuilder", "PokemonBuilder@ IsShiny(bool value)",
+            asMETHODPR(PkmnLib::Battling::CreatePokemon, IsShiny, (bool), PkmnLib::Battling::CreatePokemon&),
+            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod("PokemonBuilder", "PokemonBuilder@ WithHeldItem(const constString&in item)",
+                                            asMETHODPR(PkmnLib::Battling::CreatePokemon, WithHeldItem,
+                                                       (const ArbUt::StringView&), PkmnLib::Battling::CreatePokemon&),
+                                            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod(
+            "PokemonBuilder", "PokemonBuilder@ LearnMove(const constString&in move, MoveLearnMethod method)",
+            asMETHODPR(PkmnLib::Battling::CreatePokemon, LearnMove,
+                       (const ArbUt::StringView&, CreatureLib::Battling::AttackLearnMethod),
+                       PkmnLib::Battling::CreatePokemon&),
+            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod(
+            "PokemonBuilder",
+            "PokemonBuilder@ WithIndividualValues(uint8 hp,uint8 att,uint8 def,uint8 spa,uint8 spd,uint8 speed)",
+            asMETHODPR(PkmnLib::Battling::CreatePokemon, WithIndividualValues, (u8, u8, u8, u8, u8, u8),
+                       PkmnLib::Battling::CreatePokemon&),
+            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod(
+            "PokemonBuilder",
+            "PokemonBuilder@ WithEffortValues(uint8 hp,uint8 att,uint8 def,uint8 spa,uint8 spd,uint8 speed)",
+            asMETHODPR(PkmnLib::Battling::CreatePokemon, WithEffortValues, (u8, u8, u8, u8, u8, u8),
+                       PkmnLib::Battling::CreatePokemon&),
+            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod("PokemonBuilder", "PokemonBuilder@ WithNature(const constString&in nature)",
+                                            asMETHODPR(PkmnLib::Battling::CreatePokemon, WithNature,
+                                                       (const ArbUt::StringView&), PkmnLib::Battling::CreatePokemon&),
+                                            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod("PokemonBuilder", "PokemonBuilder@ WithNickname(const string&in name)",
+                                            asMETHODPR(PkmnLib::Battling::CreatePokemon, WithNickname,
+                                                       (const std::string&), PkmnLib::Battling::CreatePokemon&),
+                                            asCALL_THISCALL));
+        Ensure(engine->RegisterObjectMethod("PokemonBuilder", "Pokemon@ Build(uint seed = 0)", asFUNCTION(BuildWrapper),
+                                            asCALL_CDECL_OBJFIRST));
+    }
+};
+
+#endif // POKEMONSCRIPTTESTER_POKEMONBUILDER_HPP

src/Tester/Test.hpp

@@ -26,7 +26,13 @@ public:
 
         _env->CollectGarbage();
         if (e == asEXECUTION_EXCEPTION) {
-            _errorMessage = ctx->GetExceptionString();
+            std::stringstream error;
+            const char* exceptionSection = "";
+            int exceptionColumn = 0;
+            auto exceptionLine = ctx->GetExceptionLineNumber(&exceptionColumn, &exceptionSection);
+            error << "[" << exceptionSection << ":" << exceptionLine << "," << exceptionColumn << "] "
+                  << ctx->GetExceptionString();
+            _errorMessage = error.str();
             _result = TestResult::Failed;
             ctx->PopState();
             return;

src/Tester/TestEnvironment.hpp

@@ -6,6 +6,13 @@ struct TestEnvironment {
     size_t FailedRequirements = 0;
 
     template <typename T> void AddGarbage(T* data) { _garbage.Append(GarbageObject(data)); }
+    template <typename T> void TakeOwnershipOfGarbage(T* data) {
+        for (auto& g : _garbage) {
+            if (g.Ptr == data) {
+                g.Ptr = nullptr;
+            }
+        }
+    }
 
     void CollectGarbage() {
         for (auto& o : _garbage) {

src/main.cpp

@@ -7,6 +7,7 @@
 #include "Globals.hpp"
 #include "Tester/AngelScript/BattleFunctions.hpp"
 #include "Tester/AngelScript/MiscMockFunctions.hpp"
+#include "Tester/AngelScript/PokemonBuilder.hpp"
 #include "Tester/AngelScript/TestFunctions.hpp"
 #include "Tester/TestRunner.hpp"
 #include "git.h"
@@ -23,7 +24,8 @@ int main(int argc, char** argv) {
                                                 {"workdir"});
     args::Flag logTimeFlag(parser, "time-log", "Whether to show time logging.", {'t', "time-log"});
     args::Flag forceColorFlag(parser, "force-color", "Whether to force color text output.", {'c', "force-color"});
-    args::Flag waitForDebuggerFlag(parser, "wait-for-debugger", "Whether to wait until a debugger is connected or not.", {'w', "wait-for-debugger"});
+    args::Flag waitForDebuggerFlag(parser, "wait-for-debugger", "Whether to wait until a debugger is connected or not.",
+                                   {'w', "wait-for-debugger"});
     try {
         parser.ParseCLI(argc, argv);
     } catch (args::Help&) {
@@ -44,7 +46,7 @@ int main(int argc, char** argv) {
     if (!workingDirectory.empty()) {
         chdir((const char*)std::filesystem::path(workingDirectory).c_str());
     }
-    if (forceColorFlag.Get()){
+    if (forceColorFlag.Get()) {
         termcolor::colorize(std::cout);
     }
 
@@ -56,6 +58,7 @@ int main(int argc, char** argv) {
             TestFunctions::Register(scriptResolver);
             BattleFunctions::Register(scriptResolver);
             MiscMockFunctions::Register(scriptResolver);
+            PokemonBuilderRegistration::Register(scriptResolver);
         };
 
     Globals::Library = BuildLibrary::Build("", initialize);