diff --git a/docs/tutorials/how_to_testing_system.md b/docs/tutorials/how_to_testing_system.md index b663ad54b4..53b56bd26b 100644 --- a/docs/tutorials/how_to_testing_system.md +++ b/docs/tutorials/how_to_testing_system.md @@ -164,17 +164,17 @@ ASSUMPTIONS ``` ### `SINGLE_BATTLE_TEST` -`SINGLE_BATTLE_TEST(name, results...)` and `DOUBLE_BATTLE_TEST(name, results...)` -Define single- and double- battles. The names should start with the name of the mechanic being tested so that it is easier to run all the related tests. `results` contains variable declarations to be placed into the `results` array which is available in tests using `PARAMETRIZE` commands. -The main differences for doubles are: +`SINGLE_BATTLE_TEST(name, results...)`, `DOUBLE_BATTLE_TEST(name, results...)`, `MULTI_BATTLE_TEST(name, results...)`, `TWO_VS_ONE_BATTLE_TEST(name, results...)`, and `ONE_VS_TWO_BATTLE_TEST(name, results...)` +Define single-, double-, 2v2-multi-, 2v1-multi-, and 1v2- battles. The names should start with the name of the mechanic being tested so that it is easier to run all the related tests. `results` contains variable declarations to be placed into the `results` array which is available in tests using `PARAMETRIZE` commands. +The main differences for doubles, 2v2, 2v1, and 1v2 are: - Move targets sometimes need to be explicit. - Instead of `player` and `opponent` there is `playerLeft`, `playerRight`, `opponentLeft`, and `opponentRight`. ### `AI_SINGLE_BATTLE_TEST` -`AI_SINGLE_BATTLE_TEST(name, results...)` and `AI_DOUBLE_BATTLE_TEST(name, results...)` +`AI_SINGLE_BATTLE_TEST(name, results...)`, `AI_DOUBLE_BATTLE_TEST(name, results...)`, `AI_MULTI_BATTLE_TEST(name, results...)`, `AI_TWO_VS_ONE_BATTLE_TEST(name, results...)`, and `AI_ONE_VS_TWO_BATTLE_TEST(name, results...)` Define battles where opponent mons are controlled by AI, the same that runs when battling regular Trainers. The flags for AI should be specified by the `AI_FLAGS` command. -The rules remain the same as with the `SINGLE` and `DOUBLE` battle tests with some differences: +The rules remain the same as with the `SINGLE`, `DOUBLE`, `MULTI`, `TWO_VS_ONE`, and `ONE_VS_TWO` battle tests with some differences: - opponent's action is specified by the `EXPECT_MOVE` / `EXPECT_SEND_OUT` / `EXPECT_SWITCH` commands - we don't control what opponent actually does, instead we make sure the opponent does what we expect it to do - we still control the player's action the same way @@ -268,7 +268,7 @@ GIVEN { ``` ### `PLAYER` and `OPPONENT` -`PLAYER(species)` and `OPPONENT(species` +`PLAYER(species)` and `OPPONENT(species)` Adds the species to the player's or opponent's party respectively. The Pokémon can be further customized with the following functions: - `Gender(MON_MALE | MON_FEMALE)` @@ -285,11 +285,29 @@ For example to create a level 42 Wobbuffet that is poisoned: **Note if Speed is specified for any Pokémon then it must be specified for all Pokémon.** **Note if Moves is specified then MOVE will not automatically add moves to the moveset.** +### `MULTI_PLAYER`, `MULTI_PARTNER`, `MULTI_OPPONENT_A`, and `MULTI_OPPONENT_B` +For tests using `MULTI_BATTLE_TEST`, `AI_MULTI_BATTLE_TEST`, `TWO_VS_ONE_BATTLE_TEST`, `AI_TWO_VS_ONE_BATTLE_TEST`, `ONE_VS_TWO_BATTLE_TEST`, and `AI_ONE_VS_TWO_BATTLE_TEST`, the below must be used instead of `PLAYER(species)` and `OPPONENT(species)`. +`MULTI_PLAYER(species)`, `MULTI_PARTNER(species)`, `MULTI_OPPONENT_A(species)`, and `MULTI_OPPONENT_B(species)` +Adds the species to the player's, player partner's, opponent A's, or opponent B's party, respectively. +Pokemon can be customised as per the guidance for `PLAYER(species)` and `OPPONENT(species)`. +The functions assign the Pokémon to the party of the trainer at `B_POSITION_PLAYER_LEFT`, `B_POSITION_PLAYER_RIGHT`, `B_POSITION_OPPONENT_LEFT`, and `B_POSITION_OPPONENT_RIGHT`, respectively. +`MULTI_PLAYER(species)` and `MULTI_OPPONENT_A(species)` set Pokémon starting at party index 0, while `MULTI_PARTNER(species)` and `MULTI_OPPONENT_B(species)` set Pokémon starting at party index 3. +For `ONE_VS_TWO` tests, `MULTI_PLAYER(species)` must be used for all player-side Pokémon, and for `TWO_VS_ONE` tests, `MULTI_OPPONENT_A(species)` must be used for all opponent-side Pokémon. +All `MULTI_PLAYER(species)` Pokémon must be set before any `MULTI_PARTNER(species)` Pokémon, and all `MULTI_OPPONENT_A(species)` must be set before any `MULTI_OPPONENT_B(species)` Pokémon, else Pokémon will be set in the incorrect parties in the test. +**Note where a side in a test has two trainers, the test setup manages the assigning of correct multi-party orders, therefore when using functions such as SEND_OUT, Player and Opponent A Pokémon may be referenced using indexes 0, 1, and 2, and Player's Partner and Opponent B Pokémon may be referenced using indexes 3, 4, and 5.** + ### `AI_FLAGS` `AI_FLAGS(flags)` -Specifies which AI flags are run during the test. Has use only for AI tests. +Specifies which AI flags are run for all battlers during the test. Has use only for AI tests. The most common combination is `AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT)` which is the general 'smart' AI. +### `BATTLER_AI_FLAGS` +`BATTLER_AI_FLAGS(battler, flags)` +Specifies additional AI flags to be applied to specific battlers (battler 0/1/2/3). Has use only for AI tests. +Must be used strictly after `AI_FLAGS(flags)`, which overwrites all existing flags. +Example: `BATTLER_AI_FLAGS(3, AI_FLAG_RISKY)` used after `AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT)` +will set `AI_FLAG_RISKY` to only `battler3` (Opponent B), in addition to the flags set by `AI_FLAGS`. + ### `WHEN` ``` ... diff --git a/include/battle.h b/include/battle.h index ad32a9e632..14c01629ab 100644 --- a/include/battle.h +++ b/include/battle.h @@ -1223,7 +1223,7 @@ static inline struct PartyState *GetBattlerPartyState(u32 battler) static inline bool32 IsDoubleBattle(void) { - return gBattleTypeFlags & BATTLE_TYPE_DOUBLE; + return (gBattleTypeFlags & BATTLE_TYPE_MORE_THAN_TWO_BATTLERS); } static inline bool32 IsSpreadMove(u32 moveTarget) diff --git a/include/battle_controllers.h b/include/battle_controllers.h index 4f83f8eee9..0209ccbbca 100644 --- a/include/battle_controllers.h +++ b/include/battle_controllers.h @@ -395,6 +395,10 @@ void HandleChooseMoveAfterDma3(u32 battler); void SetControllerToRecordedPlayer(u32 battler); void RecordedPlayerBufferExecCompleted(u32 battler); +// recorded partner controller +void SetControllerToRecordedPartner(u32 battler); +void RecordedPartnerBufferExecCompleted(u32 battler); + // opponent controller void SetControllerToOpponent(u32 battler); void OpponentBufferExecCompleted(u32 battler); diff --git a/include/constants/battle.h b/include/constants/battle.h index 1f65e2a8f2..12f34a396b 100644 --- a/include/constants/battle.h +++ b/include/constants/battle.h @@ -98,10 +98,15 @@ enum BattleSide | BATTLE_TYPE_LEGENDARY \ | BATTLE_TYPE_RECORDED | BATTLE_TYPE_TRAINER_HILL | BATTLE_TYPE_SECRET_BASE)) -#define WILD_DOUBLE_BATTLE ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER)))) -#define RECORDED_WILD_BATTLE ((gBattleTypeFlags & BATTLE_TYPE_RECORDED) && !(gBattleTypeFlags & (BATTLE_TYPE_TRAINER | BATTLE_TYPE_FRONTIER))) -#define BATTLE_TWO_VS_ONE_OPPONENT ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && TRAINER_BATTLE_PARAM.opponentB == 0xFFFF)) -#define BATTLE_TYPE_HAS_AI (BATTLE_TYPE_TRAINER | BATTLE_TYPE_FIRST_BATTLE | BATTLE_TYPE_SAFARI | BATTLE_TYPE_ROAMER | BATTLE_TYPE_INGAME_PARTNER) +#define WILD_DOUBLE_BATTLE ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER)))) +#define RECORDED_WILD_BATTLE ((gBattleTypeFlags & BATTLE_TYPE_RECORDED) && !(gBattleTypeFlags & (BATTLE_TYPE_TRAINER | BATTLE_TYPE_FRONTIER))) +#define BATTLE_TWO_VS_ONE_OPPONENT ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && TRAINER_BATTLE_PARAM.opponentB == 0xFFFF)) +#define BATTLE_TYPE_HAS_AI (BATTLE_TYPE_TRAINER | BATTLE_TYPE_FIRST_BATTLE | BATTLE_TYPE_SAFARI | BATTLE_TYPE_ROAMER | BATTLE_TYPE_INGAME_PARTNER) +#define BATTLE_TYPE_MORE_THAN_TWO_BATTLERS (BATTLE_TYPE_DOUBLE | BATTLE_TYPE_MULTI | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_TWO_OPPONENTS) + +// Multibattle test composite flags +#define BATTLE_MULTI_TEST (BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS) +#define BATTLE_TWO_VS_ONE_TEST (BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_MULTI) // Battle Outcome defines #define B_OUTCOME_WON 1 diff --git a/include/recorded_battle.h b/include/recorded_battle.h index faf966109f..787cf4606c 100644 --- a/include/recorded_battle.h +++ b/include/recorded_battle.h @@ -27,7 +27,7 @@ struct RecordedBattleSave u8 frontierBrainSymbol; u8 battleScene:1; u8 textSpeed:3; - u64 AI_scripts; + u64 AI_scripts[MAX_BATTLERS_COUNT]; u8 recordMixFriendName[PLAYER_NAME_LENGTH + 1]; u8 recordMixFriendClass; u8 apprenticeId; @@ -81,7 +81,7 @@ u8 GetBattleSceneInRecordedBattle(void); u8 GetTextSpeedInRecordedBattle(void); void RecordedBattle_CopyBattlerMoves(u32 battler); void RecordedBattle_CheckMovesetChanges(u8 mode); -u64 GetAiScriptsInRecordedBattle(void); +u64 GetAiScriptsInRecordedBattle(u32 battler); void RecordedBattle_SetPlaybackFinished(void); bool8 RecordedBattle_CanStopPlayback(void); void GetRecordedBattleRecordMixFriendName(u8 *dst); diff --git a/include/test/battle.h b/include/test/battle.h index 78e6de34bb..4e779f0f0f 100644 --- a/include/test/battle.h +++ b/include/test/battle.h @@ -194,21 +194,22 @@ * ASSUME(GetMoveEffect(MOVE_POISON_STING) == EFFECT_POISON_HIT); * } * - * SINGLE_BATTLE_TEST(name, results...) and DOUBLE_BATTLE_TEST(name, results...) - * Define single- and double- battles. The names should start with the - * name of the mechanic being tested so that it is easier to run all the - * related tests. results contains variable declarations to be placed - * into the results array which is available in PARAMETRIZEd tests. - * The main differences for doubles are: + * SINGLE_BATTLE_TEST(name, results...), DOUBLE_BATTLE_TEST(name, results...), MULTI_BATTLE_TEST(name, results...), + * TWO_VS_ONE_BATTLE_TEST(name, results...), and ONE_VS_TWO_BATTLE_TEST(name, results...) + * Define single-, double-, 2v2-multi-, 2v1-multi-, and 1v2- battles. The names should start with + * the name of the mechanic being tested so that it is easier to run all the related tests. results contains variable + * declarations to be placed into the `results` array which is available in tests using `PARAMETRIZE` commands. + * The main differences for doubles, 2v2, 2v1, and 1v2 are: * - Move targets sometimes need to be explicit. * - Instead of player and opponent there is playerLeft, playerRight, * opponentLeft, and opponentRight. * - * AI_SINGLE_BATTLE_TEST(name, results...) and AI_DOUBLE_BATTLE_TEST(name, results...) + * AI_SINGLE_BATTLE_TEST(name, results...), AI_DOUBLE_BATTLE_TEST(name, results...), + * AI_MULTI_BATTLE_TEST(name, results...), AI_TWO_VS_ONE_BATTLE_TEST(name, results...), and AI_ONE_VS_TWO_BATTLE_TEST(name, results...) * Define battles where opponent mons are controlled by AI, the same that runs * when battling regular Trainers. The flags for AI should be specified by * the AI_FLAGS command. - * The rules remain the same as with the SINGLE and DOUBLE battle tests + * The rules remain the same as with the SINGLE, DOUBLE, MULTI, TWO_VS_ONE, and ONE_VS_TWO battle tests with some differences: * with some differences: * - opponent's action is specified by the EXPECT_MOVE(s) / EXPECT_SEND_OUT / EXPECT_SWITCH commands * - we don't control what opponent actually does, instead we make sure the opponent does what we expect it to do @@ -333,10 +334,39 @@ * Note if Moves is specified then MOVE will not automatically add moves * to the moveset. * + * For tests using MULTI_BATTLE_TEST, AI_MULTI_BATTLE_TEST, TWO_VS_ONE_BATTLE_TEST, + * AI_TWO_VS_ONE_BATTLE_TEST, ONE_VS_TWO_BATTLE_TEST, and AI_ONE_VS_TWO_BATTLE_TEST, + * the below must be used instead of PLAYER(species) and OPPONENT(species). + * MULTI_PLAYER(species), MULTI_PARTNER(species), MULTI_OPPONENT_A(species), and + * MULTI_OPPONENT_B(species) Adds the species to the player's, player partner's, + * opponent A's, or opponent B's party, respectively. + * Pokemon can be customised as per the guidance for PLAYER(species) and OPPONENT(species). + * The functions assign the Pokémon to the party of the trainer at B_POSITION_PLAYER_LEFT, + * B_POSITION_PLAYER_RIGHT, B_POSITION_OPPONENT_LEFT, and B_POSITION_OPPONENT_RIGHT, respectively. + * MULTI_PLAYER(species) and MULTI_OPPONENT_A(species) set Pokémon starting at party index 0, + * while MULTI_PARTNER(species) and MULTI_OPPONENT_B(species) set Pokémon starting at party + * index 3. + * For ONE_VS_TWO tests, MULTI_PLAYER(species) must be used for all player-side Pokémon, + * and for TWO_VS_ONE tests, MULTI_OPPONENT_A(species) must be used for all opponent-side + * Pokémon. + * All MULTI_PLAYER(species) Pokémon must be set before any MULTI_PARTNER(species) Pokémon, + * and all MULTI_OPPONENT_A(species) must be set before any MULTI_OPPONENT_B(species) Pokémon, + * else Pokémon will be set in the incorrect parties in the test. + * Note where a side in a test has two trainers, the test setup manages the assigning of correct + * multi-party orders, therefore when using functions such as SEND_OUT, Player and Opponent A + * Pokémon may be referenced using indexes 0, 1, and 2, and Player's Partner and Opponent B + * Pokémon may be referenced using indexes 3, 4, and 5. + * * AI_FLAGS - * Specifies which AI flags are run during the test. Has use only for AI tests. + * Specifies which AI flags are run for all battlers during the test. Has use only for AI tests. * The most common combination is AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT) * which is the general 'smart' AI. + * + * BATTLER_AI_FLAGS + * Specifies additional AI flags to be applied to specific battlers (battler 0/1/2/3). Has use only for AI tests. + * Must be used strictly after AI_FLAGS(flags), which overwrites all existing flags. + * Example: BATTLER_AI_FLAGS(3, AI_FLAG_RISKY) used after AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT) + * will set AI_FLAG_RISKY to only battler3 (Opponent B), in addition to the flags set by AI_FLAGS. * * WHEN * Contains the choices that battlers make during the battle. @@ -537,10 +567,13 @@ #define MAX_QUEUED_EVENTS 30 #define MAX_EXPECTED_ACTIONS 10 -enum { BATTLE_TEST_SINGLES, BATTLE_TEST_DOUBLES, BATTLE_TEST_WILD, BATTLE_TEST_AI_SINGLES, BATTLE_TEST_AI_DOUBLES }; +enum { BATTLE_TEST_SINGLES, BATTLE_TEST_DOUBLES, BATTLE_TEST_WILD, BATTLE_TEST_AI_SINGLES, BATTLE_TEST_AI_DOUBLES, BATTLE_TEST_MULTI, BATTLE_TEST_AI_MULTI, BATTLE_TEST_TWO_VS_ONE, BATTLE_TEST_AI_TWO_VS_ONE, BATTLE_TEST_ONE_VS_TWO, BATTLE_TEST_AI_ONE_VS_TWO }; typedef void (*SingleBattleTestFunction)(void *, const u32, struct BattlePokemon *, struct BattlePokemon *); typedef void (*DoubleBattleTestFunction)(void *, const u32, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *); +typedef void (*MultiBattleTestFunction)(void *, const u32, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *); +typedef void (*TwoVsOneBattleTestFunction)(void *, const u32, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *); +typedef void (*OneVsTwoBattleTestFunction)(void *, const u32, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *); struct BattleTest { @@ -549,6 +582,9 @@ struct BattleTest { SingleBattleTestFunction singles; DoubleBattleTestFunction doubles; + MultiBattleTestFunction multi; + TwoVsOneBattleTestFunction two_vs_one; + OneVsTwoBattleTestFunction one_vs_two; } function; size_t resultsSize; }; @@ -688,11 +724,11 @@ struct BattleTestData u8 playerPartySize; u8 opponentPartySize; - u8 explicitMoves[NUM_BATTLE_SIDES]; + u8 explicitMoves[MAX_BATTLERS_COUNT]; bool8 hasExplicitSpeeds; - u8 explicitSpeeds[NUM_BATTLE_SIDES]; + u8 explicitSpeeds[MAX_BATTLERS_COUNT]; u16 slowerThan[NUM_BATTLE_SIDES][PARTY_SIZE]; - u8 currentSide; + u8 currentPosition; u8 currentPartyIndex; struct Pokemon *currentMon; u8 gender; @@ -767,6 +803,8 @@ extern struct BattleTestRunnerState *const gBattleTestRunnerState; #define R_APPEND_TRUE(...) __VA_OPT__(FIRST(__VA_ARGS__), TRUE RECURSIVELY(R_FOR_EACH(APPEND_COMMA_TRUE, EXCEPT_1(__VA_ARGS__)))) #define AI_TRAINER_NAME "{PKMN} TRAINER LEAF" +#define AI_TRAINER_2_NAME "{PKMN} TRAINER RED" +#define AI_PARTNER_NAME "{PKMN} TRAINER 1" /* Test */ @@ -812,6 +850,60 @@ extern struct BattleTestRunnerState *const gBattleTestRunnerState; }; \ static void CAT(Test, __LINE__)(struct CAT(Result, __LINE__) *results, const u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight) + #define BATTLE_TEST_ARGS_MULTI(_name, _type, ...) \ + struct CAT(Result, __LINE__) { RECURSIVELY(R_FOR_EACH(APPEND_SEMICOLON, __VA_ARGS__)) }; \ + static void CAT(Test, __LINE__)(struct CAT(Result, __LINE__) *, const u32, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *); \ + __attribute__((section(".tests"), used)) static const struct Test CAT(sTest, __LINE__) = \ + { \ + .name = _name, \ + .filename = __FILE__, \ + .runner = &gBattleTestRunner, \ + .sourceLine = __LINE__, \ + .data = (void *)&(const struct BattleTest) \ + { \ + .type = _type, \ + .function = { .multi = (MultiBattleTestFunction)CAT(Test, __LINE__) }, \ + .resultsSize = sizeof(struct CAT(Result, __LINE__)), \ + }, \ + }; \ + static void CAT(Test, __LINE__)(struct CAT(Result, __LINE__) *results, const u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight) + +#define BATTLE_TEST_ARGS_TWO_VS_ONE(_name, _type, ...) \ + struct CAT(Result, __LINE__) { RECURSIVELY(R_FOR_EACH(APPEND_SEMICOLON, __VA_ARGS__)) }; \ + static void CAT(Test, __LINE__)(struct CAT(Result, __LINE__) *, const u32, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *); \ + __attribute__((section(".tests"), used)) static const struct Test CAT(sTest, __LINE__) = \ + { \ + .name = _name, \ + .filename = __FILE__, \ + .runner = &gBattleTestRunner, \ + .sourceLine = __LINE__, \ + .data = (void *)&(const struct BattleTest) \ + { \ + .type = _type, \ + .function = { .two_vs_one = (TwoVsOneBattleTestFunction)CAT(Test, __LINE__) }, \ + .resultsSize = sizeof(struct CAT(Result, __LINE__)), \ + }, \ + }; \ + static void CAT(Test, __LINE__)(struct CAT(Result, __LINE__) *results, const u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight) + +#define BATTLE_TEST_ARGS_ONE_VS_TWO(_name, _type, ...) \ + struct CAT(Result, __LINE__) { RECURSIVELY(R_FOR_EACH(APPEND_SEMICOLON, __VA_ARGS__)) }; \ + static void CAT(Test, __LINE__)(struct CAT(Result, __LINE__) *, const u32, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *, struct BattlePokemon *); \ + __attribute__((section(".tests"), used)) static const struct Test CAT(sTest, __LINE__) = \ + { \ + .name = _name, \ + .filename = __FILE__, \ + .runner = &gBattleTestRunner, \ + .sourceLine = __LINE__, \ + .data = (void *)&(const struct BattleTest) \ + { \ + .type = _type, \ + .function = { .one_vs_two = (OneVsTwoBattleTestFunction)CAT(Test, __LINE__) }, \ + .resultsSize = sizeof(struct CAT(Result, __LINE__)), \ + }, \ + }; \ + static void CAT(Test, __LINE__)(struct CAT(Result, __LINE__) *results, const u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight) + #define SINGLE_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_SINGLE(_name, BATTLE_TEST_SINGLES, __VA_ARGS__) #define WILD_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_SINGLE(_name, BATTLE_TEST_WILD, __VA_ARGS__) @@ -820,6 +912,15 @@ extern struct BattleTestRunnerState *const gBattleTestRunnerState; #define DOUBLE_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_DOUBLE(_name, BATTLE_TEST_DOUBLES, __VA_ARGS__) #define AI_DOUBLE_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_DOUBLE(_name, BATTLE_TEST_AI_DOUBLES, __VA_ARGS__) +#define MULTI_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_MULTI(_name, BATTLE_TEST_MULTI, __VA_ARGS__) +#define AI_MULTI_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_MULTI(_name, BATTLE_TEST_AI_MULTI, __VA_ARGS__) + +#define TWO_VS_ONE_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_TWO_VS_ONE(_name, BATTLE_TEST_TWO_VS_ONE, __VA_ARGS__) +#define AI_TWO_VS_ONE_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_TWO_VS_ONE(_name, BATTLE_TEST_AI_TWO_VS_ONE, __VA_ARGS__) + +#define ONE_VS_TWO_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_TWO_VS_ONE(_name, BATTLE_TEST_ONE_VS_TWO, __VA_ARGS__) +#define AI_ONE_VS_TWO_BATTLE_TEST(_name, ...) BATTLE_TEST_ARGS_TWO_VS_ONE(_name, BATTLE_TEST_AI_ONE_VS_TWO, __VA_ARGS__) + /* Parametrize */ #undef PARAMETRIZE // Override test/test.h's implementation. @@ -848,13 +949,18 @@ struct moveWithPP { #define RNGSeed(seed) RNGSeed_(__LINE__, seed) #define AI_FLAGS(flags) AIFlags_(__LINE__, flags) +#define BATTLER_AI_FLAGS(battler, flags) BattlerAIFlags_(__LINE__, battler, flags) #define AI_LOG AILogScores(__LINE__) #define FLAG_SET(flagId) SetFlagForTest(__LINE__, flagId) #define WITH_CONFIG(configTag, value) TestSetConfig(__LINE__, configTag, value) -#define PLAYER(species) for (OpenPokemon(__LINE__, B_SIDE_PLAYER, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) -#define OPPONENT(species) for (OpenPokemon(__LINE__, B_SIDE_OPPONENT, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) +#define PLAYER(species) for (OpenPokemon(__LINE__, B_POSITION_PLAYER_LEFT, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) +#define OPPONENT(species) for (OpenPokemon(__LINE__, B_POSITION_OPPONENT_LEFT, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) +#define MULTI_PLAYER(species) for (OpenPokemonMulti(__LINE__, B_POSITION_PLAYER_LEFT, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) +#define MULTI_OPPONENT_A(species) for (OpenPokemonMulti(__LINE__, B_POSITION_OPPONENT_LEFT, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) +#define MULTI_PARTNER(species) for (OpenPokemonMulti(__LINE__, B_POSITION_PLAYER_RIGHT, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) +#define MULTI_OPPONENT_B(species) for (OpenPokemonMulti(__LINE__, B_POSITION_OPPONENT_RIGHT, species); gBattleTestRunnerState->data.currentMon; ClosePokemon(__LINE__)) #define Gender(gender) Gender_(__LINE__, gender) #define Nature(nature) Nature_(__LINE__, nature) @@ -888,11 +994,13 @@ struct moveWithPP { void SetFlagForTest(u32 sourceLine, u16 flagId); void TestSetConfig(u32 sourceLine, enum GenConfigTag configTag, u32 value); void ClearFlagAfterTest(void); -void OpenPokemon(u32 sourceLine, enum BattleSide side, u32 species); +void OpenPokemon(u32 sourceLine, enum BattlerPosition position, u32 species); +void OpenPokemonMulti(u32 sourceLine, enum BattlerPosition position, u32 species); void ClosePokemon(u32 sourceLine); void RNGSeed_(u32 sourceLine, rng_value_t seed); void AIFlags_(u32 sourceLine, u64 flags); +void BattlerAIFlags_(u32 sourceLine, u32 battler, u64 flags); void AILogScores(u32 sourceLine); void Gender_(u32 sourceLine, u32 gender); void Nature_(u32 sourceLine, u32 nature); @@ -923,6 +1031,22 @@ void TeraType_(u32 sourceLine, u32 teraType); void Shadow_(u32 sourceLine, bool32 isShadow); void Shiny_(u32 sourceLine, bool32 isShiny); +static inline bool8 IsMultibattleTest(void) +{ + if (TESTING) + { + if (((gBattleTypeFlags & BATTLE_MULTI_TEST) == BATTLE_MULTI_TEST) + || ((gBattleTypeFlags & BATTLE_TWO_VS_ONE_TEST) == BATTLE_TWO_VS_ONE_TEST)) + return TRUE; + else + return FALSE; + } + else + { + return FALSE; + } +} + // Created for easy use of EXPECT_MOVES, so the user can provide 1, 2, 3 or 4 moves for AI which can pass the test. struct FourMoves { diff --git a/include/test/test_runner_battle.h b/include/test/test_runner_battle.h new file mode 100644 index 0000000000..8a2c0dc64b --- /dev/null +++ b/include/test/test_runner_battle.h @@ -0,0 +1,6 @@ +#ifndef GUARD_BATTLE_TEST_RUNNER_H +#define GUARD_BATTLE_TEST_RUNNER_H + +bool8 IsMultibattleTest(void); + +#endif diff --git a/src/battle_ai_main.c b/src/battle_ai_main.c index e84d7313a6..ce7ab09768 100644 --- a/src/battle_ai_main.c +++ b/src/battle_ai_main.c @@ -182,7 +182,7 @@ static u64 GetWildAiFlags(void) return flags; } -static u64 GetAiFlags(u16 trainerId) +static u64 GetAiFlags(u16 trainerId, u32 battler) { u64 flags = 0; @@ -195,7 +195,7 @@ static u64 GetAiFlags(u16 trainerId) else { if (gBattleTypeFlags & BATTLE_TYPE_RECORDED) - flags = GetAiScriptsInRecordedBattle(); + flags = GetAiScriptsInRecordedBattle(battler); else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI) flags = AI_FLAG_SAFARI; else if (gBattleTypeFlags & BATTLE_TYPE_ROAMER) @@ -232,7 +232,7 @@ static u64 GetAiFlags(u16 trainerId) void BattleAI_SetupFlags(void) { if (IsAiVsAiBattle()) - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT] = GetAiFlags(gPartnerTrainerId); + gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT] = GetAiFlags(gPartnerTrainerId, B_POSITION_PLAYER_LEFT); else gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT] = 0; // player has no AI @@ -246,8 +246,8 @@ void BattleAI_SetupFlags(void) if (IsWildMonSmart() && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER))) { // smart wild AI - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(0xFFFF); - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(0xFFFF); + gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(0xFFFF, B_POSITION_OPPONENT_LEFT); + gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(0xFFFF, B_POSITION_OPPONENT_RIGHT); // The check is here because wild natural enemies are not symmetrical. if (B_WILD_NATURAL_ENEMIES && IsDoubleBattle()) @@ -259,20 +259,19 @@ void BattleAI_SetupFlags(void) if (IsNaturalEnemy(speciesRight, speciesLeft)) gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] |= AI_FLAG_ATTACKS_PARTNER; } - } else { - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA); - if (TRAINER_BATTLE_PARAM.opponentB != 0 && TRAINER_BATTLE_PARAM.opponentB != 0xFFFF) - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentB); + gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA, B_POSITION_OPPONENT_LEFT); + if ((TRAINER_BATTLE_PARAM.opponentB != 0) && (TRAINER_BATTLE_PARAM.opponentB != 0xFFFF)) + gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentB, B_POSITION_OPPONENT_RIGHT); else gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT]; } if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) { - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_RIGHT] = GetAiFlags(gPartnerTrainerId); + gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_RIGHT] = GetAiFlags(gPartnerTrainerId, B_POSITION_PLAYER_RIGHT); } else if (IsDoubleBattle() && IsAiVsAiBattle()) { @@ -280,7 +279,8 @@ void BattleAI_SetupFlags(void) } else // Assign ai flags for player for prediction { - u64 aiFlags = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA) | GetAiFlags(TRAINER_BATTLE_PARAM.opponentB); + u64 aiFlags = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA, B_POSITION_OPPONENT_LEFT) + | GetAiFlags(TRAINER_BATTLE_PARAM.opponentB, B_POSITION_OPPONENT_RIGHT); gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_RIGHT] = aiFlags; gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT] = aiFlags; } diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 51322c0315..8c41359b7a 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -39,6 +39,8 @@ #include "constants/trainers.h" #include "trainer_hill.h" #include "test_runner.h" +#include "test/battle.h" +#include "test/test_runner_battle.h" static void OpponentHandleDrawTrainerPic(u32 battler); static void OpponentHandleTrainerSlideBack(u32 battler); @@ -369,18 +371,40 @@ static u32 OpponentGetTrainerPicId(u32 battlerId) static void OpponentHandleDrawTrainerPic(u32 battler) { s16 xPos; - u32 trainerPicId = OpponentGetTrainerPicId(battler); - - if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS) && !BATTLE_TWO_VS_ONE_OPPONENT) + u32 trainerPicId; + + // Sets Multibattle test opponent sprites to not be Hiker + if (IsMultibattleTest()) { - if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_LEFT) + { + trainerPicId = TRAINER_PIC_LEAF; + if (!(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)) + xPos = 176; + else + xPos = 200; + } + else + { + trainerPicId = TRAINER_PIC_RED; xPos = 152; - else // first mon - xPos = 200; + } } else { - xPos = 176; + trainerPicId = OpponentGetTrainerPicId(battler); + + if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS) && !BATTLE_TWO_VS_ONE_OPPONENT) + { + if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon + xPos = 152; + else // first mon + xPos = 200; + } + else + { + xPos = 176; + } } BtlController_HandleDrawTrainerPic(battler, trainerPicId, TRUE, xPos, 40, -1); diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index b5a5e7abec..6b6c5a65ba 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -46,6 +46,8 @@ #include "pokemon_summary_screen.h" #include "type_icons.h" #include "pokedex.h" +#include "test/battle.h" +#include "test/test_runner_battle.h" static void PlayerHandleLoadMonSprite(u32 battler); static void PlayerHandleDrawTrainerPic(u32 battler); @@ -1865,30 +1867,40 @@ static void PlayerHandleDrawTrainerPic(u32 battler) bool32 isFrontPic; s16 xPos, yPos; u32 trainerPicId; - - trainerPicId = PlayerGetTrainerBackPicId(); - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + if (IsMultibattleTest()) { - if ((GetBattlerPosition(battler) & BIT_FLANK) != B_FLANK_LEFT) // Second mon, on the right. - xPos = 90; - else // First mon, on the left. + trainerPicId = TRAINER_BACK_PIC_BRENDAN; + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) xPos = 32; - - if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gPartnerTrainerId < TRAINER_PARTNER(PARTNER_NONE)) - { - xPos = 90; - yPos = 80; - } else - { - yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; - } - + xPos = 80; + yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; } else { - xPos = 80; - yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; + trainerPicId = PlayerGetTrainerBackPicId(); + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBattlerPosition(battler) & BIT_FLANK) != B_FLANK_LEFT) // Second mon, on the right. + xPos = 90; + else // First mon, on the left. + xPos = 32; + + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gPartnerTrainerId < TRAINER_PARTNER(PARTNER_NONE)) + { + xPos = 90; + yPos = 80; + } + else + { + yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; + } + } + else + { + xPos = 80; + yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; + } } // Use front pic table for any tag battles unless your partner is Steven or a custom partner. diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index 2872a83c31..6973dbbc28 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -31,6 +31,8 @@ #include "constants/songs.h" #include "constants/party_menu.h" #include "constants/trainers.h" +#include "test/battle.h" +#include "test/test_runner_battle.h" static void PlayerPartnerHandleDrawTrainerPic(u32 battler); static void PlayerPartnerHandleTrainerSlideBack(u32 battler); @@ -204,7 +206,13 @@ static void PlayerPartnerHandleDrawTrainerPic(u32 battler) enum DifficultyLevel difficulty = GetBattlePartnerDifficultyLevel(gPartnerTrainerId); - if (gPartnerTrainerId > TRAINER_PARTNER(PARTNER_NONE)) + if (IsMultibattleTest()) + { + trainerPicId = TRAINER_BACK_PIC_STEVEN; + xPos = 90; + yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; + } + else if (gPartnerTrainerId > TRAINER_PARTNER(PARTNER_NONE)) { trainerPicId = gBattlePartners[difficulty][gPartnerTrainerId - TRAINER_PARTNER(PARTNER_NONE)].trainerBackPic; xPos = 90; @@ -309,6 +317,8 @@ static void PlayerPartnerHandleChoosePokemon(u32 battler) gBattleStruct->AI_monToSwitchIntoId[battler] = PARTY_SIZE; gBattleStruct->monToSwitchIntoId[battler] = chosenMonId; } + if (TESTING) + TestRunner_Battle_CheckSwitch(battler, chosenMonId); BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, chosenMonId, NULL); BtlController_Complete(battler); } diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index 21ecb79801..954fdc4bc3 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -31,6 +31,8 @@ #include "constants/battle_anim.h" #include "constants/songs.h" #include "constants/trainers.h" +#include "test/battle.h" +#include "test/test_runner_battle.h" static void RecordedOpponentHandleDrawTrainerPic(u32 battler); static void RecordedOpponentHandleTrainerSlideBack(u32 battler); @@ -273,7 +275,24 @@ static void RecordedOpponentHandleDrawTrainerPic(u32 battler) s16 xPos; u32 trainerPicId; - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + // Sets Multibattle test opponent sprites to not be Hiker + if (IsMultibattleTest()) + { + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_LEFT) + { + trainerPicId = TRAINER_PIC_LEAF; + if (!(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)) + xPos = 176; + else + xPos = 200; + } + else + { + trainerPicId = TRAINER_PIC_RED; + xPos = 152; + } + } + else if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon xPos = 152; diff --git a/src/battle_controller_recorded_partner.c b/src/battle_controller_recorded_partner.c new file mode 100644 index 0000000000..d135329635 --- /dev/null +++ b/src/battle_controller_recorded_partner.c @@ -0,0 +1,269 @@ +#include "global.h" +#include "battle.h" +#include "battle_ai_main.h" +#include "battle_ai_util.h" +#include "battle_anim.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_setup.h" +#include "battle_tower.h" +#include "battle_z_move.h" +#include "bg.h" +#include "data.h" +#include "item_use.h" +#include "link.h" +#include "main.h" +#include "m4a.h" +#include "palette.h" +#include "party_menu.h" +#include "pokeball.h" +#include "pokemon.h" +#include "recorded_battle.h" +#include "reshow_battle_screen.h" +#include "sound.h" +#include "string_util.h" +#include "task.h" +#include "test_runner.h" +#include "text.h" +#include "util.h" +#include "window.h" +#include "constants/battle_anim.h" +#include "constants/battle_partner.h" +#include "constants/songs.h" +#include "constants/party_menu.h" +#include "constants/trainers.h" + +static void RecordedPartnerHandleDrawTrainerPic(u32 battler); +static void RecordedPartnerHandleTrainerSlideBack(u32 battler); +static void RecordedPartnerHandleChooseAction(u32 battler); +static void RecordedPartnerHandleChooseMove(u32 battler); +static void RecordedPartnerHandleChoosePokemon(u32 battler); +static void RecordedPartnerHandleIntroTrainerBallThrow(u32 battler); +static void RecordedPartnerHandleDrawPartyStatusSummary(u32 battler); +static void RecordedPartnerHandleEndLinkBattle(u32 battler); +static void RecordedPartnerBufferRunCommand(u32 battler); + +static void (*const sRecordedPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +{ + [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, + [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, + [CONTROLLER_SETMONDATA] = BtlController_HandleSetMonData, + [CONTROLLER_SETRAWMONDATA] = BtlController_HandleSetRawMonData, + [CONTROLLER_LOADMONSPRITE] = BtlController_HandleLoadMonSprite, + [CONTROLLER_SWITCHINANIM] = BtlController_HandleSwitchInAnim, + [CONTROLLER_RETURNMONTOBALL] = BtlController_HandleReturnMonToBall, + [CONTROLLER_DRAWTRAINERPIC] = RecordedPartnerHandleDrawTrainerPic, + [CONTROLLER_TRAINERSLIDE] = BtlController_Empty, + [CONTROLLER_TRAINERSLIDEBACK] = RecordedPartnerHandleTrainerSlideBack, + [CONTROLLER_FAINTANIMATION] = BtlController_HandleFaintAnimation, + [CONTROLLER_PALETTEFADE] = BtlController_Empty, + [CONTROLLER_SUCCESSBALLTHROWANIM] = BtlController_Empty, + [CONTROLLER_BALLTHROWANIM] = BtlController_Empty, + [CONTROLLER_PAUSE] = BtlController_Empty, + [CONTROLLER_MOVEANIMATION] = BtlController_HandleMoveAnimation, + [CONTROLLER_PRINTSTRING] = BtlController_HandlePrintString, + [CONTROLLER_PRINTSTRINGPLAYERONLY] = BtlController_Empty, + [CONTROLLER_CHOOSEACTION] = RecordedPartnerHandleChooseAction, + [CONTROLLER_YESNOBOX] = BtlController_Empty, + [CONTROLLER_CHOOSEMOVE] = RecordedPartnerHandleChooseMove, + [CONTROLLER_OPENBAG] = BtlController_Empty, + [CONTROLLER_CHOOSEPOKEMON] = RecordedPartnerHandleChoosePokemon, + [CONTROLLER_23] = BtlController_Empty, + [CONTROLLER_HEALTHBARUPDATE] = BtlController_HandleHealthBarUpdate, + [CONTROLLER_EXPUPDATE] = PlayerHandleExpUpdate, // Partner's player gets experience the same way as the player. + [CONTROLLER_STATUSICONUPDATE] = BtlController_HandleStatusIconUpdate, + [CONTROLLER_STATUSANIMATION] = BtlController_HandleStatusAnimation, + [CONTROLLER_STATUSXOR] = BtlController_Empty, + [CONTROLLER_DATATRANSFER] = BtlController_Empty, + [CONTROLLER_DMA3TRANSFER] = BtlController_Empty, + [CONTROLLER_PLAYBGM] = BtlController_Empty, + [CONTROLLER_32] = BtlController_Empty, + [CONTROLLER_TWORETURNVALUES] = BtlController_Empty, + [CONTROLLER_CHOSENMONRETURNVALUE] = BtlController_Empty, + [CONTROLLER_ONERETURNVALUE] = BtlController_Empty, + [CONTROLLER_ONERETURNVALUE_DUPLICATE] = BtlController_Empty, + [CONTROLLER_HITANIMATION] = BtlController_HandleHitAnimation, + [CONTROLLER_CANTSWITCH] = BtlController_Empty, + [CONTROLLER_PLAYSE] = BtlController_HandlePlaySE, + [CONTROLLER_PLAYFANFAREORBGM] = BtlController_HandlePlayFanfareOrBGM, + [CONTROLLER_FAINTINGCRY] = BtlController_HandleFaintingCry, + [CONTROLLER_INTROSLIDE] = BtlController_HandleIntroSlide, + [CONTROLLER_INTROTRAINERBALLTHROW] = RecordedPartnerHandleIntroTrainerBallThrow, + [CONTROLLER_DRAWPARTYSTATUSSUMMARY] = RecordedPartnerHandleDrawPartyStatusSummary, + [CONTROLLER_HIDEPARTYSTATUSSUMMARY] = BtlController_HandleHidePartyStatusSummary, + [CONTROLLER_ENDBOUNCE] = BtlController_Empty, + [CONTROLLER_SPRITEINVISIBILITY] = BtlController_HandleSpriteInvisibility, + [CONTROLLER_BATTLEANIMATION] = BtlController_HandleBattleAnimation, + [CONTROLLER_LINKSTANDBYMSG] = BtlController_Empty, + [CONTROLLER_RESETACTIONMOVESELECTION] = BtlController_Empty, + [CONTROLLER_ENDLINKBATTLE] = RecordedPartnerHandleEndLinkBattle, + [CONTROLLER_DEBUGMENU] = BtlController_Empty, + [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop +}; + +void SetControllerToRecordedPartner(u32 battler) +{ + gBattlerControllerEndFuncs[battler] = RecordedPartnerBufferExecCompleted; + gBattlerControllerFuncs[battler] = RecordedPartnerBufferRunCommand; +} + +static void RecordedPartnerBufferRunCommand(u32 battler) +{ + if (IsBattleControllerActiveOnLocal(battler)) + { + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sRecordedPartnerBufferCommands)) + sRecordedPartnerBufferCommands[gBattleResources->bufferA[battler][0]](battler); + else + BtlController_Complete(battler); + } +} + +static void Intro_WaitForHealthbox(u32 battler) +{ + bool32 finished = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) + finished = TRUE; + } + else + { + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) + { + finished = TRUE; + } + } + + if (IsCryPlayingOrClearCrySongs()) + finished = FALSE; + + if (finished) + { + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = BtlController_Intro_DelayAndEnd; + } +} + +void Controller_RecordedPartnerShowIntroHealthbox(u32 battler) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive + && gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && ++gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay != 1) + { + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; + TryShinyAnimation(battler, GetBattlerMon(battler)); + + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], GetBattlerMon(BATTLE_PARTNER(battler)), HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); + } + + DestroySprite(&gSprites[gBattleControllerData[battler]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], GetBattlerMon(battler), HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); + + gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; + + gBattlerControllerFuncs[battler] = Intro_WaitForHealthbox; + } +} + +void RecordedPartnerBufferExecCompleted(u32 battler) +{ + gBattlerControllerFuncs[battler] = RecordedPartnerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId); + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; + } + else + { + MarkBattleControllerIdleOnLocal(battler); + } +} + +// some explanation here +// in emerald it's possible to have a tag battle in the battle frontier facilities with AI +// which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it +static void RecordedPartnerHandleDrawTrainerPic(u32 battler) +{ + bool32 isFrontPic; + s16 xPos, yPos; + u32 trainerPicId; + + trainerPicId = TRAINER_BACK_PIC_STEVEN; + xPos = 90; + yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; + + isFrontPic = FALSE; + + BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); +} + +static void RecordedPartnerHandleTrainerSlideBack(u32 battler) +{ + BtlController_HandleTrainerSlideBack(battler, 35, FALSE); +} + +static void RecordedPartnerHandleChooseAction(u32 battler) +{ + BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); + BtlController_Complete(battler); +} + +static void RecordedPartnerHandleChooseMove(u32 battler) +{ + u8 moveIndex = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler); + u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler); + BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_EXEC_SCRIPT, moveIndex | (target << 8)); + + BtlController_Complete(battler); +} + +static void RecordedPartnerHandleChoosePokemon(u32 battler) +{ + gBattleStruct->monToSwitchIntoId[battler] = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); + gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing + BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, gBattleStruct->monToSwitchIntoId[battler], NULL); + BtlController_Complete(battler); +} + +static void RecordedPartnerHandleIntroTrainerBallThrow(u32 battler) +{ + const u16 *trainerPal; + enum DifficultyLevel difficulty = GetBattlePartnerDifficultyLevel(gPartnerTrainerId); + + if (gPartnerTrainerId > TRAINER_PARTNER(PARTNER_NONE)) + trainerPal = gTrainerBacksprites[gBattlePartners[difficulty][gPartnerTrainerId - TRAINER_PARTNER(PARTNER_NONE)].trainerPic].palette.data; + else if (IsAiVsAiBattle()) + trainerPal = gTrainerSprites[GetTrainerPicFromId(gPartnerTrainerId)].palette.data; + else + trainerPal = gTrainerSprites[GetFrontierTrainerFrontSpriteId(gPartnerTrainerId)].palette.data; // 2 vs 2 multi battle in Battle Frontier, load front sprite and pal. + + BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Controller_RecordedPartnerShowIntroHealthbox); +} + +static void RecordedPartnerHandleDrawPartyStatusSummary(u32 battler) +{ + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); +} + +static void RecordedPartnerHandleEndLinkBattle(u32 battler) +{ + gBattleOutcome = gBattleResources->bufferA[battler][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + BtlController_Complete(battler); + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; +} diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index c86cf4a9d5..51bfa5327b 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -28,6 +28,8 @@ #include "constants/battle_anim.h" #include "constants/songs.h" #include "constants/trainers.h" +#include "test/battle.h" +#include "test/test_runner_battle.h" static void RecordedPlayerHandleDrawTrainerPic(u32 battler); static void RecordedPlayerHandleTrainerSlideBack(u32 battler); @@ -40,7 +42,6 @@ static void RecordedPlayerHandleStatusAnimation(u32 battler); static void RecordedPlayerHandleIntroTrainerBallThrow(u32 battler); static void RecordedPlayerHandleDrawPartyStatusSummary(u32 battler); static void RecordedPlayerHandleEndLinkBattle(u32 battler); - static void RecordedPlayerBufferRunCommand(u32 battler); static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = @@ -275,43 +276,54 @@ static void RecordedPlayerHandleDrawTrainerPic(u32 battler) s16 xPos, yPos; u32 trainerPicId; - if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK) + // Sets Multibattle test player sprites to not be Hiker + if (IsMultibattleTest()) { - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) - trainerPicId = GetBattlerLinkPlayerGender(battler); - else - trainerPicId = gLinkPlayers[gRecordedBattleMultiplayerId].gender; - } - else - { - trainerPicId = gLinkPlayers[0].gender; - } - - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) - { - if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon - xPos = 90; - else // first mon - xPos = 32; - + trainerPicId = TRAINER_BACK_PIC_BRENDAN; if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) - { - xPos = 90; - yPos = 80; - } + xPos = 32; else - { - yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; - } - - } - else - { - xPos = 80; + xPos = 80; yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + trainerPicId = GetBattlerLinkPlayerGender(battler); + else + trainerPicId = gLinkPlayers[gRecordedBattleMultiplayerId].gender; + } + else + trainerPicId = gLinkPlayers[0].gender; - if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon + xPos = 90; + else // first mon + xPos = 32; + + // !TESTING added as otherwise first test battle sprite is positioned incorrectly + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && !TESTING) + { + xPos = 90; + yPos = 80; + } + else + { + yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; + } + } + else + { + xPos = 80; + yPos = (8 - gTrainerBacksprites[trainerPicId].coordinates.size) * 4 + 80; + } + } + + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && !TESTING) isFrontPic = TRUE; else isFrontPic = FALSE; diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 8adfbd4880..cf55146376 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -29,6 +29,9 @@ #include "constants/abilities.h" #include "constants/item_effects.h" #include "constants/songs.h" +#include "test/battle.h" +#include "test/test.h" +#include "test/test_runner_battle.h" #include "pokemon_animation.h" static EWRAM_DATA u8 sLinkSendTaskId = 0; @@ -144,6 +147,7 @@ static void InitBtlControllersInternal(void) if ((gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) || !isMulti + || (IsMultibattleTest()) || (!isLink && !isRecorded) || (isLink && !isDouble)) { @@ -202,7 +206,7 @@ static void InitBtlControllersInternal(void) // Opponent 1 bool32 isOpponent1Recorded; if (isDouble) - isOpponent1Recorded = (!isInGamePartner && isRecorded && !isMulti && isRecordedLink); + isOpponent1Recorded = ((!isInGamePartner && isRecorded && !isMulti && isRecordedLink) || (IsMultibattleTest() && isRecordedLink)); else isOpponent1Recorded = isRecorded && isRecordedLink; @@ -212,17 +216,35 @@ static void InitBtlControllersInternal(void) gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_1)] = SetControllerToOpponent; // Player 2 - if (isInGamePartner) + if (IsMultibattleTest() && isRecordedLink) + { + gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_2)] = SetControllerToRecordedPartner; + } + else if (IsMultibattleTest() && isRecorded && !isRecordedLink) + { // Sets to PlayerPartner if EXPECT_XXXX used in test for partner trainer, else sets to RecordedPartner. + if (gBattleTestRunnerState->data.expectedAiActions[B_BATTLER_2][0].actionSet == TRUE) + gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_2)] = SetControllerToPlayerPartner; + else + gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_2)] = SetControllerToRecordedPartner; + } + else if ((isInGamePartner && !isRecorded) + || isAIvsAI) + { gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_2)] = SetControllerToPlayerPartner; + } else if (isRecorded) + { gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_2)] = SetControllerToRecordedPlayer; - else if (isAIvsAI) - gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_2)] = SetControllerToPlayerPartner; + } else + { gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_2)] = SetControllerToPlayer; + } // Opponent 2 - if (isInGamePartner || !isRecorded || isMulti || !isRecordedLink) + if (IsMultibattleTest() && isRecordedLink) + gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_3)] = SetControllerToRecordedOpponent; + else if (isInGamePartner || !isRecorded || isMulti || !isRecordedLink) gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_3)] = SetControllerToOpponent; else gBattlerControllerFuncs[GetBattlerPosition(B_BATTLER_3)] = SetControllerToRecordedOpponent; @@ -318,6 +340,11 @@ static inline bool32 IsControllerRecordedPlayer(u32 battler) return (gBattlerControllerEndFuncs[battler] == RecordedPlayerBufferExecCompleted); } +static inline bool32 IsControllerRecordedPartner(u32 battler) +{ + return (gBattlerControllerEndFuncs[battler] == RecordedPartnerBufferExecCompleted); +} + static inline bool32 IsControllerOpponent(u32 battler) { return (gBattlerControllerEndFuncs[battler] == OpponentBufferExecCompleted); @@ -2249,6 +2276,7 @@ void BtlController_HandleSwitchInAnim(u32 battler) bool32 isPlayerSide = (IsControllerPlayer(battler) || IsControllerPlayerPartner(battler) || IsControllerRecordedPlayer(battler) + || IsControllerRecordedPartner(battler) || IsControllerLinkPartner(battler)); if (IsControllerPlayer(battler)) @@ -2541,6 +2569,7 @@ void BtlController_HandleHealthBarUpdate(u32 battler) SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], maxHP, 0, hpVal); if (IsControllerPlayer(battler) || IsControllerRecordedPlayer(battler) + || IsControllerRecordedPartner(battler) || IsControllerWally(battler)) UpdateHpTextInHealthbox(gHealthboxSpriteIds[battler], HP_CURRENT, 0, maxHP); TestRunner_Battle_RecordHP(battler, curHP, 0); diff --git a/src/battle_main.c b/src/battle_main.c index 382c846bb5..ba7dfa137f 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -53,6 +53,7 @@ #include "string_util.h" #include "strings.h" #include "task.h" +#include "test/battle.h" #include "test_runner.h" #include "text.h" #include "trainer_pools.h" @@ -75,6 +76,7 @@ #include "constants/trainers.h" #include "constants/weather.h" #include "cable_club.h" +#include "test/test_runner_battle.h" extern const struct BgTemplate gBattleBgTemplates[]; extern const struct WindowTemplate *const gBattleWindowTemplates[]; @@ -545,10 +547,10 @@ static void CB2_InitBattleInternal(void) gReservedSpritePaletteCount = MAX_BATTLERS_COUNT; SetVBlankCallback(VBlankCB_Battle); SetUpBattleVarsAndBirchZigzagoon(); - - if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) - SetMainCallback2(CB2_HandleStartMultiPartnerBattle); - else if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) + + if ((IsMultibattleTest() && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) + || (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + || (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER)) SetMainCallback2(CB2_HandleStartMultiPartnerBattle); else if (gBattleTypeFlags & BATTLE_TYPE_MULTI) SetMainCallback2(CB2_HandleStartMultiBattle); diff --git a/src/battle_message.c b/src/battle_message.c index 087c436d91..3e10ec6227 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -108,6 +108,7 @@ static const u8 sText_PkmnComeBack[] = _("{B_BUFF1}, come back!"); static const u8 sText_PkmnOkComeBack[] = _("OK, {B_BUFF1}! Come back!"); static const u8 sText_PkmnGoodComeBack[] = _("Good job, {B_BUFF1}! Come back!"); static const u8 sText_Trainer1WithdrewPkmn[] = _("{B_TRAINER1_NAME_WITH_CLASS} withdrew {B_BUFF1}!"); +static const u8 sText_Trainer2WithdrewPkmn[] = _("{B_TRAINER2_NAME_WITH_CLASS} withdrew {B_BUFF1}!"); static const u8 sText_LinkTrainer1WithdrewPkmn[] = _("{B_LINK_OPPONENT1_NAME} withdrew {B_BUFF1}!"); static const u8 sText_LinkTrainer2WithdrewPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} withdrew {B_BUFF1}!"); static const u8 sText_WildPkmnPrefix[] = _("The wild "); @@ -1443,6 +1444,8 @@ static const u8 sText_TwoTrainersSentPkmn[] = _("{B_TRAINER1_NAME_WITH_CLASS} se static const u8 sText_Trainer2SentOutPkmn[] = _("{B_TRAINER2_NAME_WITH_CLASS} sent out {B_BUFF1}!"); static const u8 sText_TwoTrainersWantToBattle[] = _("You are challenged by {B_TRAINER1_NAME_WITH_CLASS} and {B_TRAINER2_NAME_WITH_CLASS}!\p"); static const u8 sText_InGamePartnerSentOutZGoN[] = _("{B_PARTNER_NAME_WITH_CLASS} sent out {B_PLAYER_MON2_NAME}! Go, {B_PLAYER_MON1_NAME}!"); +static const u8 sText_InGamePartnerSentOutPkmn2[] = _("{B_PARTNER_NAME_WITH_CLASS} sent out {B_PLAYER_MON2_NAME}!"); +static const u8 sText_InGamePartnerWithdrewPkmn2[] = _("{B_PARTNER_NAME_WITH_CLASS} withdrew {B_PLAYER_MON2_NAME}!"); const u16 gBattlePalaceFlavorTextTable[] = { @@ -2065,9 +2068,31 @@ void BufferStringBattle(enum StringID stringID, u32 battler) else if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { if (gBattleTypeFlags & BATTLE_TYPE_RECORDED) - stringPtr = sText_TwoLinkTrainersWantToBattlePause; + { + if (TESTING && gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if (!(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)) + stringPtr = sText_Trainer1WantsToBattle; + else + stringPtr = sText_TwoTrainersWantToBattle; + } + else if (TESTING && gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + { + stringPtr = sText_TwoTrainersWantToBattle; + } + else if (!(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)) + { + stringPtr = sText_LinkTrainerWantsToBattlePause; + } + else + { + stringPtr = sText_TwoLinkTrainersWantToBattlePause; + } + } else + { stringPtr = sText_TwoLinkTrainersWantToBattle; + } } else { @@ -2153,7 +2178,9 @@ void BufferStringBattle(enum StringID stringID, u32 battler) case STRINGID_RETURNMON: // sending poke to ball msg if (IsOnPlayerSide(battler)) { - if (*(&gBattleStruct->hpScale) == 0) + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && GetBattlerAtPosition(battler) == 2) + stringPtr = sText_InGamePartnerWithdrewPkmn2; + else if (*(&gBattleStruct->hpScale) == 0) stringPtr = sText_PkmnThatsEnough; else if (*(&gBattleStruct->hpScale) == 1 || IsDoubleBattle()) stringPtr = sText_PkmnComeBack; @@ -2173,14 +2200,27 @@ void BufferStringBattle(enum StringID stringID, u32 battler) } else { - stringPtr = sText_Trainer1WithdrewPkmn; + if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + { + if (GetBattlerAtPosition(battler) == 1) + stringPtr = sText_Trainer1WithdrewPkmn; + else + stringPtr = sText_Trainer2WithdrewPkmn; + + } + else + { + stringPtr = sText_Trainer1WithdrewPkmn; + } } } break; case STRINGID_SWITCHINMON: // switch-in msg if (IsOnPlayerSide(gBattleScripting.battler)) { - if (*(&gBattleStruct->hpScale) == 0 || IsDoubleBattle()) + if ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) && (GetBattlerAtPosition(gBattleScripting.battler) == 2)) + stringPtr = sText_InGamePartnerSentOutPkmn2; + else if (*(&gBattleStruct->hpScale) == 0 || IsDoubleBattle()) stringPtr = sText_GoPkmn2; else if (*(&gBattleStruct->hpScale) == 1) stringPtr = sText_DoItPkmn; @@ -2202,12 +2242,39 @@ void BufferStringBattle(enum StringID stringID, u32 battler) } else { - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + if (TESTING && gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if (gBattleScripting.battler == 1) + { + stringPtr = sText_Trainer1SentOutPkmn; + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + stringPtr = sText_Trainer2SentOutPkmn; + else + stringPtr = sText_Trainer1SentOutPkmn2; + } + } + else if (TESTING && gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + { + if (gBattleScripting.battler == 1) + stringPtr = sText_Trainer1SentOutPkmn; + else + stringPtr = sText_Trainer2SentOutPkmn; + } + else if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { stringPtr = sText_LinkTrainerMultiSentOutPkmn; + } else if (TRAINER_BATTLE_PARAM.opponentA == TRAINER_UNION_ROOM) + { stringPtr = sText_Trainer1SentOutPkmn2; + } else + { stringPtr = sText_LinkTrainerSentOutPkmn2; + } } } else diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index 1e72e2e339..084b37dc2d 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -67,8 +67,10 @@ #include "constants/pokemon.h" #include "config/battle.h" #include "data/battle_move_effects.h" +#include "test/battle.h" #include "follower_npc.h" #include "load_save.h" +#include "test/test_runner_battle.h" // table to avoid ugly powing on gba (courtesy of doesnt) // this returns (i^2.5)/4 @@ -4831,16 +4833,14 @@ bool32 NoAliveMonsForPlayer(void) { HP_count += GetMonData(&gPlayerParty[i], MON_DATA_HP); } - // Get the number of fainted mons or eggs (not empty slots) in the first three party slots. if (i < 3 && ((GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) && !GetMonData(&gPlayerParty[i], MON_DATA_HP)) || GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))) ineligibleMonsCount++; } - // Get the number of inelligible slots in the saved player party. if (B_MULTI_BATTLE_WHITEOUT > GEN_3 && gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_INGAME_PARTNER) - && !(gBattleTypeFlags & BATTLE_TYPE_ARENA)) + && !(gBattleTypeFlags & BATTLE_TYPE_ARENA) && !(IsMultibattleTest())) // Multibattle tests appear to not save the player party data for the check below. { for (i = 0; i < PARTY_SIZE; i++) { @@ -4893,7 +4893,6 @@ static void Cmd_checkteamslost(void) if (NoAliveMonsForPlayer()) gBattleOutcome |= B_OUTCOME_LOST; - if (NoAliveMonsForOpponent()) gBattleOutcome |= B_OUTCOME_WON; diff --git a/src/battle_tower.c b/src/battle_tower.c index 3cf63ba080..f925826a6f 100644 --- a/src/battle_tower.c +++ b/src/battle_tower.c @@ -40,6 +40,8 @@ #include "constants/trainers.h" #include "constants/event_objects.h" #include "constants/moves.h" +#include "test/battle.h" +#include "test/test_runner_battle.h" // EWRAM vars. EWRAM_DATA const struct BattleFrontierTrainer *gFacilityTrainers = NULL; @@ -3557,18 +3559,20 @@ bool32 ValidateBattleTowerRecord(u8 recordId) // unused void TrySetLinkBattleTowerEnemyPartyLevel(void) { - if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK)) + if (!IsMultibattleTest()) { - s32 i; - u8 enemyLevel = SetFacilityPtrsGetLevel(); - - for (i = 0; i < PARTY_SIZE; i++) + if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK)) { - u32 species = GetMonData(&gEnemyParty[i], MON_DATA_SPECIES, NULL); - if (species) + u8 enemyLevel = SetFacilityPtrsGetLevel(); + + for (u32 i = 0; i < PARTY_SIZE; i++) { - SetMonData(&gEnemyParty[i], MON_DATA_EXP, &gExperienceTables[gSpeciesInfo[species].growthRate][enemyLevel]); - CalculateMonStats(&gEnemyParty[i]); + u32 species = GetMonData(&gEnemyParty[i], MON_DATA_SPECIES, NULL); + if (species) + { + SetMonData(&gEnemyParty[i], MON_DATA_EXP, &gExperienceTables[gSpeciesInfo[species].growthRate][enemyLevel]); + CalculateMonStats(&gEnemyParty[i]); + } } } } diff --git a/src/recorded_battle.c b/src/recorded_battle.c index 10db58a53c..5b61a8b4dd 100644 --- a/src/recorded_battle.c +++ b/src/recorded_battle.c @@ -49,7 +49,7 @@ EWRAM_DATA static u8 sFrontierPassFlag = 0; EWRAM_DATA static u8 sBattleScene = 0; EWRAM_DATA static u8 sTextSpeed = 0; EWRAM_DATA static u32 sBattleFlags = 0; -EWRAM_DATA static u64 sAI_Scripts = 0; +EWRAM_DATA static u64 sAI_Scripts[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA static struct Pokemon sSavedPlayerParty[PARTY_SIZE] = {0}; EWRAM_DATA static struct Pokemon sSavedOpponentParty[PARTY_SIZE] = {0}; EWRAM_DATA static u16 sPlayerMonMoves[MAX_BATTLERS_COUNT / 2][MAX_MON_MOVES] = {0}; @@ -87,7 +87,7 @@ void RecordedBattle_Init(u8 mode) for (j = 0; j < BATTLER_RECORD_SIZE; j++) sBattleRecords[i][j] = 0xFF; sBattleFlags = gBattleTypeFlags; - sAI_Scripts = gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT]; + sAI_Scripts[i] = gAiThinkingStruct->aiFlags[i]; } } } @@ -312,6 +312,7 @@ bool32 MoveRecordedBattleToSaveData(void) battleSave->playersLanguage[i] = sPlayers[i].language; battleSave->playersBattlers[i] = sPlayers[i].battler; battleSave->playersTrainerId[i] = sPlayers[i].trainerId; + battleSave->AI_scripts[i] = sAI_Scripts[i]; } battleSave->rngSeed = gRecordedBattleRngSeed; @@ -358,7 +359,6 @@ bool32 MoveRecordedBattleToSaveData(void) battleSave->frontierBrainSymbol = sFrontierBrainSymbol; battleSave->battleScene = gSaveBlock2Ptr->optionsBattleSceneOff; battleSave->textSpeed = gSaveBlock2Ptr->optionsTextSpeed; - battleSave->AI_scripts = sAI_Scripts; if (TRAINER_BATTLE_PARAM.opponentA >= TRAINER_RECORD_MIXING_FRIEND && TRAINER_BATTLE_PARAM.opponentA < TRAINER_RECORD_MIXING_APPRENTICE) { @@ -523,6 +523,7 @@ void SetVariablesForRecordedBattle(struct RecordedBattleSave *src) gLinkPlayers[i].language = src->playersLanguage[i]; gLinkPlayers[i].id = src->playersBattlers[i]; gLinkPlayers[i].trainerId = src->playersTrainerId[i]; + sAI_Scripts[i] = src->AI_scripts[i]; if (var) ConvertInternationalString(gLinkPlayers[i].name, gLinkPlayers[i].language); @@ -539,7 +540,6 @@ void SetVariablesForRecordedBattle(struct RecordedBattleSave *src) sFrontierBrainSymbol = src->frontierBrainSymbol; sBattleScene = src->battleScene; sTextSpeed = src->textSpeed; - sAI_Scripts = src->AI_scripts; for (i = 0; i < PLAYER_NAME_LENGTH + 1; i++) sRecordMixFriendName[i] = src->recordMixFriendName[i]; @@ -786,9 +786,9 @@ void RecordedBattle_CheckMovesetChanges(u8 mode) } } -u64 GetAiScriptsInRecordedBattle(void) +u64 GetAiScriptsInRecordedBattle(u32 battler) { - return sAI_Scripts; + return sAI_Scripts[battler]; } // Used to determine when the player is allowed to press B to end a recorded battle's playback diff --git a/test/battle/ai/ai_doubles.c b/test/battle/ai/ai_doubles.c index 1ffd901810..82e8d9537a 100644 --- a/test/battle/ai/ai_doubles.c +++ b/test/battle/ai/ai_doubles.c @@ -338,7 +338,7 @@ AI_DOUBLE_BATTLE_TEST("AI will trigger its ally's Weakness Policy") } } -AI_DOUBLE_BATTLE_TEST("AI will only explode and kill everything on the field with Risky or Will Suicide") +AI_DOUBLE_BATTLE_TEST("AI will only explode and kill everything on the field with Risky or Will Suicide (doubles)") { ASSUME(GetMoveTarget(MOVE_EXPLOSION) == MOVE_TARGET_FOES_AND_ALLY); ASSUME(GetMoveEffect(MOVE_EXPLOSION) == EFFECT_EXPLOSION); @@ -363,6 +363,36 @@ AI_DOUBLE_BATTLE_TEST("AI will only explode and kill everything on the field wit } } +AI_DOUBLE_BATTLE_TEST("Battler 3 has Battler 1 AI flags set correctly (doubles)") +{ + ASSUME(GetMoveTarget(MOVE_EXPLOSION) == MOVE_TARGET_FOES_AND_ALLY); + ASSUME(GetMoveEffect(MOVE_EXPLOSION) == EFFECT_EXPLOSION); + + u32 aiFlags; + u32 battler; + + PARAMETRIZE { aiFlags = 0; battler = 1; } + PARAMETRIZE { aiFlags = 0; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 3; } + + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT); + BATTLER_AI_FLAGS(battler, aiFlags); + PLAYER(SPECIES_WOBBUFFET) { HP(1); } + PLAYER(SPECIES_WOBBUFFET) { HP(1); } + OPPONENT(SPECIES_VOLTORB) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + OPPONENT(SPECIES_ELECTRODE) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + } WHEN { + if (aiFlags == 0 || battler == 3) + TURN { EXPECT_MOVE(opponentLeft, MOVE_ELECTRO_BALL, target: playerLeft); EXPECT_MOVE(opponentRight, MOVE_ELECTRO_BALL, target: playerLeft); } + else + TURN { EXPECT_MOVE(opponentLeft, MOVE_EXPLOSION, target: playerLeft); EXPECT_MOVE(opponentRight, MOVE_EXPLOSION); } + } +} + AI_DOUBLE_BATTLE_TEST("AI sees corresponding absorbing abilities on partners") { ASSUME(GetMoveTarget(MOVE_DISCHARGE) == MOVE_TARGET_FOES_AND_ALLY); diff --git a/test/battle/ai/ai_multi.c b/test/battle/ai/ai_multi.c new file mode 100644 index 0000000000..ddbfdb49b0 --- /dev/null +++ b/test/battle/ai/ai_multi.c @@ -0,0 +1,127 @@ +#include "global.h" +#include "test/battle.h" +#include "battle_ai_util.h" + +AI_MULTI_BATTLE_TEST("AI will only explode and kill everything on the field with Risky or Will Suicide (multi)") +{ + ASSUME(GetMoveTarget(MOVE_EXPLOSION) == MOVE_TARGET_FOES_AND_ALLY); + ASSUME(GetMoveEffect(MOVE_EXPLOSION) == EFFECT_EXPLOSION); + + u32 aiFlags; + u32 battler; + + PARAMETRIZE { aiFlags = 0; battler = 1; } + PARAMETRIZE { aiFlags = 0; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 3; } + + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT); + BATTLER_AI_FLAGS(battler, aiFlags); + MULTI_PLAYER(SPECIES_WOBBUFFET) { HP(1); } + MULTI_PARTNER(SPECIES_WOBBUFFET) { HP(1); } + MULTI_OPPONENT_A(SPECIES_ELECTRODE) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + MULTI_OPPONENT_B(SPECIES_VOLTORB) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + } WHEN { + if (aiFlags == 0) + TURN { EXPECT_MOVE(opponentLeft, MOVE_ELECTRO_BALL, target: playerLeft); EXPECT_MOVE(opponentRight, MOVE_ELECTRO_BALL, target: playerLeft); } + else + TURN { EXPECT_MOVE(&gBattleMons[BATTLE_PARTNER(battler)], MOVE_ELECTRO_BALL, target: playerLeft); EXPECT_MOVE(&gBattleMons[battler], MOVE_EXPLOSION); } + } +} + +AI_ONE_VS_TWO_BATTLE_TEST("AI will only explode and kill everything on the field with Risky or Will Suicide (1v2)") +{ + ASSUME(GetMoveTarget(MOVE_EXPLOSION) == MOVE_TARGET_FOES_AND_ALLY); + ASSUME(GetMoveEffect(MOVE_EXPLOSION) == EFFECT_EXPLOSION); + + u32 aiFlags; + u32 battler; + + PARAMETRIZE { aiFlags = 0; battler = 1; } + PARAMETRIZE { aiFlags = 0; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 3; } + + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT); + BATTLER_AI_FLAGS(battler, aiFlags); + MULTI_PLAYER(SPECIES_WOBBUFFET) { HP(1); } + MULTI_PLAYER(SPECIES_WOBBUFFET) { HP(1); } + MULTI_OPPONENT_A(SPECIES_ELECTRODE) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + MULTI_OPPONENT_B(SPECIES_VOLTORB) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + } WHEN { + if (aiFlags == 0) + TURN { EXPECT_MOVE(opponentLeft, MOVE_ELECTRO_BALL, target: playerLeft); EXPECT_MOVE(opponentRight, MOVE_ELECTRO_BALL, target: playerLeft); } + else + TURN { EXPECT_MOVE(&gBattleMons[BATTLE_PARTNER(battler)], MOVE_ELECTRO_BALL, target: playerLeft); EXPECT_MOVE(&gBattleMons[battler], MOVE_EXPLOSION); } + } +} + +// Used to test EXPECT_MOVE only on partner +AI_MULTI_BATTLE_TEST("AI partner makes sensible move selections in battle (multi)") +{ + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT); + MULTI_PLAYER(SPECIES_HAUNTER); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL, MOVE_AURA_SPHERE); } + MULTI_OPPONENT_A(SPECIES_RATTATA) { Moves(MOVE_CELEBRATE); HP(1); } + MULTI_OPPONENT_B(SPECIES_KANGASKHAN) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { MOVE(playerLeft, MOVE_AURA_SPHERE, target:opponentRight); EXPECT_MOVE(playerRight, MOVE_AURA_SPHERE, target:opponentLeft); }; + } +} + +// Used to test EXPECT_MOVE only on partner +AI_TWO_VS_ONE_BATTLE_TEST("AI partner makes sensible move selections in battle (2v1)") +{ + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT); + MULTI_PLAYER(SPECIES_HAUNTER); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL, MOVE_AURA_SPHERE); } + MULTI_OPPONENT_A(SPECIES_RATTATA) { Moves(MOVE_CELEBRATE); HP(1); } + MULTI_OPPONENT_A(SPECIES_KANGASKHAN) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { MOVE(playerLeft, MOVE_AURA_SPHERE, target:opponentRight); EXPECT_MOVE(playerRight, MOVE_AURA_SPHERE, target:opponentLeft); }; + } +} + +AI_TWO_VS_ONE_BATTLE_TEST("Battler 3 has Battler 1 AI flags set correctly (2v1)") +{ + ASSUME(GetMoveTarget(MOVE_EXPLOSION) == MOVE_TARGET_FOES_AND_ALLY); + ASSUME(GetMoveEffect(MOVE_EXPLOSION) == EFFECT_EXPLOSION); + + u32 aiFlags; + u32 battler; + + PARAMETRIZE { aiFlags = 0; battler = 1; } + PARAMETRIZE { aiFlags = 0; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_RISKY; battler = 3; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 1; } + PARAMETRIZE { aiFlags = AI_FLAG_WILL_SUICIDE; battler = 3; } + + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT); + BATTLER_AI_FLAGS(battler, aiFlags); + MULTI_PLAYER(SPECIES_WOBBUFFET) { HP(1); } + MULTI_PARTNER(SPECIES_WOBBUFFET) { HP(1); } + MULTI_OPPONENT_A(SPECIES_VOLTORB) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + MULTI_OPPONENT_A(SPECIES_ELECTRODE) { Moves(MOVE_EXPLOSION, MOVE_ELECTRO_BALL); HP(1); } + } WHEN { + if (aiFlags == 0 || battler == 3) + TURN { EXPECT_MOVE(opponentLeft, MOVE_ELECTRO_BALL, target: playerLeft); EXPECT_MOVE(opponentRight, MOVE_ELECTRO_BALL, target: playerLeft); } + else + TURN { EXPECT_MOVE(opponentLeft, MOVE_EXPLOSION, target: playerLeft); EXPECT_MOVE(opponentRight, MOVE_EXPLOSION); } + } +} diff --git a/test/battle/ai/ai_switching.c b/test/battle/ai/ai_switching.c index 1e10b7fc1c..f3c8cb6103 100644 --- a/test/battle/ai/ai_switching.c +++ b/test/battle/ai/ai_switching.c @@ -91,6 +91,250 @@ AI_DOUBLE_BATTLE_TEST("AI will not try to switch for the same Pokémon for 2 spo } } +// Used to test EXPECT_SWITCH only on partner +AI_MULTI_BATTLE_TEST("AI partner will not switch mid-turn into a player Pokémon (multi)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_HAUNTER); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL); } + MULTI_PARTNER(SPECIES_GASTLY) { Moves(MOVE_LICK); } + MULTI_PARTNER(SPECIES_RATICATE) { Moves(MOVE_HEADBUTT); } + MULTI_OPPONENT_A(SPECIES_RATTATA) { Moves(MOVE_CELEBRATE); } + MULTI_OPPONENT_B(SPECIES_KANGASKHAN) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { EXPECT_SWITCH(playerRight, 5); }; + } SCENE { + MESSAGE(AI_PARTNER_NAME " withdrew Gengar!"); + MESSAGE(AI_PARTNER_NAME " sent out Raticate!"); + NONE_OF { + MESSAGE(AI_PARTNER_NAME " withdrew Gengar!"); + MESSAGE(AI_PARTNER_NAME " sent out Rattata!"); + } + } +} + +// Used to test EXPECT_SWITCH only on partner +AI_TWO_VS_ONE_BATTLE_TEST("AI partner will not switch mid-turn into a player Pokémon (2v1)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_HAUNTER); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL); } + MULTI_PARTNER(SPECIES_GASTLY) { Moves(MOVE_LICK); } + MULTI_PARTNER(SPECIES_RATICATE) { Moves(MOVE_HEADBUTT); } + MULTI_OPPONENT_A(SPECIES_RATTATA) { Moves(MOVE_CELEBRATE); } + MULTI_OPPONENT_A(SPECIES_KANGASKHAN) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { EXPECT_SWITCH(playerRight, 5); }; + } SCENE { + MESSAGE(AI_PARTNER_NAME " withdrew Gengar!"); + MESSAGE(AI_PARTNER_NAME " sent out Raticate!"); + NONE_OF { + MESSAGE(AI_PARTNER_NAME " withdrew Gengar!"); + MESSAGE(AI_PARTNER_NAME " sent out Rattata!"); + } + } +} + +// Used to test EXPECT_SEND_OUT only on partner +AI_MULTI_BATTLE_TEST("AI partner will not switch into a player Pokémon after fainting (multi)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_GENGAR); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_WOBBUFFET) { Status1(STATUS1_BURN); HP(1); } + MULTI_PARTNER(SPECIES_GASTLY); + MULTI_PARTNER(SPECIES_HAUNTER); + MULTI_OPPONENT_A(SPECIES_TRAPINCH) { Ability(ABILITY_ARENA_TRAP); Moves(MOVE_CELEBRATE); } + MULTI_OPPONENT_B(SPECIES_VIBRAVA) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { EXPECT_MOVE(playerRight, MOVE_CELEBRATE); EXPECT_SEND_OUT(playerRight, 5); }; + } SCENE { + MESSAGE(AI_PARTNER_NAME " sent out Haunter!"); + NONE_OF { + MESSAGE(AI_PARTNER_NAME " sent out Rattata!"); + } + } +} + +// Used to test EXPECT_SEND_OUT only on partner +AI_TWO_VS_ONE_BATTLE_TEST("AI partner will not switch into a player Pokémon after fainting (2v1)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_GENGAR); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_WOBBUFFET) { Status1(STATUS1_BURN); HP(1); } + MULTI_PARTNER(SPECIES_GASTLY); + MULTI_PARTNER(SPECIES_HAUNTER); + MULTI_OPPONENT_A(SPECIES_TRAPINCH) { Ability(ABILITY_ARENA_TRAP); Moves(MOVE_CELEBRATE); } + MULTI_OPPONENT_A(SPECIES_VIBRAVA) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { EXPECT_MOVE(playerRight, MOVE_CELEBRATE); EXPECT_SEND_OUT(playerRight, 5); }; + } SCENE { + MESSAGE(AI_PARTNER_NAME " sent out Haunter!"); + NONE_OF { + MESSAGE(AI_PARTNER_NAME " sent out Rattata!"); + } + } +} + +// Used to test EXPECT_SWITCH, EXPECT_SEND_OUT, and EXPECT_MOVE on partner +AI_MULTI_BATTLE_TEST("AI partner will not switch into a player Pokémon (multi)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_HAUNTER); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL); } + MULTI_PARTNER(SPECIES_RATICATE) { Moves(MOVE_HEADBUTT); HP(1); } + MULTI_OPPONENT_A(SPECIES_RATTATA) { Moves(MOVE_CELEBRATE); } + MULTI_OPPONENT_B(SPECIES_KANGASKHAN) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { MOVE(playerLeft, MOVE_AURA_SPHERE, target:playerRight); EXPECT_SWITCH(playerRight, 4); EXPECT_SEND_OUT(playerRight, 3); }; + TURN { EXPECT_MOVE(playerRight, MOVE_SHADOW_BALL, target:opponentLeft); }; + } SCENE { + MESSAGE(AI_PARTNER_NAME " sent out Raticate!"); + NONE_OF { + MESSAGE(AI_PARTNER_NAME " sent out Rattata!"); + } + } +} + +// Used to test EXPECT_SWITCH, EXPECT_SEND_OUT, and EXPECT_MOVE on partner +AI_TWO_VS_ONE_BATTLE_TEST("AI partner will not switch into a player Pokémon (2v1)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_HAUNTER); + MULTI_PLAYER(SPECIES_RATTATA); + // No moves to damage opponents. + MULTI_PARTNER(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL); } + MULTI_PARTNER(SPECIES_RATICATE) { Moves(MOVE_HEADBUTT); HP(1); } + MULTI_OPPONENT_A(SPECIES_RATTATA) { Moves(MOVE_CELEBRATE); } + MULTI_OPPONENT_A(SPECIES_KANGASKHAN) { Moves(MOVE_CELEBRATE); } + + } WHEN { + TURN { MOVE(playerLeft, MOVE_AURA_SPHERE, target:playerRight); EXPECT_SWITCH(playerRight, 4); EXPECT_SEND_OUT(playerRight, 3); }; + TURN { EXPECT_MOVE(playerRight, MOVE_SHADOW_BALL, target:opponentLeft); }; + } SCENE { + MESSAGE(AI_PARTNER_NAME " sent out Raticate!"); + NONE_OF { + MESSAGE(AI_PARTNER_NAME " sent out Rattata!"); + } + } +} + +AI_TWO_VS_ONE_BATTLE_TEST("AI will not try to switch for the same pokemon for 2 spots in a 2v1 battle (all bad moves)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_RATTATA); + MULTI_PLAYER(SPECIES_RATTATA); + MULTI_PARTNER(SPECIES_KANGASKHAN); + // No moves to damage player. + MULTI_OPPONENT_A(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL); } + MULTI_OPPONENT_A(SPECIES_HAUNTER) { Moves(MOVE_SHADOW_BALL); } + MULTI_OPPONENT_A(SPECIES_GASTLY) { Moves(MOVE_LICK); } + MULTI_OPPONENT_A(SPECIES_RATICATE) { Moves(MOVE_HEADBUTT); } + } WHEN { + TURN { EXPECT_SWITCH(opponentLeft, 3); }; + } SCENE { + MESSAGE(AI_TRAINER_NAME " withdrew Gengar!"); + MESSAGE(AI_TRAINER_NAME " sent out Raticate!"); + NONE_OF { + MESSAGE(AI_TRAINER_NAME " withdrew Haunter!"); + MESSAGE(AI_TRAINER_NAME " sent out Raticate!"); + } + } +} + +AI_ONE_VS_TWO_BATTLE_TEST("AI will not switch into a partner Pokémon in a 1v2 battle (all bad moves)") +{ + u32 flags; + + PARAMETRIZE {flags = AI_FLAG_SMART_SWITCHING; } + PARAMETRIZE {flags = 0; } + + PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); + GIVEN { + AI_FLAGS(AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT | flags); + MULTI_PLAYER(SPECIES_RATTATA); + MULTI_PLAYER(SPECIES_KANGASKHAN); + // No moves to damage player. + MULTI_OPPONENT_A(SPECIES_HAUNTER) { Moves(MOVE_SHADOW_BALL); } + MULTI_OPPONENT_B(SPECIES_GENGAR) { Moves(MOVE_SHADOW_BALL); } + MULTI_OPPONENT_B(SPECIES_GASTLY) { Moves(MOVE_LICK); } + MULTI_OPPONENT_B(SPECIES_RATICATE) { Moves(MOVE_HEADBUTT); } + + } WHEN { + TURN { EXPECT_SWITCH(opponentRight, 5); }; + } SCENE { + MESSAGE(AI_TRAINER_2_NAME " withdrew Gengar!"); + MESSAGE(AI_TRAINER_2_NAME " sent out Raticate!"); + NONE_OF { + MESSAGE(AI_TRAINER_NAME " withdrew Haunter!"); + MESSAGE(AI_TRAINER_NAME " sent out Raticate!"); + } + } +} + AI_SINGLE_BATTLE_TEST("AI will switch out if it has no move that affects the player") { PASSES_RANDOMLY(SHOULD_SWITCH_ALL_MOVES_BAD_PERCENTAGE, 100, RNG_AI_SWITCH_ALL_MOVES_BAD); diff --git a/test/battle/damage_formula.c b/test/battle/damage_formula.c index 4a7e4ec1ef..702feaa837 100644 --- a/test/battle/damage_formula.c +++ b/test/battle/damage_formula.c @@ -118,7 +118,7 @@ SINGLE_BATTLE_TEST("Damage calculation matches Gen5+ (Marshadow vs Mawile)") } } -DOUBLE_BATTLE_TEST("A spread move will do correct damage to the second mon if the first target faints from first hit of the spread move") +DOUBLE_BATTLE_TEST("A spread move will do correct damage to the second mon if the first target faints from first hit of the spread move (double battle)") { s16 damage[6]; GIVEN { @@ -152,6 +152,108 @@ DOUBLE_BATTLE_TEST("A spread move will do correct damage to the second mon if th } } +MULTI_BATTLE_TEST("A spread move will do correct damage to the second mon if the first target faints from first hit of the spread move (multibattle)") +{ + s16 damage[6]; + GIVEN { + MULTI_PLAYER(SPECIES_REGIROCK); + MULTI_PARTNER(SPECIES_REGIROCK); + MULTI_OPPONENT_A(SPECIES_WOBBUFFET) { HP(200); } + MULTI_OPPONENT_B(SPECIES_WOBBUFFET); + } WHEN { + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); } + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); MOVE(playerRight, MOVE_ROCK_SLIDE); } + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); } + } SCENE { + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentLeft, captureDamage: &damage[0]); + HP_BAR(opponentRight, captureDamage: &damage[1]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentLeft, captureDamage: &damage[2]); + HP_BAR(opponentRight, captureDamage: &damage[3]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerRight); + HP_BAR(opponentRight, captureDamage: &damage[4]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentRight, captureDamage: &damage[5]); + } THEN { + EXPECT_EQ(damage[0], damage[1]); + EXPECT_EQ(damage[1], damage[3]); + EXPECT_MUL_EQ(damage[5], UQ_4_12(0.75), damage[3]); + EXPECT_EQ(damage[4], damage[5]); + } +} + +TWO_VS_ONE_BATTLE_TEST("A spread move will do correct damage to the second mon if the first target faints from first hit of the spread move (2v1)") +{ + s16 damage[6]; + GIVEN { + MULTI_PLAYER(SPECIES_REGIROCK); + MULTI_PARTNER(SPECIES_REGIROCK); + MULTI_OPPONENT_A(SPECIES_WOBBUFFET) { HP(200); } + MULTI_OPPONENT_A(SPECIES_WOBBUFFET); + } WHEN { + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); } + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); MOVE(playerRight, MOVE_ROCK_SLIDE); } + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); } + } SCENE { + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentLeft, captureDamage: &damage[0]); + HP_BAR(opponentRight, captureDamage: &damage[1]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentLeft, captureDamage: &damage[2]); + HP_BAR(opponentRight, captureDamage: &damage[3]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerRight); + HP_BAR(opponentRight, captureDamage: &damage[4]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentRight, captureDamage: &damage[5]); + } THEN { + EXPECT_EQ(damage[0], damage[1]); + EXPECT_EQ(damage[1], damage[3]); + EXPECT_MUL_EQ(damage[5], UQ_4_12(0.75), damage[3]); + EXPECT_EQ(damage[4], damage[5]); + } +} + +ONE_VS_TWO_BATTLE_TEST("A spread move will do correct damage to the second mon if the first target faints from first hit of the spread move (1v2)") +{ + s16 damage[6]; + GIVEN { + MULTI_PLAYER(SPECIES_REGIROCK); + MULTI_PLAYER(SPECIES_REGIROCK); + MULTI_OPPONENT_A(SPECIES_WOBBUFFET) { HP(200); } + MULTI_OPPONENT_B(SPECIES_WOBBUFFET); + } WHEN { + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); } + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); MOVE(playerRight, MOVE_ROCK_SLIDE); } + TURN { MOVE(playerLeft, MOVE_ROCK_SLIDE); } + } SCENE { + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentLeft, captureDamage: &damage[0]); + HP_BAR(opponentRight, captureDamage: &damage[1]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentLeft, captureDamage: &damage[2]); + HP_BAR(opponentRight, captureDamage: &damage[3]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerRight); + HP_BAR(opponentRight, captureDamage: &damage[4]); + + ANIMATION(ANIM_TYPE_MOVE, MOVE_ROCK_SLIDE, playerLeft); + HP_BAR(opponentRight, captureDamage: &damage[5]); + } THEN { + EXPECT_EQ(damage[0], damage[1]); + EXPECT_EQ(damage[1], damage[3]); + EXPECT_MUL_EQ(damage[5], UQ_4_12(0.75), damage[3]); + EXPECT_EQ(damage[4], damage[5]); + } +} + SINGLE_BATTLE_TEST("Punching Glove vs Muscle Band Damage calculation") { s16 dmgPlayer, dmgOpponent; diff --git a/test/battle/end_turn_effects.c b/test/battle/end_turn_effects.c index 51aa1e79bf..95ae96889f 100644 --- a/test/battle/end_turn_effects.c +++ b/test/battle/end_turn_effects.c @@ -1,7 +1,7 @@ #include "global.h" #include "test/battle.h" -DOUBLE_BATTLE_TEST("End Turn Effects: First Event Block is executed correctly") +DOUBLE_BATTLE_TEST("End Turn Effects: First Event Block is executed correctly (double battle)") { s16 healed; s16 damage; @@ -29,3 +29,90 @@ DOUBLE_BATTLE_TEST("End Turn Effects: First Event Block is executed correctly") } } + +MULTI_BATTLE_TEST("End Turn Effects: First Event Block is executed correctly (multibattle)") +{ + s16 healed; + s16 damage; + + GIVEN { + MULTI_PLAYER(SPECIES_WYNAUT) { HP(100); Speed(1); } + MULTI_PARTNER(SPECIES_EKANS) { HP(100); Ability(ABILITY_SHED_SKIN); Status1(STATUS1_BURN); Speed(2); } + MULTI_OPPONENT_A(SPECIES_WYNAUT) { HP(100); Item(ITEM_LEFTOVERS); Speed(3); } + MULTI_OPPONENT_B(SPECIES_WOBBUFFET) { HP(100); Item(ITEM_BLACK_SLUDGE); Speed(4); } + } WHEN { + TURN { MOVE(playerLeft, MOVE_GRASSY_TERRAIN); } + } SCENE { + MESSAGE("The opposing Wobbuffet is healed by the grassy terrain!"); + HP_BAR(opponentRight, captureDamage: &healed); + HP_BAR(opponentRight, captureDamage: &damage); + MESSAGE("The opposing Wobbuffet was hurt by the Black Sludge!"); + MESSAGE("The opposing Wynaut is healed by the grassy terrain!"); + MESSAGE("The opposing Wynaut restored a little HP using its Leftovers!"); + MESSAGE("Ekans is healed by the grassy terrain!"); + MESSAGE("Ekans's Shed Skin cured its burn problem!"); + MESSAGE("Wynaut is healed by the grassy terrain!"); + } THEN { + EXPECT_GT(0, healed); + EXPECT_GT(damage, 0); + } +} + + +TWO_VS_ONE_BATTLE_TEST("End Turn Effects: First Event Block is executed correctly (2v1)") +{ + s16 healed; + s16 damage; + + GIVEN { + MULTI_PLAYER(SPECIES_WYNAUT) { HP(100); Speed(1);} + MULTI_PARTNER(SPECIES_EKANS) { HP(100); Ability(ABILITY_SHED_SKIN); Status1(STATUS1_BURN); Speed(2); } + MULTI_OPPONENT_A(SPECIES_WYNAUT) { HP(100); Item(ITEM_LEFTOVERS); Speed(3); } + MULTI_OPPONENT_A(SPECIES_WOBBUFFET) { HP(100); Item(ITEM_BLACK_SLUDGE); Speed(4); } + } WHEN { + TURN { MOVE(playerLeft, MOVE_GRASSY_TERRAIN); } + } SCENE { + MESSAGE("The opposing Wobbuffet is healed by the grassy terrain!"); + HP_BAR(opponentRight, captureDamage: &healed); + HP_BAR(opponentRight, captureDamage: &damage); + MESSAGE("The opposing Wobbuffet was hurt by the Black Sludge!"); + MESSAGE("The opposing Wynaut is healed by the grassy terrain!"); + MESSAGE("The opposing Wynaut restored a little HP using its Leftovers!"); + MESSAGE("Ekans is healed by the grassy terrain!"); + MESSAGE("Ekans's Shed Skin cured its burn problem!"); + MESSAGE("Wynaut is healed by the grassy terrain!"); + } THEN { + EXPECT_GT(0, healed); + EXPECT_GT(damage, 0); + } +} + + +ONE_VS_TWO_BATTLE_TEST("End Turn Effects: First Event Block is executed correctly (1v2)") +{ + s16 healed; + s16 damage; + + GIVEN { + MULTI_PLAYER(SPECIES_WYNAUT) { HP(100); Speed(1);} + MULTI_PLAYER(SPECIES_EKANS) { HP(100); Ability(ABILITY_SHED_SKIN); Status1(STATUS1_BURN); Speed(2); } + MULTI_OPPONENT_A(SPECIES_WYNAUT) { HP(100); Item(ITEM_LEFTOVERS); Speed(3); } + MULTI_OPPONENT_B(SPECIES_WOBBUFFET) { HP(100); Item(ITEM_BLACK_SLUDGE); Speed(4); } + } WHEN { + TURN { MOVE(playerLeft, MOVE_GRASSY_TERRAIN); } + } SCENE { + MESSAGE("The opposing Wobbuffet is healed by the grassy terrain!"); + HP_BAR(opponentRight, captureDamage: &healed); + HP_BAR(opponentRight, captureDamage: &damage); + MESSAGE("The opposing Wobbuffet was hurt by the Black Sludge!"); + MESSAGE("The opposing Wynaut is healed by the grassy terrain!"); + MESSAGE("The opposing Wynaut restored a little HP using its Leftovers!"); + MESSAGE("Ekans is healed by the grassy terrain!"); + MESSAGE("Ekans's Shed Skin cured its burn problem!"); + MESSAGE("Wynaut is healed by the grassy terrain!"); + } THEN { + EXPECT_GT(0, healed); + EXPECT_GT(damage, 0); + } +} + diff --git a/test/battle/move.c b/test/battle/move.c index f69c7b2eb4..3efab260a7 100644 --- a/test/battle/move.c +++ b/test/battle/move.c @@ -212,6 +212,50 @@ DOUBLE_BATTLE_TEST("Moves fail if they target the partner but they faint before } } +MULTI_BATTLE_TEST("Ally switch fails when used by either side in a multibattle") +{ + GIVEN { + MULTI_PLAYER(SPECIES_WOBBUFFET); + MULTI_PARTNER(SPECIES_WOBBUFFET); + MULTI_OPPONENT_A(SPECIES_WOBBUFFET); + MULTI_OPPONENT_B(SPECIES_WOBBUFFET); + } WHEN { + TURN { MOVE(playerLeft, MOVE_ALLY_SWITCH); MOVE(playerRight, MOVE_ALLY_SWITCH); MOVE(opponentLeft, MOVE_ALLY_SWITCH); MOVE(opponentRight, MOVE_ALLY_SWITCH); } + } SCENE { + NONE_OF { ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, playerLeft); ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, playerRight); ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, opponentLeft); ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, opponentRight); } + } +} + +TWO_VS_ONE_BATTLE_TEST("Ally switch can only be used by the opponent in a 2v1 battle") +{ + GIVEN { + MULTI_PLAYER(SPECIES_WOBBUFFET); + MULTI_PARTNER(SPECIES_WOBBUFFET); + MULTI_OPPONENT_A(SPECIES_WOBBUFFET); + MULTI_OPPONENT_A(SPECIES_WOBBUFFET); + } WHEN { + TURN { MOVE(playerLeft, MOVE_ALLY_SWITCH); MOVE(playerRight, MOVE_ALLY_SWITCH); MOVE(opponentLeft, MOVE_ALLY_SWITCH); } + } SCENE { + { ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, opponentLeft); } + NONE_OF { ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, playerLeft); ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, playerRight); } + } +} + +ONE_VS_TWO_BATTLE_TEST("Ally switch can only be used by the player in a 1v2 battle") +{ + GIVEN { + MULTI_PLAYER(SPECIES_WOBBUFFET); + MULTI_PLAYER(SPECIES_WOBBUFFET); + MULTI_OPPONENT_A(SPECIES_WOBBUFFET); + MULTI_OPPONENT_B(SPECIES_WOBBUFFET); + } WHEN { + TURN { MOVE(playerLeft, MOVE_ALLY_SWITCH); MOVE(opponentLeft, MOVE_ALLY_SWITCH); MOVE(opponentRight, MOVE_ALLY_SWITCH); } + } SCENE { + { ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, playerLeft); } + NONE_OF { ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, opponentLeft); ANIMATION(ANIM_TYPE_MOVE, MOVE_ALLY_SWITCH, opponentRight); } + } +} + DOUBLE_BATTLE_TEST("Moves do not fail if an alive partner is the target") { GIVEN { diff --git a/test/battle/switch_in_abilities.c b/test/battle/switch_in_abilities.c index c8a8c54dd3..4d125ddce8 100644 --- a/test/battle/switch_in_abilities.c +++ b/test/battle/switch_in_abilities.c @@ -126,3 +126,124 @@ DOUBLE_BATTLE_TEST("Switch-in abilities trigger in Speed Order after post-KO swi } } } + +MULTI_BATTLE_TEST("Switch-in abilities trigger in Speed Order after post-KO switch - multibattle") +{ + u32 spdPlayer1, spdPlayer2, spdOpponent1, spdOpponent2; + + PARAMETRIZE { spdPlayer1 = 5; spdPlayer2 = 4; spdOpponent1 = 3; spdOpponent2 = 2; } + PARAMETRIZE { spdPlayer1 = 2; spdPlayer2 = 3; spdOpponent1 = 4; spdOpponent2 = 5; } + PARAMETRIZE { spdPlayer1 = 4; spdPlayer2 = 3; spdOpponent1 = 5; spdOpponent2 = 2; } + + GIVEN { + MULTI_PLAYER(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_PLAYER(SPECIES_TYRANITAR) { Speed(spdPlayer1); Ability(ABILITY_SAND_STREAM); } + MULTI_PARTNER(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_PARTNER(SPECIES_GYARADOS) { Speed(spdPlayer2); Ability(ABILITY_INTIMIDATE); } + MULTI_OPPONENT_A(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_OPPONENT_A(SPECIES_WEEZING_GALAR) { Speed(spdOpponent1); Ability(ABILITY_MISTY_SURGE); } + MULTI_OPPONENT_B(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_OPPONENT_B(SPECIES_VULPIX_ALOLA) { Speed(spdOpponent2); Ability(ABILITY_SNOW_WARNING); } + } WHEN { + TURN { MOVE(playerLeft, MOVE_EXPLOSION); SEND_OUT(playerLeft, 1); SEND_OUT(opponentLeft, 1); SEND_OUT(playerRight, 4); SEND_OUT(opponentRight, 4); } + TURN { ; } + } SCENE { + MESSAGE("Wobbuffet used Explosion!"); + if (spdPlayer1 == 5) { + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + } else if (spdOpponent2 == 5) { + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + } else { + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + } + } +} + +TWO_VS_ONE_BATTLE_TEST("Switch-in abilities trigger in Speed Order after post-KO switch - 2v1") +{ + u32 spdPlayer1, spdPlayer2, spdOpponent1, spdOpponent2; + + PARAMETRIZE { spdPlayer1 = 5; spdPlayer2 = 4; spdOpponent1 = 3; spdOpponent2 = 2; } + PARAMETRIZE { spdPlayer1 = 2; spdPlayer2 = 3; spdOpponent1 = 4; spdOpponent2 = 5; } + PARAMETRIZE { spdPlayer1 = 4; spdPlayer2 = 3; spdOpponent1 = 5; spdOpponent2 = 2; } + + GIVEN { + MULTI_PLAYER(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_PLAYER(SPECIES_TYRANITAR) { Speed(spdPlayer1); Ability(ABILITY_SAND_STREAM); } + MULTI_PARTNER(SPECIES_WYNAUT) { HP(1); Speed(1); } + MULTI_PARTNER(SPECIES_GYARADOS) { Speed(spdPlayer2); Ability(ABILITY_INTIMIDATE); } + MULTI_OPPONENT_A(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_OPPONENT_A(SPECIES_WYNAUT) { HP(1); Speed(1); } + MULTI_OPPONENT_A(SPECIES_WEEZING_GALAR) { Speed(spdOpponent1); Ability(ABILITY_MISTY_SURGE); } + MULTI_OPPONENT_A(SPECIES_VULPIX_ALOLA) { Speed(spdOpponent2); Ability(ABILITY_SNOW_WARNING); } + } WHEN { + TURN { MOVE(playerLeft, MOVE_EXPLOSION); SEND_OUT(playerLeft, 1); SEND_OUT(opponentLeft, 2); SEND_OUT(playerRight, 4); SEND_OUT(opponentRight, 3); } + } SCENE { + MESSAGE("Wobbuffet used Explosion!"); + if (spdPlayer1 == 5) { + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + } else if (spdOpponent2 == 5) { + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + } else { + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + } + } +} + +ONE_VS_TWO_BATTLE_TEST("Switch-in abilities trigger in Speed Order after post-KO switch - 1v2") +{ + u32 spdPlayer1, spdPlayer2, spdOpponent1, spdOpponent2; + + PARAMETRIZE { spdPlayer1 = 5; spdPlayer2 = 4; spdOpponent1 = 3; spdOpponent2 = 2; } + PARAMETRIZE { spdPlayer1 = 2; spdPlayer2 = 3; spdOpponent1 = 4; spdOpponent2 = 5; } + PARAMETRIZE { spdPlayer1 = 4; spdPlayer2 = 3; spdOpponent1 = 5; spdOpponent2 = 2; } + + GIVEN { + MULTI_PLAYER(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_PLAYER(SPECIES_WYNAUT) { HP(1); Speed(1); } + MULTI_PLAYER(SPECIES_TYRANITAR) { Speed(spdPlayer1); Ability(ABILITY_SAND_STREAM); } + MULTI_PLAYER(SPECIES_GYARADOS) { Speed(spdPlayer2); Ability(ABILITY_INTIMIDATE); } + MULTI_OPPONENT_A(SPECIES_WOBBUFFET) { HP(1); Speed(1); } + MULTI_OPPONENT_A(SPECIES_WEEZING_GALAR) { Speed(spdOpponent1); Ability(ABILITY_MISTY_SURGE); } + MULTI_OPPONENT_B(SPECIES_WYNAUT) { HP(1); Speed(1); } + MULTI_OPPONENT_B(SPECIES_VULPIX_ALOLA) { Speed(spdOpponent2); Ability(ABILITY_SNOW_WARNING); } + } WHEN { + TURN { MOVE(playerLeft, MOVE_EXPLOSION); SEND_OUT(playerLeft, 2); SEND_OUT(opponentLeft, 1); SEND_OUT(playerRight, 3); SEND_OUT(opponentRight, 4); } + } SCENE { + MESSAGE("Wobbuffet used Explosion!"); + if (spdPlayer1 == 5) { + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + } else if (spdOpponent2 == 5) { + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + } else { + ABILITY_POPUP(opponentLeft, ABILITY_MISTY_SURGE); + ABILITY_POPUP(playerLeft, ABILITY_SAND_STREAM); + ABILITY_POPUP(playerRight, ABILITY_INTIMIDATE); + ABILITY_POPUP(opponentRight, ABILITY_SNOW_WARNING); + } + } +} diff --git a/test/test_runner_battle.c b/test/test_runner_battle.c index 55b1caabfa..5301bd911d 100644 --- a/test/test_runner_battle.c +++ b/test/test_runner_battle.c @@ -3,6 +3,7 @@ #include "battle_ai_util.h" #include "battle_anim.h" #include "battle_controllers.h" +#include "battle_setup.h" #include "battle_gimmick.h" #include "battle_z_move.h" #include "event_data.h" @@ -10,6 +11,7 @@ #include "item_menu.h" #include "main.h" #include "malloc.h" +#include "party_menu.h" #include "random.h" #include "test/battle.h" #include "window.h" @@ -76,7 +78,7 @@ NAKED static void InvokeSingleTestFunctionWithStack(void *results, u32 i, struct .pool"); } -NAKED static void InvokeDoubleTestFunctionWithStack(void *results, u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight, SingleBattleTestFunction function, void *stack) +NAKED static void InvokeDoubleTestFunctionWithStack(void *results, u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight, DoubleBattleTestFunction function, void *stack) { asm("push {r4-r7,lr}\n\ ldr r4, [sp, #28] @ function\n\ @@ -100,6 +102,78 @@ NAKED static void InvokeDoubleTestFunctionWithStack(void *results, u32 i, struct .pool"); } +NAKED static void InvokeMultiTestFunctionWithStack(void *results, u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight, MultiBattleTestFunction function, void *stack) +{ + asm("push {r4-r7,lr}\n\ + ldr r4, [sp, #28] @ function\n\ + ldr r5, [sp, #32] @ stack\n\ + mov r6, sp\n\ + mov sp, r5\n\ + push {r6}\n\ + add r6, #20\n\ + ldmia r6, {r6, r7} @ playerRight, opponentRight\n\ + push {r6, r7}\n\ + ldr r6, =MultiRestoreSP + 1\n\ + mov lr, r6\n\ + bx r4\n\ + MultiRestoreSP:\n\ + add sp, #8\n\ + pop {r0}\n\ + mov sp, r0\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool"); +} + +NAKED static void InvokeTwoVsOneTestFunctionWithStack(void *results, u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight, TwoVsOneBattleTestFunction function, void *stack) +{ + asm("push {r4-r7,lr}\n\ + ldr r4, [sp, #28] @ function\n\ + ldr r5, [sp, #32] @ stack\n\ + mov r6, sp\n\ + mov sp, r5\n\ + push {r6}\n\ + add r6, #20\n\ + ldmia r6, {r6, r7} @ playerRight, opponentRight\n\ + push {r6, r7}\n\ + ldr r6, =TwoVsOneRestoreSP + 1\n\ + mov lr, r6\n\ + bx r4\n\ + TwoVsOneRestoreSP:\n\ + add sp, #8\n\ + pop {r0}\n\ + mov sp, r0\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool"); +} + +NAKED static void InvokeOneVsTwoTestFunctionWithStack(void *results, u32 i, struct BattlePokemon *playerLeft, struct BattlePokemon *opponentLeft, struct BattlePokemon *playerRight, struct BattlePokemon *opponentRight, OneVsTwoBattleTestFunction function, void *stack) +{ + asm("push {r4-r7,lr}\n\ + ldr r4, [sp, #28] @ function\n\ + ldr r5, [sp, #32] @ stack\n\ + mov r6, sp\n\ + mov sp, r5\n\ + push {r6}\n\ + add r6, #20\n\ + ldmia r6, {r6, r7} @ playerRight, opponentRight\n\ + push {r6, r7}\n\ + ldr r6, =OneVsTwoRestoreSP + 1\n\ + mov lr, r6\n\ + bx r4\n\ + OneVsTwoRestoreSP:\n\ + add sp, #8\n\ + pop {r0}\n\ + mov sp, r0\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool"); +} + // Calls test->function, but pointing its stack at DATA.stack so that // local variables are live after the function returns (and so can be // referenced by HP_BAR, or the next call, etc). @@ -118,7 +192,19 @@ static void InvokeTestFunction(const struct BattleTest *test) break; case BATTLE_TEST_DOUBLES: case BATTLE_TEST_AI_DOUBLES: - InvokeDoubleTestFunctionWithStack(STATE->results, STATE->runParameter, &gBattleMons[B_POSITION_PLAYER_LEFT], &gBattleMons[B_POSITION_OPPONENT_LEFT], &gBattleMons[B_POSITION_PLAYER_RIGHT], &gBattleMons[B_POSITION_OPPONENT_RIGHT], test->function.singles, &DATA.stack[BATTLE_TEST_STACK_SIZE]); + InvokeDoubleTestFunctionWithStack(STATE->results, STATE->runParameter, &gBattleMons[B_POSITION_PLAYER_LEFT], &gBattleMons[B_POSITION_OPPONENT_LEFT], &gBattleMons[B_POSITION_PLAYER_RIGHT], &gBattleMons[B_POSITION_OPPONENT_RIGHT], test->function.doubles, &DATA.stack[BATTLE_TEST_STACK_SIZE]); + break; + case BATTLE_TEST_MULTI: + case BATTLE_TEST_AI_MULTI: + InvokeMultiTestFunctionWithStack(STATE->results, STATE->runParameter, &gBattleMons[B_POSITION_PLAYER_LEFT], &gBattleMons[B_POSITION_OPPONENT_LEFT], &gBattleMons[B_POSITION_PLAYER_RIGHT], &gBattleMons[B_POSITION_OPPONENT_RIGHT], test->function.multi, &DATA.stack[BATTLE_TEST_STACK_SIZE]); + break; + case BATTLE_TEST_TWO_VS_ONE: + case BATTLE_TEST_AI_TWO_VS_ONE: + InvokeTwoVsOneTestFunctionWithStack(STATE->results, STATE->runParameter, &gBattleMons[B_POSITION_PLAYER_LEFT], &gBattleMons[B_POSITION_OPPONENT_LEFT], &gBattleMons[B_POSITION_PLAYER_RIGHT], &gBattleMons[B_POSITION_OPPONENT_RIGHT], test->function.two_vs_one, &DATA.stack[BATTLE_TEST_STACK_SIZE]); + break; + case BATTLE_TEST_ONE_VS_TWO: + case BATTLE_TEST_AI_ONE_VS_TWO: + InvokeOneVsTwoTestFunctionWithStack(STATE->results, STATE->runParameter, &gBattleMons[B_POSITION_PLAYER_LEFT], &gBattleMons[B_POSITION_OPPONENT_LEFT], &gBattleMons[B_POSITION_PLAYER_RIGHT], &gBattleMons[B_POSITION_OPPONENT_RIGHT], test->function.one_vs_two, &DATA.stack[BATTLE_TEST_STACK_SIZE]); break; } } @@ -135,6 +221,9 @@ static bool32 IsAITest(void) { case BATTLE_TEST_AI_SINGLES: case BATTLE_TEST_AI_DOUBLES: + case BATTLE_TEST_AI_MULTI: + case BATTLE_TEST_AI_TWO_VS_ONE: + case BATTLE_TEST_AI_ONE_VS_TWO: return TRUE; } return FALSE; @@ -179,6 +268,12 @@ static void BattleTest_SetUp(void *data) break; case BATTLE_TEST_DOUBLES: case BATTLE_TEST_AI_DOUBLES: + case BATTLE_TEST_MULTI: + case BATTLE_TEST_AI_MULTI: + case BATTLE_TEST_TWO_VS_ONE: + case BATTLE_TEST_AI_TWO_VS_ONE: + case BATTLE_TEST_ONE_VS_TWO: + case BATTLE_TEST_AI_ONE_VS_TWO: STATE->battlersCount = 4; break; } @@ -263,26 +358,97 @@ static void BattleTest_Run(void *data) { case BATTLE_TEST_WILD: DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER; + for (i = 0; i < STATE->battlersCount; i++) + DATA.currentMonIndexes[i] = i / 2; break; case BATTLE_TEST_AI_SINGLES: DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER; DATA.recordedBattle.opponentA = TRAINER_LEAF; DATA.hasAI = TRUE; + for (i = 0; i < STATE->battlersCount; i++) + DATA.currentMonIndexes[i] = i / 2; break; case BATTLE_TEST_AI_DOUBLES: DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER | BATTLE_TYPE_DOUBLE; DATA.recordedBattle.opponentA = TRAINER_LEAF; + DATA.recordedBattle.opponentB = TRAINER_NONE; + DATA.hasAI = TRUE; + for (i = 0; i < STATE->battlersCount; i++) + DATA.currentMonIndexes[i] = i / 2; + break; + case BATTLE_TEST_AI_MULTI: + DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS; + DATA.recordedBattle.partnerId = TRAINER_PARTNER(PARTNER_STEVEN); + DATA.recordedBattle.opponentA = TRAINER_LEAF; DATA.recordedBattle.opponentB = TRAINER_RED; DATA.hasAI = TRUE; + DATA.currentMonIndexes[0] = 0; // Player first mon + DATA.currentMonIndexes[1] = 0; // Opponent A first mon + DATA.currentMonIndexes[2] = 3; // Player partner first mon + DATA.currentMonIndexes[3] = 3; // Opponent B first mon + break; + case BATTLE_TEST_AI_TWO_VS_ONE: + DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_MULTI; + DATA.recordedBattle.partnerId = TRAINER_PARTNER(PARTNER_STEVEN); + DATA.recordedBattle.opponentA = TRAINER_LEAF; + DATA.recordedBattle.opponentB = 0xFFFF; + DATA.currentMonIndexes[0] = 0; // Player first mon + DATA.currentMonIndexes[1] = 0; // Opponent first mon + DATA.currentMonIndexes[2] = 3; // Player partner first mon + DATA.currentMonIndexes[3] = 1; // Opponent second mon + DATA.hasAI = TRUE; + break; + case BATTLE_TEST_AI_ONE_VS_TWO: + DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER | BATTLE_TYPE_DOUBLE | BATTLE_TYPE_TWO_OPPONENTS; + DATA.recordedBattle.opponentA = TRAINER_LEAF; + DATA.recordedBattle.opponentB = TRAINER_RED; + DATA.currentMonIndexes[0] = 0; // Player first mon + DATA.currentMonIndexes[1] = 0; // Opponent A first mon + DATA.currentMonIndexes[2] = 1; // Player second mon + DATA.currentMonIndexes[3] = 3; // Opponent B first mon + DATA.hasAI = TRUE; break; case BATTLE_TEST_SINGLES: DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_RECORDED_IS_MASTER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER; DATA.recordedBattle.opponentA = TRAINER_LINK_OPPONENT; + for (i = 0; i < STATE->battlersCount; i++) + DATA.currentMonIndexes[i] = i / 2; break; case BATTLE_TEST_DOUBLES: DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_RECORDED_IS_MASTER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER | BATTLE_TYPE_DOUBLE; DATA.recordedBattle.opponentA = TRAINER_LINK_OPPONENT; + DATA.recordedBattle.opponentB = TRAINER_NONE; + for (i = 0; i < STATE->battlersCount; i++) + DATA.currentMonIndexes[i] = i / 2; + break; + case BATTLE_TEST_MULTI: + DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_RECORDED_IS_MASTER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS; + DATA.recordedBattle.partnerId = TRAINER_PARTNER(PARTNER_STEVEN); + DATA.recordedBattle.opponentA = TRAINER_LINK_OPPONENT; DATA.recordedBattle.opponentB = TRAINER_LINK_OPPONENT; + DATA.currentMonIndexes[0] = 0; // Player first mon + DATA.currentMonIndexes[1] = 0; // Opponent A first mon + DATA.currentMonIndexes[2] = 3; // Player partner first mon + DATA.currentMonIndexes[3] = 3; // Opponent B first mon + break; + case BATTLE_TEST_TWO_VS_ONE: + DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_RECORDED_IS_MASTER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_MULTI; + DATA.recordedBattle.partnerId = TRAINER_PARTNER(PARTNER_STEVEN); + DATA.recordedBattle.opponentA = TRAINER_LINK_OPPONENT; + DATA.recordedBattle.opponentB = 0xFFFF; + DATA.currentMonIndexes[0] = 0; // Player first mon + DATA.currentMonIndexes[1] = 0; // Opponent first mon + DATA.currentMonIndexes[2] = 3; // Player partner first mon + DATA.currentMonIndexes[3] = 1; // Opponent second mon + break; + case BATTLE_TEST_ONE_VS_TWO: + DATA.recordedBattle.battleFlags = BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_RECORDED_IS_MASTER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER | BATTLE_TYPE_DOUBLE | BATTLE_TYPE_TWO_OPPONENTS; + DATA.recordedBattle.opponentA = TRAINER_LINK_OPPONENT; + DATA.recordedBattle.opponentB = TRAINER_LINK_OPPONENT; + DATA.currentMonIndexes[0] = 0; // Player first mon + DATA.currentMonIndexes[1] = 0; // Opponent A first mon + DATA.currentMonIndexes[2] = 1; // Player second mon + DATA.currentMonIndexes[3] = 3; // Opponent B first mon break; } @@ -294,9 +460,6 @@ static void BattleTest_Run(void *data) DATA.recordedBattle.playersBattlers[i] = i; } - for (i = 0; i < STATE->battlersCount; i++) - DATA.currentMonIndexes[i] = i / 2; - STATE->runRandomly = TRUE; STATE->runGiven = TRUE; STATE->runWhen = TRUE; @@ -326,10 +489,46 @@ static void BattleTest_Run(void *data) if (DATA.hasExplicitSpeeds) { - // TODO: If a battler is taking the default action maybe it - // should not require an explicit speed? - if (DATA.explicitSpeeds[B_SIDE_PLAYER] != (1 << DATA.playerPartySize) - 1 - || DATA.explicitSpeeds[B_SIDE_OPPONENT] != (1 << DATA.opponentPartySize) - 1) + u8 revisedPlayerExplicitSpeeds = 0; + u8 revisedPartnerExplicitSpeeds = 0; + u8 revisedOpponentAExplicitSpeeds = 0; + u8 revisedOpponentBExplicitSpeeds = 0; + + for (i = 0; i < 3; i++) + { + if(GetMonData(&DATA.recordedBattle.playerParty[i], MON_DATA_SPECIES, NULL) != SPECIES_NONE) + revisedPlayerExplicitSpeeds |= 1 << i; + } + for (i = 3; i < PARTY_SIZE; i++) + { + if(GetMonData(&DATA.recordedBattle.playerParty[i], MON_DATA_SPECIES, NULL) != SPECIES_NONE) + { + if(DATA.currentPosition == B_POSITION_PLAYER_LEFT) + revisedPlayerExplicitSpeeds |= 1 << i; + else + revisedPartnerExplicitSpeeds |= 1 << i; + } + } + + for (i = 0; i < 3; i++) + { + if(GetMonData(&DATA.recordedBattle.opponentParty[i], MON_DATA_SPECIES, NULL) != SPECIES_NONE) + revisedOpponentAExplicitSpeeds |= 1 << i; + } + for (i = 3; i < PARTY_SIZE; i++) + { + if(GetMonData(&DATA.recordedBattle.opponentParty[i], MON_DATA_SPECIES, NULL) != SPECIES_NONE) + { + if(DATA.currentPosition == B_POSITION_OPPONENT_LEFT) + revisedOpponentAExplicitSpeeds |= 1 << i; + else + revisedOpponentBExplicitSpeeds |= 1 << i; + } + } + + if (((DATA.explicitSpeeds[B_POSITION_PLAYER_LEFT] + DATA.explicitSpeeds[B_POSITION_PLAYER_RIGHT]) != (revisedPlayerExplicitSpeeds + revisedPartnerExplicitSpeeds) + || (DATA.explicitSpeeds[B_POSITION_OPPONENT_LEFT] + DATA.explicitSpeeds[B_POSITION_OPPONENT_RIGHT]) != (revisedOpponentAExplicitSpeeds + revisedOpponentBExplicitSpeeds))) + { Test_ExitWithResult(TEST_RESULT_INVALID, SourceLine(0), ":LSpeed required for all PLAYERs and OPPONENTs"); } @@ -1509,14 +1708,24 @@ void RNGSeed_(u32 sourceLine, rng_value_t seed) void AIFlags_(u32 sourceLine, u64 flags) { - INVALID_IF(!IsAITest(), "AI_FLAGS is usable only in AI_SINGLE_BATTLE_TEST & AI_DOUBLE_BATTLE_TEST"); - DATA.recordedBattle.AI_scripts = flags; + INVALID_IF(!IsAITest(), "AI_FLAGS is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, and AI_TWO_VS_ONE_TEST"); + for (u32 i = 0; i < MAX_BATTLERS_COUNT; i++) + { + DATA.recordedBattle.AI_scripts[i] = flags; + } + DATA.hasAI = TRUE; +} + +void BattlerAIFlags_(u32 sourceLine, u32 battler, u64 flags) +{ + INVALID_IF(!IsAITest(), "AI_FLAGS is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, and AI_TWO_VS_ONE_TEST"); + DATA.recordedBattle.AI_scripts[battler] |= flags; DATA.hasAI = TRUE; } void AILogScores(u32 sourceLine) { - INVALID_IF(!IsAITest(), "AI_LOG is usable only in AI_SINGLE_BATTLE_TEST & AI_DOUBLE_BATTLE_TEST"); + INVALID_IF(!IsAITest(), "AI_LOG is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, and AI_TWO_VS_ONE_TEST"); DATA.logAI = TRUE; } @@ -1552,14 +1761,14 @@ void ClearFlagAfterTest(void) } } -void OpenPokemon(u32 sourceLine, enum BattleSide side, u32 species) +void OpenPokemon(u32 sourceLine, enum BattlerPosition position, u32 species) { s32 i, data; u8 *partySize; struct Pokemon *party; INVALID_IF(species >= SPECIES_EGG, "Invalid species: %d", species); ASSUMPTION_FAIL_IF(!IsSpeciesEnabled(species), "Species disabled: %d", species); - if (side == B_SIDE_PLAYER) + if ((position & BIT_SIDE) == B_SIDE_PLAYER) { partySize = &DATA.playerPartySize; party = DATA.recordedBattle.playerParty; @@ -1570,7 +1779,60 @@ void OpenPokemon(u32 sourceLine, enum BattleSide side, u32 species) party = DATA.recordedBattle.opponentParty; } INVALID_IF(*partySize >= PARTY_SIZE, "Too many Pokemon in party"); - DATA.currentSide = side; + DATA.currentPosition = position; + DATA.currentPartyIndex = *partySize; + DATA.currentMon = &party[DATA.currentPartyIndex]; + DATA.gender = 0xFF; // Male + DATA.nature = NATURE_HARDY; + (*partySize)++; + + CreateMon(DATA.currentMon, species, 100, 0, TRUE, 0, OT_ID_PRESET, 0); + data = MOVE_NONE; + for (i = 0; i < MAX_MON_MOVES; i++) + SetMonData(DATA.currentMon, MON_DATA_MOVE1 + i, &data); + data = 0; + if (B_FRIENDSHIP_BOOST) + { + // This way, we avoid the boost affecting tests unless explicitly stated. + SetMonData(DATA.currentMon, MON_DATA_FRIENDSHIP, &data); + CalculateMonStats(DATA.currentMon); + } +} + +void OpenPokemonMulti(u32 sourceLine, enum BattlerPosition position, u32 species) +{ + + s32 i, data; + u8 *partySize; + struct Pokemon *party; + INVALID_IF(species >= SPECIES_EGG, "Invalid species: %d", species); + ASSUMPTION_FAIL_IF(!IsSpeciesEnabled(species), "Species disabled: %d", species); + if (position == B_POSITION_PLAYER_LEFT) // MULTI_PLAYER + { + partySize = &DATA.playerPartySize; + party = DATA.recordedBattle.playerParty; + } + else if (position == B_POSITION_PLAYER_RIGHT) // MULTI_PARTNER + { + partySize = &DATA.playerPartySize; + if ((*partySize == 0) || (*partySize == 1) || (*partySize == 2)) + *partySize = 3; + party = DATA.recordedBattle.playerParty; + } + else if (position == B_POSITION_OPPONENT_LEFT) // MULTI_OPPONENT_A + { + partySize = &DATA.opponentPartySize; + party = DATA.recordedBattle.opponentParty; + } + else // MULTI_OPPONENT_B + { + partySize = &DATA.opponentPartySize; + if ((*partySize == 0) || (*partySize == 1) || (*partySize == 2)) + *partySize = 3; + party = DATA.recordedBattle.opponentParty; + } + INVALID_IF(*partySize >= PARTY_SIZE, "Too many Pokemon in party"); + DATA.currentPosition = position; DATA.currentPartyIndex = *partySize; DATA.currentMon = &party[DATA.currentPartyIndex]; DATA.gender = 0xFF; // Male @@ -1621,10 +1883,10 @@ void ClosePokemon(u32 sourceLine) { s32 i; u32 data; - INVALID_IF(DATA.hasExplicitSpeeds && !(DATA.explicitSpeeds[DATA.currentSide] & (1 << DATA.currentPartyIndex)), "Speed required"); + INVALID_IF(DATA.hasExplicitSpeeds && !(DATA.explicitSpeeds[DATA.currentPosition] & (1 << DATA.currentPartyIndex)), "Speed required"); for (i = 0; i < STATE->battlersCount; i++) { - if ((i & BIT_SIDE) == DATA.currentSide + if (i == DATA.currentPosition && DATA.currentMonIndexes[i] == DATA.currentPartyIndex) { INVALID_IF(GetMonData(DATA.currentMon, MON_DATA_HP) == 0, "Battlers cannot be fainted"); @@ -1695,7 +1957,7 @@ void Ability_(u32 sourceLine, enum Ability ability) // Store forced ability to be set when the battle starts if invalid. if (i == NUM_ABILITY_SLOTS) { - DATA.forcedAbilities[DATA.currentSide][DATA.currentPartyIndex] = ability; + DATA.forcedAbilities[DATA.currentPosition][DATA.currentPartyIndex] = ability; } } @@ -1759,7 +2021,7 @@ void Speed_(u32 sourceLine, u32 speed) INVALID_IF(speed == 0, "Illegal speed: %d", speed); SetMonData(DATA.currentMon, MON_DATA_SPEED, &speed); DATA.hasExplicitSpeeds = TRUE; - DATA.explicitSpeeds[DATA.currentSide] |= 1 << DATA.currentPartyIndex; + DATA.explicitSpeeds[DATA.currentPosition] |= 1 << DATA.currentPartyIndex; } void HPIV_(u32 sourceLine, u32 hpIV) @@ -1812,10 +2074,10 @@ void Item_(u32 sourceLine, u32 item) switch (GetItemHoldEffect(item)) { case HOLD_EFFECT_MEGA_STONE: - SetGimmick(sourceLine, DATA.currentSide, DATA.currentPartyIndex, GIMMICK_MEGA); + SetGimmick(sourceLine, DATA.currentPosition, DATA.currentPartyIndex, GIMMICK_MEGA); break; case HOLD_EFFECT_Z_CRYSTAL: - SetGimmick(sourceLine, DATA.currentSide, DATA.currentPartyIndex, GIMMICK_Z_MOVE); + SetGimmick(sourceLine, DATA.currentPosition, DATA.currentPartyIndex, GIMMICK_Z_MOVE); break; } } @@ -1833,7 +2095,7 @@ void Moves_(u32 sourceLine, u16 moves[MAX_MON_MOVES]) u32 pp = GetMovePP(moves[i]); SetMonData(DATA.currentMon, MON_DATA_PP1 + i, &pp); } - DATA.explicitMoves[DATA.currentSide] |= 1 << DATA.currentPartyIndex; + DATA.explicitMoves[DATA.currentPosition] |= 1 << DATA.currentPartyIndex; } void MovesWithPP_(u32 sourceLine, struct moveWithPP moveWithPP[MAX_MON_MOVES]) @@ -1848,7 +2110,7 @@ void MovesWithPP_(u32 sourceLine, struct moveWithPP moveWithPP[MAX_MON_MOVES]) SetMonData(DATA.currentMon, MON_DATA_MOVE1 + i, &moveWithPP[i].moveId); SetMonData(DATA.currentMon, MON_DATA_PP1 + i, &moveWithPP[i].pp); } - DATA.explicitMoves[DATA.currentSide] |= 1 << DATA.currentPartyIndex; + DATA.explicitMoves[DATA.currentPosition] |= 1 << DATA.currentPartyIndex; } void Friendship_(u32 sourceLine, u32 friendship) @@ -1874,21 +2136,21 @@ void DynamaxLevel_(u32 sourceLine, u32 dynamaxLevel) { INVALID_IF(!DATA.currentMon, "DynamaxLevel outside of PLAYER/OPPONENT"); SetMonData(DATA.currentMon, MON_DATA_DYNAMAX_LEVEL, &dynamaxLevel); - SetGimmick(sourceLine, DATA.currentSide, DATA.currentPartyIndex, GIMMICK_DYNAMAX); + SetGimmick(sourceLine, DATA.currentPosition, DATA.currentPartyIndex, GIMMICK_DYNAMAX); } void GigantamaxFactor_(u32 sourceLine, bool32 gigantamaxFactor) { INVALID_IF(!DATA.currentMon, "GigantamaxFactor outside of PLAYER/OPPONENT"); SetMonData(DATA.currentMon, MON_DATA_GIGANTAMAX_FACTOR, &gigantamaxFactor); - SetGimmick(sourceLine, DATA.currentSide, DATA.currentPartyIndex, GIMMICK_DYNAMAX); + SetGimmick(sourceLine, DATA.currentPosition, DATA.currentPartyIndex, GIMMICK_DYNAMAX); } void TeraType_(u32 sourceLine, u32 teraType) { INVALID_IF(!DATA.currentMon, "TeraType outside of PLAYER/OPPONENT"); SetMonData(DATA.currentMon, MON_DATA_TERA_TYPE, &teraType); - SetGimmick(sourceLine, DATA.currentSide, DATA.currentPartyIndex, GIMMICK_TERA); + SetGimmick(sourceLine, DATA.currentPosition, DATA.currentPartyIndex, GIMMICK_TERA); } void Shadow_(u32 sourceLine, bool32 isShadow) @@ -1928,7 +2190,13 @@ static const char *BattlerIdentifier(s32 battlerId) return sBattlerIdentifiersSingles[battlerId]; case BATTLE_TEST_DOUBLES: case BATTLE_TEST_AI_DOUBLES: - return sBattlerIdentifiersDoubles[battlerId]; + case BATTLE_TEST_MULTI: + case BATTLE_TEST_AI_MULTI: + case BATTLE_TEST_TWO_VS_ONE: + case BATTLE_TEST_AI_TWO_VS_ONE: + case BATTLE_TEST_ONE_VS_TWO: + case BATTLE_TEST_AI_ONE_VS_TWO: + return sBattlerIdentifiersDoubles[battlerId]; } return ""; } @@ -2068,7 +2336,7 @@ void CloseTurn(u32 sourceLine) for (i = 0; i < STATE->battlersCount; i++) { if (!(DATA.actionBattlers & (1 << i))) - { + { // Multi test partner trainers want setting to RecordedPartner controller if no move set in this case. if (IsAITest() && (i & BIT_SIDE) == B_SIDE_OPPONENT) // If Move was not specified, allow any move used. SetAiActionToPass(sourceLine, i); else @@ -2082,7 +2350,7 @@ void CloseTurn(u32 sourceLine) static struct Pokemon *CurrentMon(s32 battlerId) { struct Pokemon *party; - if ((battlerId & BIT_SIDE) == B_SIDE_PLAYER) + if (battlerId == B_POSITION_PLAYER_LEFT || battlerId == B_POSITION_PLAYER_RIGHT) party = DATA.recordedBattle.playerParty; else party = DATA.recordedBattle.opponentParty; @@ -2320,7 +2588,7 @@ static void TryMarkExpectMove(u32 sourceLine, struct BattlePokemon *battler, str s32 target; INVALID_IF(DATA.turnState == TURN_CLOSED, "EXPECT_MOVE outside TURN"); - INVALID_IF(!IsAITest(), "EXPECT_MOVE is usable only in AI_SINGLE_BATTLE_TEST & AI_DOUBLE_BATTLE_TEST"); + INVALID_IF(!IsAITest(), "EXPECT_MOVE is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, and AI_TWO_VS_ONE_TEST"); MoveGetIdAndSlot(battlerId, ctx, &moveId, &moveSlot, sourceLine); target = MoveGetTarget(battlerId, moveId, ctx, sourceLine); @@ -2351,7 +2619,7 @@ void ExpectSendOut(u32 sourceLine, struct BattlePokemon *battler, u32 partyIndex s32 i, id; s32 battlerId = battler - gBattleMons; INVALID_IF(DATA.turnState == TURN_CLOSED, "EXPECT_SEND_OUT outside TURN"); - INVALID_IF(!IsAITest(), "EXPECT_SEND_OUT is usable only in AI_SINGLE_BATTLE_TEST & AI_DOUBLE_BATTLE_TEST"); + INVALID_IF(!IsAITest(), "EXPECT_SEND_OUT is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, AI_TWO_VS_ONE_TEST, and AI_ONE_VS_TWO_TEST"); INVALID_IF(partyIndex >= ((battlerId & BIT_SIDE) == B_SIDE_PLAYER ? DATA.playerPartySize : DATA.opponentPartySize), "EXPECT_SEND_OUT to invalid party index"); for (i = 0; i < STATE->battlersCount; i++) { @@ -2359,8 +2627,9 @@ void ExpectSendOut(u32 sourceLine, struct BattlePokemon *battler, u32 partyIndex INVALID_IF(DATA.currentMonIndexes[i] == partyIndex, "EXPECT_SEND_OUT to battler"); } if (!(DATA.actionBattlers & (1 << battlerId))) - { - if (IsAITest() && (battlerId & BIT_SIDE) == B_SIDE_OPPONENT) // If Move was not specified, allow any move used. + { // Multi test partner trainers want setting to PlayerPartner controller even if no move set in this case. + if (IsAITest() && (((battlerId & BIT_SIDE) == B_SIDE_OPPONENT) // If Move was not specified, allow any move used. + || (IsMultibattleTest() && battlerId == B_POSITION_PLAYER_RIGHT))) SetAiActionToPass(sourceLine, battlerId); else Move(sourceLine, battler, (struct MoveContext) { move: MOVE_CELEBRATE, explicitMove: TRUE }); @@ -2403,7 +2672,7 @@ void Score(u32 sourceLine, struct BattlePokemon *battler, u32 cmp, bool32 toValu s32 battlerId = battler - gBattleMons; s32 turn = DATA.turns; - INVALID_IF(!IsAITest(), "SCORE_%s%s is usable only in AI_SINGLE_BATTLE_TEST & AI_DOUBLE_BATTLE_TEST", sCmpToStringTable[cmp], (toValue == TRUE) ? "_VAL" : ""); + INVALID_IF(!IsAITest(), "SCORE_%s%s is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, & AI_TWO_VS_ONE_TEST", sCmpToStringTable[cmp], (toValue == TRUE) ? "_VAL" : ""); for (i = 0; i < MAX_AI_SCORE_COMPARISION_PER_TURN; i++) { @@ -2487,7 +2756,7 @@ void ExpectSwitch(u32 sourceLine, struct BattlePokemon *battler, u32 partyIndex) s32 i, id; s32 battlerId = battler - gBattleMons; INVALID_IF(DATA.turnState == TURN_CLOSED, "EXPECT_SWITCH outside TURN"); - INVALID_IF(!IsAITest(), "EXPECT_SWITCH is usable only in AI_SINGLE_BATTLE_TEST & AI_DOUBLE_BATTLE_TEST"); + INVALID_IF(!IsAITest(), "EXPECT_SWITCH is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, AI_TWO_VS_ONE_TEST, and AI_ONE_VS_TWO_TEST"); INVALID_IF(DATA.actionBattlers & (1 << battlerId), "Multiple battler actions"); INVALID_IF(partyIndex >= ((battlerId & BIT_SIDE) == B_SIDE_PLAYER ? DATA.playerPartySize : DATA.opponentPartySize), "EXPECT_SWITCH to invalid party index");