summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/battle_ai_script_commands.c120
-rw-r--r--src/battle_controller_safari.c10
-rw-r--r--src/battle_controllers.c1171
-rw-r--r--src/battle_gfx_sfx_util.c1
-rw-r--r--src/mevent.c8
-rw-r--r--src/mevent_server_helpers.c6
-rw-r--r--src/pokemon.c17
-rw-r--r--src/quest_log_battle.c2
-rw-r--r--src/save.c8
9 files changed, 1254 insertions, 89 deletions
diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c
index 1650f1056..86e7d3143 100644
--- a/src/battle_ai_script_commands.c
+++ b/src/battle_ai_script_commands.c
@@ -249,7 +249,7 @@ static const u16 sDiscouragedPowerfulMoveEffects[] =
};
// TODO: move these
-extern u8 sBattler_AI;
+extern u8 gBattlerAttacker;
extern const u32 gBitTable[]; // util.h
extern u32 gStatuses3[]; // battle_2.h
extern u16 gSideAffecting[2];
@@ -318,7 +318,7 @@ void BattleAI_SetupAIData(void)
}
gBattleResources->AI_ScriptsStack->size = 0;
- sBattler_AI = gActiveBattler;
+ gBattlerAttacker = gActiveBattler;
// Decide a random target battlerId in doubles.
if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
@@ -331,7 +331,7 @@ void BattleAI_SetupAIData(void)
// There's only one choice in single battles.
else
{
- gBattlerTarget = sBattler_AI ^ BIT_SIDE;
+ gBattlerTarget = gBattlerAttacker ^ BIT_SIDE;
}
// Choose proper trainer ai scripts.
@@ -425,13 +425,13 @@ void BattleAI_DoAIProcessing(void)
break;
case AIState_SettingUp:
gAIScriptPtr = BattleAIs[AI_THINKING_STRUCT->aiLogicId]; // set the AI ptr.
- if (gBattleMons[sBattler_AI].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
+ if (gBattleMons[gBattlerAttacker].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
{
AI_THINKING_STRUCT->moveConsidered = 0; // don't consider a move you have 0 PP for, idiot.
}
else
{
- AI_THINKING_STRUCT->moveConsidered = gBattleMons[sBattler_AI].moves[AI_THINKING_STRUCT->movesetIndex];
+ AI_THINKING_STRUCT->moveConsidered = gBattleMons[gBattlerAttacker].moves[AI_THINKING_STRUCT->movesetIndex];
}
AI_THINKING_STRUCT->aiState++;
break;
@@ -544,7 +544,7 @@ static void BattleAICmd_if_hp_less_than(void)
u16 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -559,7 +559,7 @@ static void BattleAICmd_if_hp_more_than(void)
u16 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -574,7 +574,7 @@ static void BattleAICmd_if_hp_equal(void)
u16 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -589,7 +589,7 @@ static void BattleAICmd_if_hp_not_equal(void)
u16 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -605,7 +605,7 @@ static void BattleAICmd_if_status(void)
u32 arg;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -623,7 +623,7 @@ static void BattleAICmd_if_not_status(void)
u32 arg;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -641,7 +641,7 @@ static void BattleAICmd_if_status2(void)
u32 arg;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -659,7 +659,7 @@ static void BattleAICmd_if_not_status2(void)
u32 arg;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -677,7 +677,7 @@ static void BattleAICmd_if_status3(void)
u32 arg;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -695,7 +695,7 @@ static void BattleAICmd_if_not_status3(void)
u32 arg;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -713,7 +713,7 @@ static void BattleAICmd_if_status4(void)
u32 arg1, arg2;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -732,7 +732,7 @@ static void BattleAICmd_if_not_status4(void)
u32 arg1, arg2;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -907,8 +907,8 @@ static void BattleAICmd_if_user_can_damage(void)
for (i = 0; i < MAX_MON_MOVES; i++)
{
- if (gBattleMons[sBattler_AI].moves[i] != 0
- && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
+ if (gBattleMons[gBattlerAttacker].moves[i] != 0
+ && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].power != 0)
break;
}
if (i == MAX_MON_MOVES)
@@ -923,8 +923,8 @@ static void BattleAICmd_if_user_cant_damage(void)
for (i = 0; i < MAX_MON_MOVES; i++)
{
- if (gBattleMons[sBattler_AI].moves[i] != 0
- && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
+ if (gBattleMons[gBattlerAttacker].moves[i] != 0
+ && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].power != 0)
break;
}
if (i != MAX_MON_MOVES)
@@ -944,13 +944,13 @@ static void BattleAICmd_get_type(void)
switch (gAIScriptPtr[1])
{
case 1: // player primary type
- AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type1;
+ AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerAttacker].type1;
break;
case 0: // enemy primary type
AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type1;
break;
case 3: // player secondary type
- AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type2;
+ AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerAttacker].type2;
break;
case 2: // enemy secondary type
AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type2;
@@ -992,17 +992,17 @@ static void BattleAICmd_is_most_powerful_move(void)
{
for (i = 0; sDiscouragedPowerfulMoveEffects[i] != 0xFFFF; i++)
{
- if (gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].effect == sDiscouragedPowerfulMoveEffects[i])
+ if (gBattleMoves[gBattleMons[gBattlerAttacker].moves[checkedMove]].effect == sDiscouragedPowerfulMoveEffects[i])
break;
}
- if (gBattleMons[sBattler_AI].moves[checkedMove] != MOVE_NONE
+ if (gBattleMons[gBattlerAttacker].moves[checkedMove] != MOVE_NONE
&& sDiscouragedPowerfulMoveEffects[i] == 0xFFFF
- && gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].power > 1)
+ && gBattleMoves[gBattleMons[gBattlerAttacker].moves[checkedMove]].power > 1)
{
- gCurrentMove = gBattleMons[sBattler_AI].moves[checkedMove];
- AI_CalcDmg(sBattler_AI, gBattlerTarget);
- TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+ gCurrentMove = gBattleMons[gBattlerAttacker].moves[checkedMove];
+ AI_CalcDmg(gBattlerAttacker, gBattlerTarget);
+ TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
moveDmgs[checkedMove] = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[checkedMove] / 100;
if (moveDmgs[checkedMove] == 0)
moveDmgs[checkedMove] = 1;
@@ -1035,7 +1035,7 @@ static void BattleAICmd_is_most_powerful_move(void)
static void BattleAICmd_get_move(void)
{
if (gAIScriptPtr[1] == USER)
- AI_THINKING_STRUCT->funcResult = gLastUsedMove[sBattler_AI];
+ AI_THINKING_STRUCT->funcResult = gLastUsedMove[gBattlerAttacker];
else
AI_THINKING_STRUCT->funcResult = gLastUsedMove[gBattlerTarget];
@@ -1060,7 +1060,7 @@ static void BattleAICmd_if_arg_not_equal(void)
static void BattleAICmd_if_would_go_first(void)
{
- if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) == gAIScriptPtr[1])
+ if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) == gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
@@ -1068,7 +1068,7 @@ static void BattleAICmd_if_would_go_first(void)
static void BattleAICmd_if_would_not_go_first(void)
{
- if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) != gAIScriptPtr[1])
+ if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) != gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
@@ -1092,7 +1092,7 @@ static void BattleAICmd_count_alive_pokemon(void)
AI_THINKING_STRUCT->funcResult = 0;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1145,7 +1145,7 @@ static void BattleAICmd_get_ability(void)
u8 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1218,11 +1218,11 @@ static void BattleAICmd_get_highest_possible_damage(void)
for (i = 0; i < 4; i++)
{
gBattleMoveDamage = 40;
- gCurrentMove = gBattleMons[sBattler_AI].moves[i];
+ gCurrentMove = gBattleMons[gBattlerAttacker].moves[i];
if (gCurrentMove != 0)
{
- TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+ TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
if (gBattleMoveDamage == 120) // Super effective STAB.
gBattleMoveDamage = AI_EFFECTIVENESS_x2;
@@ -1257,7 +1257,7 @@ static void BattleAICmd_if_type_effectiveness(void)
gBattleMoveDamage = AI_EFFECTIVENESS_x1;
gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
- TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+ TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
if (gBattleMoveDamage == 120) // Super effective STAB.
gBattleMoveDamage = AI_EFFECTIVENESS_x2;
@@ -1402,7 +1402,7 @@ static void BattleAICmd_if_stat_level_less_than(void)
u32 party;
if (gAIScriptPtr[1] == USER)
- party = sBattler_AI;
+ party = gBattlerAttacker;
else
party = gBattlerTarget;
@@ -1417,7 +1417,7 @@ static void BattleAICmd_if_stat_level_more_than(void)
u32 party;
if (gAIScriptPtr[1] == USER)
- party = sBattler_AI;
+ party = gBattlerAttacker;
else
party = gBattlerTarget;
@@ -1432,7 +1432,7 @@ static void BattleAICmd_if_stat_level_equal(void)
u32 party;
if (gAIScriptPtr[1] == USER)
- party = sBattler_AI;
+ party = gBattlerAttacker;
else
party = gBattlerTarget;
@@ -1447,7 +1447,7 @@ static void BattleAICmd_if_stat_level_not_equal(void)
u32 party;
if (gAIScriptPtr[1] == USER)
- party = sBattler_AI;
+ party = gBattlerAttacker;
else
party = gBattlerTarget;
@@ -1471,8 +1471,8 @@ static void BattleAICmd_if_can_faint(void)
gMoveResultFlags = 0;
gCritMultiplier = 1;
gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
- AI_CalcDmg(sBattler_AI, gBattlerTarget);
- TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+ AI_CalcDmg(gBattlerAttacker, gBattlerTarget);
+ TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
@@ -1500,8 +1500,8 @@ static void BattleAICmd_if_cant_faint(void)
gMoveResultFlags = 0;
gCritMultiplier = 1;
gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
- AI_CalcDmg(sBattler_AI, gBattlerTarget);
- TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+ AI_CalcDmg(gBattlerAttacker, gBattlerTarget);
+ TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
@@ -1524,7 +1524,7 @@ static void BattleAICmd_if_has_move(void)
case 3:
for (i = 0; i < MAX_MON_MOVES; i++)
{
- if (gBattleMons[sBattler_AI].moves[i] == *temp_ptr)
+ if (gBattleMons[gBattlerAttacker].moves[i] == *temp_ptr)
break;
}
if (i == MAX_MON_MOVES)
@@ -1558,7 +1558,7 @@ static void BattleAICmd_if_dont_have_move(void)
case 3:
for (i = 0; i < MAX_MON_MOVES; i++)
{
- if (gBattleMons[sBattler_AI].moves[i] == *temp_ptr)
+ if (gBattleMons[gBattlerAttacker].moves[i] == *temp_ptr)
break;
}
if (i != MAX_MON_MOVES)
@@ -1591,7 +1591,7 @@ static void BattleAICmd_if_move_effect(void)
case 3:
for (i = 0; i < MAX_MON_MOVES; i++)
{
- if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
+ if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == gAIScriptPtr[2])
break;
}
if (i != MAX_MON_MOVES)
@@ -1603,7 +1603,7 @@ static void BattleAICmd_if_move_effect(void)
case 2:
for (i = 0; i < 8; i++)
{
- if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
+ if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
break;
}
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
@@ -1620,7 +1620,7 @@ static void BattleAICmd_if_not_move_effect(void)
case 3:
for (i = 0; i < MAX_MON_MOVES; i++)
{
- if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
+ if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == gAIScriptPtr[2])
break;
}
if (i != MAX_MON_MOVES)
@@ -1644,7 +1644,7 @@ static void BattleAICmd_if_last_move_did_damage(void)
u8 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1739,7 +1739,7 @@ static void BattleAICmd_get_hold_effect(void)
u16 side;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1759,7 +1759,7 @@ static void BattleAICmd_get_gender(void)
u8 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1773,7 +1773,7 @@ static void BattleAICmd_is_first_turn(void)
u8 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1787,7 +1787,7 @@ static void BattleAICmd_get_stockpile_count(void)
u8 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1808,7 +1808,7 @@ static void BattleAICmd_get_used_held_item(void)
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
- battlerId = sBattler_AI;
+ battlerId = gBattlerAttacker;
else
battlerId = gBattlerTarget;
@@ -1848,7 +1848,7 @@ static void BattleAICmd_get_protect_count(void)
u8 index;
if (gAIScriptPtr[1] == USER)
- index = sBattler_AI;
+ index = gBattlerAttacker;
else
index = gBattlerTarget;
@@ -1903,7 +1903,7 @@ static void BattleAICmd_if_level_compare(void)
switch (gAIScriptPtr[1])
{
case 0: // greater than
- if (gBattleMons[sBattler_AI].level > gBattleMons[gBattlerTarget].level)
+ if (gBattleMons[gBattlerAttacker].level > gBattleMons[gBattlerTarget].level)
{
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
return;
@@ -1911,7 +1911,7 @@ static void BattleAICmd_if_level_compare(void)
gAIScriptPtr += 6;
return;
case 1: // less than
- if (gBattleMons[sBattler_AI].level < gBattleMons[gBattlerTarget].level)
+ if (gBattleMons[gBattlerAttacker].level < gBattleMons[gBattlerTarget].level)
{
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
return;
@@ -1919,7 +1919,7 @@ static void BattleAICmd_if_level_compare(void)
gAIScriptPtr += 6;
return;
case 2: // equal
- if (gBattleMons[sBattler_AI].level == gBattleMons[gBattlerTarget].level)
+ if (gBattleMons[gBattlerAttacker].level == gBattleMons[gBattlerTarget].level)
{
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
return;
diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c
index 5a2f20ef4..b3c6ab2e5 100644
--- a/src/battle_controller_safari.c
+++ b/src/battle_controller_safari.c
@@ -176,16 +176,16 @@ static void HandleInputChooseAction(void)
switch (gActionSelectionCursor[gActiveBattler])
{
case 0:
- EmitTwoReturnValues(1, B_ACTION_SAFARI_BALL, 0);
+ BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_BALL, 0);
break;
case 1:
- EmitTwoReturnValues(1, B_ACTION_SAFARI_POKEBLOCK, 0);
+ BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_POKEBLOCK, 0);
break;
case 2:
- EmitTwoReturnValues(1, B_ACTION_SAFARI_GO_NEAR, 0);
+ BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_GO_NEAR, 0);
break;
case 3:
- EmitTwoReturnValues(1, B_ACTION_SAFARI_RUN, 0);
+ BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_RUN, 0);
break;
}
SafariBufferExecCompleted();
@@ -276,7 +276,7 @@ static void CompleteWhenChosePokeblock(void)
{
if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
{
- EmitOneReturnValue(1, gSpecialVar_ItemId);
+ BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
SafariBufferExecCompleted();
}
}
diff --git a/src/battle_controllers.c b/src/battle_controllers.c
new file mode 100644
index 000000000..20c934a0c
--- /dev/null
+++ b/src/battle_controllers.c
@@ -0,0 +1,1171 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_2.h"
+#include "battle_ai_script_commands.h"
+#include "battle_anim.h"
+#include "battle_util.h"
+#include "battle_controllers.h"
+#include "battle_message.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "cable_club.h"
+#include "party_menu.h"
+#include "pokemon.h"
+#include "task.h"
+#include "util.h"
+#include "constants/abilities.h"
+#include "constants/species.h"
+#include "constants/battle.h"
+
+static EWRAM_DATA u8 sLinkSendTaskId = 0;
+static EWRAM_DATA u8 sLinkReceiveTaskId = 0;
+static EWRAM_DATA u8 gUnknown_202286E = 0;
+EWRAM_DATA struct UnusedControllerStruct gUnknown_2022870 = {0};
+static EWRAM_DATA u8 sBattleBuffersTransferData[0x100] = {0};
+
+static void CreateTasksForSendRecvLinkBuffers(void);
+static void InitLinkBtlControllers(void);
+static void InitSinglePlayerBtlControllers(void);
+static void SetBattlePartyIds(void);
+static void Task_HandleSendLinkBuffersData(u8 taskId);
+static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId);
+
+void HandleLinkBattleSetup(void)
+{
+ if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+ {
+ if (gWirelessCommType)
+ sub_800B1F4();
+ if (!gReceivedRemoteLinkPlayers)
+ OpenLink();
+ CreateTask(sub_8081A90, 0);
+ CreateTasksForSendRecvLinkBuffers();
+ }
+}
+
+void SetUpBattleVars(void)
+{
+ s32 i;
+
+ gBattleMainFunc = nullsub_12;
+ for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+ {
+ gBattlerControllerFuncs[i] = nullsub_13;
+ gBattlerPositions[i] = 0xFF;
+ gActionSelectionCursor[i] = 0;
+ gMoveSelectionCursor[i] = 0;
+ }
+ HandleLinkBattleSetup();
+ gBattleControllerExecFlags = 0;
+ ClearBattleAnimationVars();
+ ClearBattleMonForms();
+ BattleAI_HandleItemUseBeforeAISetup();
+ gUnknown_2022B54 = 0;
+ gUnknown_2023DDC = 0;
+}
+
+void sub_800D30C(void)
+{
+ s32 i;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+ InitLinkBtlControllers();
+ else
+ InitSinglePlayerBtlControllers();
+ SetBattlePartyIds();
+ if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+ for (i = 0; i < gBattlersCount; ++i)
+ sub_8127DA8(i, 0);
+}
+
+static void InitSinglePlayerBtlControllers(void)
+{
+ if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+ {
+ gBattleMainFunc = BeginBattleIntro;
+ if (gBattleTypeFlags & BATTLE_TYPE_POKEDUDE)
+ {
+ gBattlerControllerFuncs[0] = SetControllerToPokedude;
+ gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[1] = SetControllerToPokedude;
+ gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+ gBattlersCount = 2;
+ }
+ else
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+ gBattlerControllerFuncs[0] = SetControllerToSafari;
+ else if (gBattleTypeFlags & (BATTLE_TYPE_OLDMAN_TUTORIAL | BATTLE_TYPE_FIRST_BATTLE))
+ gBattlerControllerFuncs[0] = SetControllerToOakOrOldman;
+ else
+ gBattlerControllerFuncs[0] = SetControllerToPlayer;
+ gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[1] = SetControllerToOpponent;
+ gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+ gBattlersCount = 2;
+ }
+ }
+ else
+ {
+ gBattleMainFunc = BeginBattleIntro;
+ if (gBattleTypeFlags & BATTLE_TYPE_POKEDUDE)
+ {
+ gBattlerControllerFuncs[0] = SetControllerToPokedude;
+ gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[1] = SetControllerToPokedude;
+ gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+ gBattlerControllerFuncs[2] = SetControllerToPokedude;
+ gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
+ gBattlerControllerFuncs[3] = SetControllerToPokedude;
+ gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
+ gBattlersCount = MAX_BATTLERS_COUNT;
+ }
+ else
+ {
+ gBattlerControllerFuncs[0] = SetControllerToPlayer;
+ gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[1] = SetControllerToOpponent;
+ gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+ gBattlerControllerFuncs[2] = SetControllerToPlayer;
+ gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
+ gBattlerControllerFuncs[3] = SetControllerToOpponent;
+ gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
+ gBattlersCount = MAX_BATTLERS_COUNT;
+ }
+ }
+}
+
+static void InitLinkBtlControllers(void)
+{
+ s32 i;
+ u8 multiplayerId;
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+ gBattlerControllerFuncs[0] = SetControllerToPlayer;
+ gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[1] = SetControllerToLinkOpponent;
+ gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+ gBattlersCount = 2;
+ }
+ else
+ {
+ gBattlerControllerFuncs[1] = SetControllerToPlayer;
+ gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[0] = SetControllerToLinkOpponent;
+ gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
+ gBattlersCount = 2;
+ }
+ }
+ else if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && (gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+ gBattlerControllerFuncs[0] = SetControllerToPlayer;
+ gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[1] = SetControllerToLinkOpponent;
+ gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+ gBattlerControllerFuncs[2] = SetControllerToPlayer;
+ gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
+ gBattlerControllerFuncs[3] = SetControllerToLinkOpponent;
+ gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
+ gBattlersCount = MAX_BATTLERS_COUNT;
+ }
+ else
+ {
+ gBattlerControllerFuncs[1] = SetControllerToPlayer;
+ gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
+ gBattlerControllerFuncs[0] = SetControllerToLinkOpponent;
+ gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
+ gBattlerControllerFuncs[3] = SetControllerToPlayer;
+ gBattlerPositions[3] = B_POSITION_PLAYER_RIGHT;
+ gBattlerControllerFuncs[2] = SetControllerToLinkOpponent;
+ gBattlerPositions[2] = B_POSITION_OPPONENT_RIGHT;
+ gBattlersCount = MAX_BATTLERS_COUNT;
+ }
+ }
+ else
+ {
+ multiplayerId = GetMultiplayerId();
+ if (gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)
+ gBattleMainFunc = BeginBattleIntro;
+
+ for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+ {
+ switch (gLinkPlayers[i].id)
+ {
+ case 0:
+ case 3:
+ sub_8127DA8(gLinkPlayers[i].id, 0);
+ break;
+ case 1:
+ case 2:
+ sub_8127DA8(gLinkPlayers[i].id, 1);
+ break;
+ }
+ if (i == multiplayerId)
+ {
+ gBattlerControllerFuncs[gLinkPlayers[i].id] = SetControllerToPlayer;
+ switch (gLinkPlayers[i].id)
+ {
+ case 0:
+ case 3:
+ gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+ gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+ break;
+ case 1:
+ case 2:
+ gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_RIGHT;
+ gBattlerPartyIndexes[gLinkPlayers[i].id] = 3;
+ break;
+ }
+ }
+ else
+ {
+ if ((!(gLinkPlayers[i].id & 1) && !(gLinkPlayers[multiplayerId].id & 1)) || ((gLinkPlayers[i].id & 1) && (gLinkPlayers[multiplayerId].id & 1)))
+ {
+ gBattlerControllerFuncs[gLinkPlayers[i].id] = SetControllerToLinkPartner;
+ switch (gLinkPlayers[i].id)
+ {
+ case 0:
+ case 3:
+ gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+ gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+ break;
+ case 1:
+ case 2:
+ gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_RIGHT;
+ gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_OPPONENT_RIGHT;
+ break;
+ }
+ }
+ else
+ {
+ gBattlerControllerFuncs[gLinkPlayers[i].id] = SetControllerToLinkOpponent;
+ switch (gLinkPlayers[i].id)
+ {
+ case 0:
+ case 3:
+ gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_OPPONENT_LEFT;
+ gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+ break;
+ case 1:
+ case 2:
+ gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_OPPONENT_RIGHT;
+ gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_OPPONENT_RIGHT;
+ break;
+ }
+ }
+ }
+ }
+ gBattlersCount = MAX_BATTLERS_COUNT;
+ }
+}
+
+static void SetBattlePartyIds(void)
+{
+ s32 i, j;
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+ {
+ for (i = 0; i < gBattlersCount; ++i)
+ {
+ for (j = 0; j < PARTY_SIZE; ++j)
+ {
+ if (i < 2)
+ {
+ if (GET_BATTLER_SIDE2(i) == B_SIDE_PLAYER)
+ {
+ if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && !GetMonData(&gPlayerParty[j], MON_DATA_IS_EGG))
+ {
+ gBattlerPartyIndexes[i] = j;
+ break;
+ }
+ }
+ else
+ {
+ if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && !GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG))
+ {
+ gBattlerPartyIndexes[i] = j;
+ break;
+ }
+ }
+ }
+ else
+ {
+ if (GET_BATTLER_SIDE2(i) == B_SIDE_PLAYER)
+ {
+ if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES) != SPECIES_NONE // Probably a typo by Game Freak. The rest use SPECIES2.
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && !GetMonData(&gPlayerParty[j], MON_DATA_IS_EGG)
+ && gBattlerPartyIndexes[i - 2] != j)
+ {
+ gBattlerPartyIndexes[i] = j;
+ break;
+ }
+ }
+ else
+ {
+ if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && !GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG)
+ && gBattlerPartyIndexes[i - 2] != j)
+ {
+ gBattlerPartyIndexes[i] = j;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+static void PrepareBufferDataTransfer(u8 bufferId, u8 *data, u16 size)
+{
+ s32 i;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+ {
+ PrepareBufferDataTransferLink(bufferId, size, data);
+ }
+ else
+ {
+ switch (bufferId)
+ {
+ case 0:
+ for (i = 0; i < size; ++data, ++i)
+ gBattleBufferA[gActiveBattler][i] = *data;
+ break;
+ case 1:
+ for (i = 0; i < size; ++data, ++i)
+ gBattleBufferB[gActiveBattler][i] = *data;
+ break;
+ }
+ }
+}
+
+static void CreateTasksForSendRecvLinkBuffers(void)
+{
+ sLinkSendTaskId = CreateTask(Task_HandleSendLinkBuffersData, 0);
+ gTasks[sLinkSendTaskId].data[11] = 0;
+ gTasks[sLinkSendTaskId].data[12] = 0;
+ gTasks[sLinkSendTaskId].data[13] = 0;
+ gTasks[sLinkSendTaskId].data[14] = 0;
+ gTasks[sLinkSendTaskId].data[15] = 0;
+ sLinkReceiveTaskId = CreateTask(Task_HandleCopyReceivedLinkBuffersData, 0);
+ gTasks[sLinkReceiveTaskId].data[12] = 0;
+ gTasks[sLinkReceiveTaskId].data[13] = 0;
+ gTasks[sLinkReceiveTaskId].data[14] = 0;
+ gTasks[sLinkReceiveTaskId].data[15] = 0;
+ gUnknown_202286E = 0;
+}
+
+enum
+{
+ LINK_BUFF_BUFFER_ID,
+ LINK_BUFF_ACTIVE_BATTLER,
+ LINK_BUFF_ATTACKER,
+ LINK_BUFF_TARGET,
+ LINK_BUFF_SIZE_LO,
+ LINK_BUFF_SIZE_HI,
+ LINK_BUFF_ABSENT_BATTLER_FLAGS,
+ LINK_BUFF_EFFECT_BATTLER,
+ LINK_BUFF_DATA,
+};
+
+void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data)
+{
+ s32 alignedSize, i;
+
+ alignedSize = size - size % 4 + 4;
+ if (gTasks[sLinkSendTaskId].data[14] + alignedSize + LINK_BUFF_DATA + 1 > BATTLE_BUFFER_LINK_SIZE)
+ {
+ gTasks[sLinkSendTaskId].data[12] = gTasks[sLinkSendTaskId].data[14];
+ gTasks[sLinkSendTaskId].data[14] = 0;
+ }
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_BUFFER_ID] = bufferId;
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ACTIVE_BATTLER] = gActiveBattler;
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ATTACKER] = gBattlerAttacker;
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_TARGET] = gBattlerTarget;
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_SIZE_LO] = alignedSize;
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_SIZE_HI] = (alignedSize & 0x0000FF00) >> 8;
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ABSENT_BATTLER_FLAGS] = gAbsentBattlerFlags;
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_EFFECT_BATTLER] = gEffectBattler;
+ for (i = 0; i < size; ++i)
+ gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_DATA + i] = data[i];
+ gTasks[sLinkSendTaskId].data[14] = gTasks[sLinkSendTaskId].data[14] + alignedSize + LINK_BUFF_DATA;
+}
+
+static void Task_HandleSendLinkBuffersData(u8 taskId)
+{
+ u16 blockSize;
+ s32 playerCount;
+
+ switch (gTasks[taskId].data[11])
+ {
+ case 0:
+ gTasks[taskId].data[10] = 100;
+ ++gTasks[taskId].data[11];
+ break;
+ case 1:
+ if (!--gTasks[taskId].data[10])
+ {
+ ++gTasks[taskId].data[11];
+ if (gReceivedRemoteLinkPlayers)
+ gTasks[taskId].data[11] = 3;
+ }
+ break;
+ case 2:
+ playerCount = GetLinkPlayerCount_2();
+ if ((gBattleTypeFlags & BATTLE_TYPE_MULTI && playerCount > 3) || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && playerCount > 1))
+ {
+ if (IsLinkMaster())
+ {
+ CheckShouldAdvanceLinkState();
+ ++gTasks[taskId].data[11];
+ }
+ else
+ {
+ ++gTasks[taskId].data[11];
+ }
+ }
+ break;
+ case 3:
+ if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
+ {
+ if (!gTasks[taskId].data[13])
+ {
+ if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
+ && gTasks[taskId].data[15] == gTasks[taskId].data[12])
+ {
+ gTasks[taskId].data[12] = 0;
+ gTasks[taskId].data[15] = 0;
+ }
+ blockSize = (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8)) + LINK_BUFF_DATA;
+ SendBlock(bitmask_all_link_players_but_self(), &gLinkBattleSendBuffer[gTasks[taskId].data[15]], blockSize);
+ ++gTasks[taskId].data[11];
+ }
+ else
+ {
+ --gTasks[taskId].data[13];
+ break;
+ }
+ }
+ break;
+ case 4:
+ if (IsLinkTaskFinished())
+ {
+ blockSize = gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8);
+ gTasks[taskId].data[13] = 5;
+ gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
+ gTasks[taskId].data[11] = 3;
+ }
+ break;
+ case 5:
+ if (!--gTasks[taskId].data[13])
+ {
+ gTasks[taskId].data[13] = 5;
+ gTasks[taskId].data[11] = 3;
+ }
+ break;
+ }
+}
+
+void sub_800DD28(void)
+{
+ u8 i;
+ s32 j;
+ u16 r6;
+ u8 *recvBuffer, *dest, *src;
+
+ if (gReceivedRemoteLinkPlayers && (gBattleTypeFlags & BATTLE_TYPE_20) && (gLinkPlayers[0].linkType == 0x2211))
+ {
+ sub_80FBB4C();
+ for (i = 0; i < GetLinkPlayerCount(); ++i)
+ {
+ if (GetBlockReceivedStatus() & gBitTable[i])
+ {
+ ResetBlockReceivedFlag(i);
+ recvBuffer = (u8 *)gBlockRecvBuffer[i];
+ {
+ r6 = gBlockRecvBuffer[i][2];
+ if (gTasks[sLinkReceiveTaskId].data[14] + 9 + r6 > 0x1000)
+ {
+ gTasks[sLinkReceiveTaskId].data[12] = gTasks[sLinkReceiveTaskId].data[14];
+ gTasks[sLinkReceiveTaskId].data[14] = 0;
+ }
+ dest = &gLinkBattleRecvBuffer[gTasks[sLinkReceiveTaskId].data[14]];
+ src = recvBuffer;
+ for (j = 0; j < r6 + 8; ++j)
+ dest[j] = src[j];
+ }
+ gTasks[sLinkReceiveTaskId].data[14] = gTasks[sLinkReceiveTaskId].data[14] + r6 + 8;
+ }
+ }
+ }
+}
+
+static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
+{
+ u16 blockSize;
+ u8 battlerId;
+ u8 var;
+
+ if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
+ {
+ if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
+ && gTasks[taskId].data[15] == gTasks[taskId].data[12])
+ {
+ gTasks[taskId].data[12] = 0;
+ gTasks[taskId].data[15] = 0;
+ }
+ battlerId = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_ACTIVE_BATTLER];
+ blockSize = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8);
+ switch (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 0])
+ {
+ case 0:
+ if (gBattleControllerExecFlags & gBitTable[battlerId])
+ return;
+ memcpy(gBattleBufferA[battlerId], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA], blockSize);
+ sub_8017298(battlerId);
+ if (!(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER))
+ {
+ gBattlerAttacker = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_ATTACKER];
+ gBattlerTarget = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_TARGET];
+ gAbsentBattlerFlags = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_ABSENT_BATTLER_FLAGS];
+ gEffectBattler = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_EFFECT_BATTLER];
+ }
+ break;
+ case 1:
+ memcpy(gBattleBufferB[battlerId], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA], blockSize);
+ break;
+ case 2:
+ var = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA];
+ gBattleControllerExecFlags &= ~(gBitTable[battlerId] << (var * 4));
+ break;
+ }
+ gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
+ }
+}
+
+void BtlController_EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA;
+ sBattleBuffersTransferData[1] = requestId;
+ sBattleBuffersTransferData[2] = monToCheck;
+ sBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_GETRAWMONDATA;
+ sBattleBuffersTransferData[1] = monId;
+ sBattleBuffersTransferData[2] = bytes;
+ sBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_SETMONDATA;
+ sBattleBuffersTransferData[1] = requestId;
+ sBattleBuffersTransferData[2] = monToCheck;
+ for (i = 0; i < bytes; ++i)
+ sBattleBuffersTransferData[3 + i] = *(u8 *)(data++);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 3 + bytes);
+}
+
+// not used
+static void BtlController_EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_SETRAWMONDATA;
+ sBattleBuffersTransferData[1] = monId;
+ sBattleBuffersTransferData[2] = bytes;
+ for (i = 0; i < bytes; ++i)
+ sBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, bytes + 3);
+}
+
+void BtlController_EmitLoadMonSprite(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_LOADMONSPRITE;
+ sBattleBuffersTransferData[1] = CONTROLLER_LOADMONSPRITE;
+ sBattleBuffersTransferData[2] = CONTROLLER_LOADMONSPRITE;
+ sBattleBuffersTransferData[3] = CONTROLLER_LOADMONSPRITE;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_SWITCHINANIM;
+ sBattleBuffersTransferData[1] = partyId;
+ sBattleBuffersTransferData[2] = dontClearSubstituteBit;
+ sBattleBuffersTransferData[3] = 5;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitReturnMonToBall(u8 bufferId, u8 arg1)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_RETURNMONTOBALL;
+ sBattleBuffersTransferData[1] = arg1;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitDrawTrainerPic(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_DRAWTRAINERPIC;
+ sBattleBuffersTransferData[1] = CONTROLLER_DRAWTRAINERPIC;
+ sBattleBuffersTransferData[2] = CONTROLLER_DRAWTRAINERPIC;
+ sBattleBuffersTransferData[3] = CONTROLLER_DRAWTRAINERPIC;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitTrainerSlide(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDE;
+ sBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDE;
+ sBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDE;
+ sBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDE;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitTrainerSlideBack(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDEBACK;
+ sBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDEBACK;
+ sBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDEBACK;
+ sBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDEBACK;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitFaintAnimation(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_FAINTANIMATION;
+ sBattleBuffersTransferData[1] = CONTROLLER_FAINTANIMATION;
+ sBattleBuffersTransferData[2] = CONTROLLER_FAINTANIMATION;
+ sBattleBuffersTransferData[3] = CONTROLLER_FAINTANIMATION;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitPaletteFade(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_PALETTEFADE;
+ sBattleBuffersTransferData[1] = CONTROLLER_PALETTEFADE;
+ sBattleBuffersTransferData[2] = CONTROLLER_PALETTEFADE;
+ sBattleBuffersTransferData[3] = CONTROLLER_PALETTEFADE;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitSuccessBallThrowAnim(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_SUCCESSBALLTHROWANIM;
+ sBattleBuffersTransferData[1] = CONTROLLER_SUCCESSBALLTHROWANIM;
+ sBattleBuffersTransferData[2] = CONTROLLER_SUCCESSBALLTHROWANIM;
+ sBattleBuffersTransferData[3] = CONTROLLER_SUCCESSBALLTHROWANIM;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitBallThrowAnim(u8 bufferId, u8 caseId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_BALLTHROWANIM;
+ sBattleBuffersTransferData[1] = caseId;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+// not used
+static void BtlController_EmitPause(u8 bufferId, u8 toWait, void *data)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_PAUSE;
+ sBattleBuffersTransferData[1] = toWait;
+ for (i = 0; i < toWait * 3; ++i)
+ sBattleBuffersTransferData[2 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, toWait * 3 + 2);
+}
+
+void BtlController_EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_MOVEANIMATION;
+ sBattleBuffersTransferData[1] = move;
+ sBattleBuffersTransferData[2] = (move & 0xFF00) >> 8;
+ sBattleBuffersTransferData[3] = turnOfMove;
+ sBattleBuffersTransferData[4] = movePower;
+ sBattleBuffersTransferData[5] = (movePower & 0xFF00) >> 8;
+ sBattleBuffersTransferData[6] = dmg;
+ sBattleBuffersTransferData[7] = (dmg & 0x0000FF00) >> 8;
+ sBattleBuffersTransferData[8] = (dmg & 0x00FF0000) >> 16;
+ sBattleBuffersTransferData[9] = (dmg & 0xFF000000) >> 24;
+ sBattleBuffersTransferData[10] = friendship;
+ sBattleBuffersTransferData[11] = gUnknown_2023D72; // multihit in pokeem
+ if (WEATHER_HAS_EFFECT2)
+ {
+ sBattleBuffersTransferData[12] = gBattleWeather;
+ sBattleBuffersTransferData[13] = (gBattleWeather & 0xFF00) >> 8;
+ }
+ else
+ {
+ sBattleBuffersTransferData[12] = 0;
+ sBattleBuffersTransferData[13] = 0;
+ }
+ sBattleBuffersTransferData[14] = 0;
+ sBattleBuffersTransferData[15] = 0;
+ memcpy(&sBattleBuffersTransferData[16], disableStructPtr, sizeof(struct DisableStruct));
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 16 + sizeof(struct DisableStruct));
+}
+
+void BtlController_EmitPrintString(u8 bufferId, u16 stringID)
+{
+ s32 i;
+ struct BattleMsgData *stringInfo;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRING;
+ sBattleBuffersTransferData[1] = gBattleOutcome;
+ sBattleBuffersTransferData[2] = stringID;
+ sBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8;
+ stringInfo = (struct BattleMsgData *)(&sBattleBuffersTransferData[4]);
+ stringInfo->currentMove = gCurrentMove;
+ stringInfo->originallyUsedMove = gChosenMove;
+ stringInfo->lastItem = gLastUsedItem;
+ stringInfo->lastAbility = gLastUsedAbility;
+ stringInfo->scrActive = gBattleScripting.battler;
+ stringInfo->unk1605E = gBattleStruct->field_52;
+ stringInfo->hpScale = gBattleStruct->hpScale;
+ stringInfo->itemEffectBattler = gPotentialItemEffectBattler;
+ stringInfo->moveType = gBattleMoves[gCurrentMove].type;
+ for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+ stringInfo->abilities[i] = gBattleMons[i].ability;
+ for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; ++i)
+ {
+ stringInfo->textBuffs[0][i] = gBattleTextBuff1[i];
+ stringInfo->textBuffs[1][i] = gBattleTextBuff2[i];
+ stringInfo->textBuffs[2][i] = gBattleTextBuff3[i];
+ }
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct BattleMsgData) + 4);
+}
+
+void BtlController_EmitPrintSelectionString(u8 bufferId, u16 stringID)
+{
+ s32 i;
+ struct BattleMsgData *stringInfo;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRINGPLAYERONLY;
+ sBattleBuffersTransferData[1] = CONTROLLER_PRINTSTRINGPLAYERONLY;
+ sBattleBuffersTransferData[2] = stringID;
+ sBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8;
+
+ stringInfo = (struct BattleMsgData*)(&sBattleBuffersTransferData[4]);
+ stringInfo->currentMove = gCurrentMove;
+ stringInfo->originallyUsedMove = gChosenMove;
+ stringInfo->lastItem = gLastUsedItem;
+ stringInfo->lastAbility = gLastUsedAbility;
+ stringInfo->scrActive = gBattleScripting.battler;
+ stringInfo->unk1605E = gBattleStruct->field_52;
+ for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+ stringInfo->abilities[i] = gBattleMons[i].ability;
+ for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; ++i)
+ {
+ stringInfo->textBuffs[0][i] = gBattleTextBuff1[i];
+ stringInfo->textBuffs[1][i] = gBattleTextBuff2[i];
+ stringInfo->textBuffs[2][i] = gBattleTextBuff3[i];
+ }
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct BattleMsgData) + 4);
+}
+
+void BtlController_EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEACTION;
+ sBattleBuffersTransferData[1] = arg1;
+ sBattleBuffersTransferData[2] = arg2;
+ sBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitUnknownYesNoBox(u8 bufferId, u32 arg1) // TODO: Does the function name make sense for pokefirered?
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_UNKNOWNYESNOBOX;
+ sBattleBuffersTransferData[1] = arg1;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEMOVE;
+ sBattleBuffersTransferData[1] = isDoubleBattle;
+ sBattleBuffersTransferData[2] = NoPpNumber;
+ sBattleBuffersTransferData[3] = 0;
+ for (i = 0; i < sizeof(*movePpData); ++i)
+ sBattleBuffersTransferData[4 + i] = *((u8*)(movePpData) + i);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(*movePpData) + 4);
+}
+
+void BtlController_EmitChooseItem(u8 bufferId, u8 *arg1)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_OPENBAG;
+ for (i = 0; i < 3; ++i)
+ sBattleBuffersTransferData[1 + i] = arg1[i];
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitChoosePokemon(u8 bufferId, u8 caseId, u8 arg2, u8 abilityId, u8 *arg4)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEPOKEMON;
+ sBattleBuffersTransferData[1] = caseId;
+ sBattleBuffersTransferData[2] = arg2;
+ sBattleBuffersTransferData[3] = abilityId;
+ for (i = 0; i < 3; ++i)
+ sBattleBuffersTransferData[4 + i] = arg4[i];
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 8); // Only 7 bytes were written.
+}
+
+// not used
+static void BtlController_EmitCmd23(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_23;
+ sBattleBuffersTransferData[1] = CONTROLLER_23;
+ sBattleBuffersTransferData[2] = CONTROLLER_23;
+ sBattleBuffersTransferData[3] = CONTROLLER_23;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitHealthBarUpdate(u8 bufferId, u16 hpValue)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_HEALTHBARUPDATE;
+ sBattleBuffersTransferData[1] = 0;
+ sBattleBuffersTransferData[2] = (s16)hpValue;
+ sBattleBuffersTransferData[3] = ((s16)hpValue & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitExpUpdate(u8 bufferId, u8 partyId, u16 expPoints)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_EXPUPDATE;
+ sBattleBuffersTransferData[1] = partyId;
+ sBattleBuffersTransferData[2] = (s16)expPoints;
+ sBattleBuffersTransferData[3] = ((s16)expPoints & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_STATUSICONUPDATE;
+ sBattleBuffersTransferData[1] = status1;
+ sBattleBuffersTransferData[2] = (status1 & 0x0000FF00) >> 8;
+ sBattleBuffersTransferData[3] = (status1 & 0x00FF0000) >> 16;
+ sBattleBuffersTransferData[4] = (status1 & 0xFF000000) >> 24;
+ sBattleBuffersTransferData[5] = status2;
+ sBattleBuffersTransferData[6] = (status2 & 0x0000FF00) >> 8;
+ sBattleBuffersTransferData[7] = (status2 & 0x00FF0000) >> 16;
+ sBattleBuffersTransferData[8] = (status2 & 0xFF000000) >> 24;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 9);
+}
+
+void BtlController_EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_STATUSANIMATION;
+ sBattleBuffersTransferData[1] = status2;
+ sBattleBuffersTransferData[2] = status;
+ sBattleBuffersTransferData[3] = (status & 0x0000FF00) >> 8;
+ sBattleBuffersTransferData[4] = (status & 0x00FF0000) >> 16;
+ sBattleBuffersTransferData[5] = (status & 0xFF000000) >> 24;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 6);
+}
+
+// not used
+static void BtlController_EmitStatusXor(u8 bufferId, u8 b)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_STATUSXOR;
+ sBattleBuffersTransferData[1] = b;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitDataTransfer(u8 bufferId, u16 size, void *data)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_DATATRANSFER;
+ sBattleBuffersTransferData[1] = CONTROLLER_DATATRANSFER;
+ sBattleBuffersTransferData[2] = size;
+ sBattleBuffersTransferData[3] = (size & 0xFF00) >> 8;
+ for (i = 0; i < size; ++i)
+ sBattleBuffersTransferData[4 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 4);
+}
+
+// not used
+static void BtlController_EmitDMA3Transfer(u8 bufferId, void *dst, u16 size, void *data)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_DMA3TRANSFER;
+ sBattleBuffersTransferData[1] = (u32)(dst);
+ sBattleBuffersTransferData[2] = ((u32)(dst) & 0x0000FF00) >> 8;
+ sBattleBuffersTransferData[3] = ((u32)(dst) & 0x00FF0000) >> 16;
+ sBattleBuffersTransferData[4] = ((u32)(dst) & 0xFF000000) >> 24;
+ sBattleBuffersTransferData[5] = size;
+ sBattleBuffersTransferData[6] = (size & 0xFF00) >> 8;
+ for (i = 0; i < size; ++i)
+ sBattleBuffersTransferData[7 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 7);
+}
+
+// not used
+static void BtlController_EmitPlayBGM(u8 bufferId, u16 songId, void *unusedDumbDataParameter)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_31;
+ sBattleBuffersTransferData[1] = songId;
+ sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+ for (i = 0; i < songId; ++i)
+ sBattleBuffersTransferData[3 + i] = *(u8*)(unusedDumbDataParameter++);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, songId + 3);
+}
+
+// not used
+static void BtlController_EmitCmd32(u8 bufferId, u16 size, void *data)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_32;
+ sBattleBuffersTransferData[1] = size;
+ sBattleBuffersTransferData[2] = (size & 0xFF00) >> 8;
+ for (i = 0; i < size; ++i)
+ sBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 3);
+}
+
+void BtlController_EmitTwoReturnValues(u8 bufferId, u8 arg1, u16 arg2)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_TWORETURNVALUES;
+ sBattleBuffersTransferData[1] = arg1;
+ sBattleBuffersTransferData[2] = arg2;
+ sBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitChosenMonReturnValue(u8 bufferId, u8 b, u8 *c)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_CHOSENMONRETURNVALUE;
+ sBattleBuffersTransferData[1] = b;
+ for (i = 0; i < 3; ++i)
+ sBattleBuffersTransferData[2 + i] = c[i];
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 5);
+}
+
+void BtlController_EmitOneReturnValue(u8 bufferId, u16 arg1)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE;
+ sBattleBuffersTransferData[1] = arg1;
+ sBattleBuffersTransferData[2] = (arg1 & 0xFF00) >> 8;
+ sBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitOneReturnValue_Duplicate(u8 bufferId, u16 b)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE_DUPLICATE;
+ sBattleBuffersTransferData[1] = b;
+ sBattleBuffersTransferData[2] = (b & 0xFF00) >> 8;
+ sBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitCmd37(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_37;
+ sBattleBuffersTransferData[1] = CONTROLLER_37;
+ sBattleBuffersTransferData[2] = CONTROLLER_37;
+ sBattleBuffersTransferData[3] = CONTROLLER_37;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitCmd38(u8 bufferId, u8 b)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_38;
+ sBattleBuffersTransferData[1] = b;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+// not used
+static void BtlController_EmitCmd39(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_39;
+ sBattleBuffersTransferData[1] = CONTROLLER_39;
+ sBattleBuffersTransferData[2] = CONTROLLER_39;
+ sBattleBuffersTransferData[3] = CONTROLLER_39;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitCmd40(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_40;
+ sBattleBuffersTransferData[1] = CONTROLLER_40;
+ sBattleBuffersTransferData[2] = CONTROLLER_40;
+ sBattleBuffersTransferData[3] = CONTROLLER_40;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitHitAnimation(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_HITANIMATION;
+ sBattleBuffersTransferData[1] = CONTROLLER_HITANIMATION;
+ sBattleBuffersTransferData[2] = CONTROLLER_HITANIMATION;
+ sBattleBuffersTransferData[3] = CONTROLLER_HITANIMATION;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitCmd42(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_42;
+ sBattleBuffersTransferData[1] = CONTROLLER_42;
+ sBattleBuffersTransferData[2] = CONTROLLER_42;
+ sBattleBuffersTransferData[3] = CONTROLLER_42;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitPlaySE(u8 bufferId, u16 songId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_EFFECTIVENESSSOUND;
+ sBattleBuffersTransferData[1] = songId;
+ sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+ sBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitPlayFanfare(u8 bufferId, u16 songId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_PLAYFANFAREORBGM;
+ sBattleBuffersTransferData[1] = songId;
+ sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+ sBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitFaintingCry(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_FAINTINGCRY;
+ sBattleBuffersTransferData[1] = CONTROLLER_FAINTINGCRY;
+ sBattleBuffersTransferData[2] = CONTROLLER_FAINTINGCRY;
+ sBattleBuffersTransferData[3] = CONTROLLER_FAINTINGCRY;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitIntroSlide(u8 bufferId, u8 terrainId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_INTROSLIDE;
+ sBattleBuffersTransferData[1] = terrainId;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitIntroTrainerBallThrow(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_INTROTRAINERBALLTHROW;
+ sBattleBuffersTransferData[1] = CONTROLLER_INTROTRAINERBALLTHROW;
+ sBattleBuffersTransferData[2] = CONTROLLER_INTROTRAINERBALLTHROW;
+ sBattleBuffersTransferData[3] = CONTROLLER_INTROTRAINERBALLTHROW;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 arg2)
+{
+ s32 i;
+
+ sBattleBuffersTransferData[0] = CONTROLLER_DRAWPARTYSTATUSSUMMARY;
+ sBattleBuffersTransferData[1] = arg2 & 0x7F;
+ sBattleBuffersTransferData[2] = (arg2 & 0x80) >> 7;
+ sBattleBuffersTransferData[3] = CONTROLLER_DRAWPARTYSTATUSSUMMARY;
+ for (i = 0; i < (s32)(sizeof(struct HpAndStatus) * PARTY_SIZE); ++i)
+ sBattleBuffersTransferData[4 + i] = *(i + (u8*)(hpAndStatus));
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct HpAndStatus) * PARTY_SIZE + 4);
+}
+
+void BtlController_EmitHidePartyStatusSummary(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+ sBattleBuffersTransferData[1] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+ sBattleBuffersTransferData[2] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+ sBattleBuffersTransferData[3] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitEndBounceEffect(u8 bufferId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_ENDBOUNCE;
+ sBattleBuffersTransferData[1] = CONTROLLER_ENDBOUNCE;
+ sBattleBuffersTransferData[2] = CONTROLLER_ENDBOUNCE;
+ sBattleBuffersTransferData[3] = CONTROLLER_ENDBOUNCE;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_SPRITEINVISIBILITY;
+ sBattleBuffersTransferData[1] = isInvisible;
+ sBattleBuffersTransferData[2] = CONTROLLER_SPRITEINVISIBILITY;
+ sBattleBuffersTransferData[3] = CONTROLLER_SPRITEINVISIBILITY;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_BATTLEANIMATION;
+ sBattleBuffersTransferData[1] = animationId;
+ sBattleBuffersTransferData[2] = argument;
+ sBattleBuffersTransferData[3] = (argument & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitLinkStandbyMsg(u8 bufferId, u8 arg1)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_LINKSTANDBYMSG;
+ sBattleBuffersTransferData[1] = arg1;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitResetActionMoveSelection(u8 bufferId, u8 caseId)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_RESETACTIONMOVESELECTION;
+ sBattleBuffersTransferData[1] = caseId;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitCmd55(u8 bufferId, u8 battleOutcome)
+{
+ sBattleBuffersTransferData[0] = CONTROLLER_55;
+ sBattleBuffersTransferData[1] = battleOutcome;
+ PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c
index bea4406bc..f0a724fe6 100644
--- a/src/battle_gfx_sfx_util.c
+++ b/src/battle_gfx_sfx_util.c
@@ -758,6 +758,7 @@ void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, u8 notTransform)
void BattleLoadSubstituteOrMonSpriteGfx(u8 battlerId, bool8 loadMonSprite)
{
u8 position;
+ // variable i is actually u8, but needs to be 32-bit to make the inline ASM match.
s32 i;
u32 palOffset;
const void *substitutePal;
diff --git a/src/mevent.c b/src/mevent.c
index fc0c1f2d4..d0d7f59aa 100644
--- a/src/mevent.c
+++ b/src/mevent.c
@@ -134,7 +134,7 @@ static void ResetTTDataBuffer(void)
{
memset(gDecompressionBuffer, 0, 0x2000);
gLinkType = 0x5502;
- sub_8009804();
+ OpenLink();
SetSuppressLinkErrorMessage(TRUE);
}
@@ -156,7 +156,7 @@ bool32 sub_81436EC(void)
static bool32 IsEReaderConnectionSane(void)
{
- if (sub_800AA48() && GetLinkPlayerCount_2() == 2)
+ if (IsLinkMaster() && GetLinkPlayerCount_2() == 2)
return TRUE;
return FALSE;
}
@@ -171,7 +171,7 @@ u32 sub_8143770(u8 * r4, u16 * r5)
switch (*r4)
{
case 0:
- if (sub_800AA48() && GetLinkPlayerCount_2() > 1)
+ if (IsLinkMaster() && GetLinkPlayerCount_2() > 1)
{
*r4 = 1;
;
@@ -193,7 +193,7 @@ u32 sub_8143770(u8 * r4, u16 * r5)
if (GetLinkPlayerCount_2() == 2)
{
PlaySE(SE_TOY_G);
- sub_800A5BC();
+ CheckShouldAdvanceLinkState();
*r5 = 0;
*r4 = 3;
}
diff --git a/src/mevent_server_helpers.c b/src/mevent_server_helpers.c
index 35efa68c8..6df5207f0 100644
--- a/src/mevent_server_helpers.c
+++ b/src/mevent_server_helpers.c
@@ -155,7 +155,7 @@ static bool32 mevent_send_func(struct mevent_srv_sub * svr)
switch (svr->seqno)
{
case 0:
- if (sub_800A4BC())
+ if (IsLinkTaskFinished())
{
header.ident = svr->sendIdent;
header.size = svr->sendSize;
@@ -167,7 +167,7 @@ static bool32 mevent_send_func(struct mevent_srv_sub * svr)
}
break;
case 1:
- if (sub_800A4BC())
+ if (IsLinkTaskFinished())
{
if (mevent_has_received(svr->sendPlayerNo))
{
@@ -189,7 +189,7 @@ static bool32 mevent_send_func(struct mevent_srv_sub * svr)
}
break;
case 2:
- if (sub_800A4BC())
+ if (IsLinkTaskFinished())
{
if (CalcCRC16WithTable(svr->sendBfr, svr->sendSize) != svr->sendCRC)
sub_80FA190();
diff --git a/src/pokemon.c b/src/pokemon.c
index 848f258be..ffe407daf 100644
--- a/src/pokemon.c
+++ b/src/pokemon.c
@@ -19,7 +19,6 @@
#include "evolution_scene.h"
#include "battle_message.h"
#include "battle_util.h"
-#include "battle_ai_script_commands.h"
#include "link.h"
#include "m4a.h"
#include "sound.h"
@@ -2592,7 +2591,7 @@ u8 CountAliveMonsInBattle(u8 caseId)
case BATTLE_ALIVE_ATK_SIDE:
for (i = 0; i < 4; i++)
{
- if (GetBattlerSide(i) == GetBattlerSide(sBattler_AI) && !(gAbsentBattlerFlags & gBitTable[i]))
+ if (GetBattlerSide(i) == GetBattlerSide(gBattlerAttacker) && !(gAbsentBattlerFlags & gBitTable[i]))
retVal++;
}
break;
@@ -6106,7 +6105,7 @@ const u8 *Battle_PrintStatBoosterEffectMessage(u16 itemId)
}
else
{
- sBattler_AI = gBattlerInMenuId;
+ gBattlerAttacker = gBattlerInMenuId;
BattleStringExpandPlaceholdersToDisplayedString(BattleText_GetPumped);
}
}
@@ -6114,7 +6113,7 @@ const u8 *Battle_PrintStatBoosterEffectMessage(u16 itemId)
if (itemEffect[3] & 0x80)
{
- sBattler_AI = gBattlerInMenuId;
+ gBattlerAttacker = gBattlerInMenuId;
BattleStringExpandPlaceholdersToDisplayedString(BattleText_MistShroud);
}
@@ -7075,15 +7074,9 @@ void BoxMonRestorePP(struct BoxPokemon *boxMon)
}
}
-// SetMonPreventsSwitchingString
-void sub_8044348(void)
+void SetMonPreventsSwitchingString(void)
{
-#ifdef NONMATCHING
- gLastUsedAbility = gBattleStruct -> abilityPreventingSwitchout; // fixed from the original
-#else
- gLastUsedAbility = ((u8 *) gBattleStruct)[0xac]; // huh? why is this wrong?
-#endif
-
+ gLastUsedAbility = gBattleStruct -> abilityPreventingSwitchout;
gBattleTextBuff1[0] = B_BUFF_PLACEHOLDER_BEGIN;
gBattleTextBuff1[1] = B_BUFF_MON_NICK_WITH_PREFIX;
gBattleTextBuff1[2] = gBattleStruct->battlerPreventingSwitchout;
diff --git a/src/quest_log_battle.c b/src/quest_log_battle.c
index 3dfc2eb57..2687e4ea5 100644
--- a/src/quest_log_battle.c
+++ b/src/quest_log_battle.c
@@ -26,7 +26,7 @@ void sub_812C334(s32 *, s32 *);
void sub_812BFDC(void)
{
- if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_WALLY_TUTORIAL | BATTLE_TYPE_POKEDUDE)) && (gBattleOutcome == B_OUTCOME_WON || gBattleOutcome == B_OUTCOME_CAUGHT))
+ if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_OLDMAN_TUTORIAL | BATTLE_TYPE_POKEDUDE)) && (gBattleOutcome == B_OUTCOME_WON || gBattleOutcome == B_OUTCOME_CAUGHT))
{
struct QuestLogStruct_TrainerBattleRecord * questLogTrainerBattleRecord = Alloc(sizeof(struct QuestLogStruct_TrainerBattleRecord));
struct QuestLogStruct_WildBattleRecord * questLogWildBattleRecord = Alloc(sizeof(struct QuestLogStruct_WildBattleRecord));
diff --git a/src/save.c b/src/save.c
index d3d31a22e..9f580477b 100644
--- a/src/save.c
+++ b/src/save.c
@@ -68,7 +68,7 @@ const struct SaveSectionOffsets gSaveSectionOffsets[] =
extern void DoSaveFailedScreen(u8 saveType); // save_failed_screen
extern void sub_800AB9C(void); // link
-extern bool8 sub_800A4BC(void); // link
+extern bool8 IsLinkTaskFinished(void); // link
extern void save_serialize_map(void); // fieldmap
extern void sub_804C1C0(void); // load_save
extern void sav2_gender2_inplace_and_xFE(void); // load_save
@@ -865,7 +865,7 @@ void sub_80DA634(u8 taskId)
gTasks[taskId].data[0] = 2;
break;
case 2:
- if (sub_800A4BC())
+ if (IsLinkTaskFinished())
{
save_serialize_map();
gTasks[taskId].data[0] = 3;
@@ -899,7 +899,7 @@ void sub_80DA634(u8 taskId)
gTasks[taskId].data[0] = 8;
break;
case 8:
- if (sub_800A4BC())
+ if (IsLinkTaskFinished())
{
sub_80DA434();
gTasks[taskId].data[0] = 9;
@@ -910,7 +910,7 @@ void sub_80DA634(u8 taskId)
gTasks[taskId].data[0] = 10;
break;
case 10:
- if (sub_800A4BC())
+ if (IsLinkTaskFinished())
gTasks[taskId].data[0]++;
break;
case 11:
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-06 12:32:40 +0000