Cloyir/pokeemmo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge commit 'c39ef1a03002a7af94' into pret-merge

Browse Source 
Conflicts:
	src/battle_ai_switch_items.c
	src/battle_controller_link_opponent.c
	src/battle_controller_link_partner.c
	src/battle_controller_opponent.c
	src/battle_controller_player.c
	src/battle_controller_player_partner.c
	src/battle_controller_recorded_opponent.c
	src/battle_controller_recorded_player.c
	src/battle_controller_safari.c
	src/battle_controller_wally.c
	src/battle_controllers.c
	src/battle_main.c
	src/battle_script_commands.c
	src/battle_util.c
	src/battle_util2.c
	src/pokemon.c
This commit is contained in:
Hedara 2025-05-15 17:31:50 +02:00
commit 49906a81f7
16 changed files with 440 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
include/battle_controllers.h
View File

@ -64,11 +64,65 @@ enum {
REQUEST_TOUGH_RIBBON_BATTLE,
};
// Accessors for gBattleControllerExecFlags.
//
// These are provided for documentation purposes, to make the battle
// controller internals and the link communication internals more
// legible. Several of these have functions that you should call
// (e.g. MarkBattlerForControllerExec) instead of using these macros
// directly.
#define MARK_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battler) \
gBattleControllerExecFlags |= (1u << battler)
#define MARK_BATTLE_CONTROLLER_IDLE_ON_LOCAL(battler) \
gBattleControllerExecFlags &= ~(1u << battler)
#define IS_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battler) \
(gBattleControllerExecFlags & (1u << battler))
#define MARK_BATTLE_CONTROLLER_MESSAGE_OUTBOUND_OVER_LINK(battler) \
gBattleControllerExecFlags |= (1u << battler) << (32 - MAX_BATTLERS_COUNT)
#define MARK_BATTLE_CONTROLLER_MESSAGE_SYNCHRONIZED_OVER_LINK(battler) \
gBattleControllerExecFlags &= ~((1 << 28) << (battler))
#define MARK_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battler, playerId) \
gBattleControllerExecFlags |= (1u << battler) << ((playerId) << 2)
#define MARK_BATTLE_CONTROLLER_IDLE_FOR_PLAYER(battler, playerId) \
gBattleControllerExecFlags &= ~(1u << battler) << ((playerId) * 4)
#define IS_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battler, playerId) \
(gBattleControllerExecFlags & (1u << battler) << ((playerId) * 4))
// This actually checks if a specific controller is active on any player or if
// *any* controller is pending sync over link communications, but the macro name
// can only be so specific before it just gets ridiculous.
#define IS_BATTLE_CONTROLLER_ACTIVE_OR_PENDING_SYNC_ANYWHERE(battler) \
(gBattleControllerExecFlags & ( \
(1u << battler) \
| (0xF << 28) \
| (1u << battler << 4) \
| (1u << battler << 8) \
| (1u << battler << 12) \
))
// Special arguments for Battle Controller functions.
enum { // Values given to the emit functions to choose gBattleBufferA or gBattleBufferB
BUFFER_A,
BUFFER_B
enum {
// For commands sent from the core battle engine to a controller.
B_COMM_TO_CONTROLLER, // gBattleBufferA
// For replies sent from a controller to the core battle engine.
B_COMM_TO_ENGINE, // gBattleBufferB
// During local play, a controller must directly mark itself as
// inactive when it's done processing, whether or not it sends
// a reply. During multiplayer, it must NOT directly mark itself
// as inactive, but instead send one of these, with the player's
// multiplayer ID as data.
B_COMM_CONTROLLER_IS_DONE
};
enum {

4
src/battle_ai_switch_items.c
View File

@ -1244,7 +1244,7 @@ void AI_TrySwitchOrUseItem(u32 battler)
}
}
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, BATTLE_OPPOSITE(battler) << 8);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_MOVE, BATTLE_OPPOSITE(battler) << 8);
}
// If there are two(or more) mons to choose from, always choose one that has baton pass
@ -2311,7 +2311,7 @@ static bool32 ShouldUseItem(u32 battler)
// Set selected party ID to current battler if none chosen.
if (gBattleStruct->itemPartyIndex[battler] == PARTY_SIZE)
gBattleStruct->itemPartyIndex[battler] = gBattlerPartyIndexes[battler];
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_ITEM, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_ITEM, 0);
gBattleStruct->chosenItem[battler] = item;
gBattleResources->battleHistory->trainerItems[i] = 0;
return shouldUse;

2
src/battle_controller_link_opponent.c
View File

@ -367,7 +367,7 @@ static void LinkOpponentBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else

2
src/battle_controller_link_partner.c
View File

@ -193,7 +193,7 @@ static void LinkPartnerBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else

28
src/battle_controller_opponent.c
View File

@ -404,7 +404,7 @@ static void OpponentBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else
@ -540,7 +540,7 @@ static void OpponentHandleChooseMove(u32 battler)
{
if (gBattleTypeFlags & BATTLE_TYPE_PALACE)
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace(battler));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, ChooseMoveAndTargetInBattlePalace(battler));
}
else
{
@ -549,13 +549,13 @@ static void OpponentHandleChooseMove(u32 battler)
switch (chosenMoveId)
{
case AI_CHOICE_WATCH:
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_WATCH_CAREFULLY, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_SAFARI_WATCH_CAREFULLY, 0);
break;
case AI_CHOICE_FLEE:
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_RUN, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_RUN, 0);
break;
case 6:
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 15, gBattlerTarget);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 15, gBattlerTarget);
break;
default:
{
@ -573,11 +573,11 @@ static void OpponentHandleChooseMove(u32 battler)
&& !(gBattleStruct->gimmick.usableGimmick[battler] == GIMMICK_Z_MOVE
&& !ShouldUseZMove(battler, gBattlerTarget, moveInfo->moves[chosenMoveId])))
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (RET_GIMMICK) | (gBattlerTarget << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (RET_GIMMICK) | (gBattlerTarget << 8));
}
else
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (gBattlerTarget << 8));
}
}
break;
@ -596,7 +596,7 @@ static void OpponentHandleChooseMove(u32 battler)
} while (move == MOVE_NONE);
if (GetBattlerMoveTargetType(battler, move) & MOVE_TARGET_USER)
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (battler << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (battler << 8));
else if (IsDoubleBattle())
{
do {
@ -629,17 +629,17 @@ static void OpponentHandleChooseMove(u32 battler)
}
}
if (isPartnerEnemy && CanTargetBattler(battler, target, move))
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(BATTLE_PARTNER(battler)) << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (GetBattlerAtPosition(BATTLE_PARTNER(battler)) << 8));
else
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (target << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (target << 8));
}
else
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (target << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (target << 8));
}
}
else
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) << 8));
OpponentBufferExecCompleted(battler);
}
@ -647,7 +647,7 @@ static void OpponentHandleChooseMove(u32 battler)
static void OpponentHandleChooseItem(u32 battler)
{
BtlController_EmitOneReturnValue(battler, BUFFER_B, gBattleStruct->chosenItem[battler]);
BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, gBattleStruct->chosenItem[battler]);
OpponentBufferExecCompleted(battler);
}
@ -720,7 +720,7 @@ static void OpponentHandleChoosePokemon(u32 battler)
#if TESTING
TestRunner_Battle_CheckSwitch(battler, chosenMonId);
#endif // TESTING
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, chosenMonId, NULL);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, chosenMonId, NULL);
OpponentBufferExecCompleted(battler);
}

62
src/battle_controller_player.c
View File

@ -173,7 +173,7 @@ static void PlayerBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else
@ -306,7 +306,7 @@ static void HandleInputChooseAction(u32 battler)
PlaySE(SE_SELECT);
ArrowsChangeColorLastBallCycle(FALSE);
TryHideLastUsedBall();
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_THROW_BALL, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_THROW_BALL, 0);
PlayerBufferExecCompleted(battler);
}
return;
@ -321,16 +321,16 @@ static void HandleInputChooseAction(u32 battler)
switch (gActionSelectionCursor[battler])
{
case 0: // Top left
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_MOVE, 0);
break;
case 1: // Top right
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_ITEM, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_ITEM, 0);
break;
case 2: // Bottom left
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_SWITCH, 0);
break;
case 3: // Bottom right
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_RUN, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_RUN, 0);
break;
}
PlayerBufferExecCompleted(battler);
@ -388,7 +388,7 @@ static void HandleInputChooseAction(u32 battler)
AddBagItem(itemId, 1);
}
PlaySE(SE_SELECT);
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_CANCEL_PARTNER, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_CANCEL_PARTNER, 0);
PlayerBufferExecCompleted(battler);
}
else if (B_QUICK_MOVE_CURSOR_TO_RUN)
@ -408,7 +408,7 @@ static void HandleInputChooseAction(u32 battler)
}
else if (DEBUG_BATTLE_MENU == TRUE && JOY_NEW(SELECT_BUTTON))
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_DEBUG, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_DEBUG, 0);
PlayerBufferExecCompleted(battler);
}
else if (B_LAST_USED_BALL == TRUE && B_LAST_USED_BALL_CYCLE == FALSE
@ -416,7 +416,7 @@ static void HandleInputChooseAction(u32 battler)
{
PlaySE(SE_SELECT);
TryHideLastUsedBall();
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_THROW_BALL, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_THROW_BALL, 0);
PlayerBufferExecCompleted(battler);
}
}
@ -445,9 +445,9 @@ void HandleInputChooseTarget(u32 battler)
PlaySE(SE_SELECT);
gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_HideAsMoveTarget;
if (gBattleStruct->gimmick.playerSelect)
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
else
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX);
TryHideLastUsedBall();
HideGimmickTriggerSprite();
@ -601,9 +601,9 @@ void HandleInputShowEntireFieldTargets(u32 battler)
PlaySE(SE_SELECT);
HideAllTargets();
if (gBattleStruct->gimmick.playerSelect)
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
else
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
HideGimmickTriggerSprite();
PlayerBufferExecCompleted(battler);
}
@ -629,9 +629,9 @@ void HandleInputShowTargets(u32 battler)
PlaySE(SE_SELECT);
HideShownTargets(battler);
if (gBattleStruct->gimmick.playerSelect)
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
else
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
HideGimmickTriggerSprite();
TryHideLastUsedBall();
PlayerBufferExecCompleted(battler);
@ -733,9 +733,9 @@ void HandleInputChooseMove(u32 battler)
case 0:
default:
if (gBattleStruct->gimmick.playerSelect)
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | RET_GIMMICK | (gMultiUsePlayerCursor << 8));
else
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
HideGimmickTriggerSprite();
TryHideLastUsedBall();
PlayerBufferExecCompleted(battler);
@ -771,7 +771,7 @@ void HandleInputChooseMove(u32 battler)
}
else
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, 0xFFFF);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, 0xFFFF);
HideGimmickTriggerSprite();
PlayerBufferExecCompleted(battler);
TryToHideMoveInfoWindow();
@ -1437,7 +1437,7 @@ static void Task_GiveExpToMon(u8 taskId)
DynamaxModifyHPLevelUp(mon, battler, oldMaxHP);
gainedExp -= nextLvlExp - currExp;
BtlController_EmitTwoReturnValues(battler, BUFFER_B, RET_VALUE_LEVELED_UP, gainedExp);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RET_VALUE_LEVELED_UP, gainedExp);
if (IsDoubleBattle() == TRUE
&& (monId == gBattlerPartyIndexes[battler] || monId == gBattlerPartyIndexes[BATTLE_PARTNER(battler)]))
@ -1518,7 +1518,7 @@ static void Task_GiveExpWithExpBar(u8 taskId)
DynamaxModifyHPLevelUp(mon, battler, oldMaxHP);
gainedExp -= expOnNextLvl - currExp;
BtlController_EmitTwoReturnValues(battler, BUFFER_B, RET_VALUE_LEVELED_UP, gainedExp);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RET_VALUE_LEVELED_UP, gainedExp);
gTasks[taskId].func = Task_LaunchLvlUpAnim;
}
else
@ -1587,9 +1587,9 @@ static void WaitForMonSelection(u32 battler)
if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
{
if (gPartyMenuUseExitCallback == TRUE)
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, gSelectedMonPartyId, gBattlePartyCurrentOrder);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, gSelectedMonPartyId, gBattlePartyCurrentOrder);
else
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, PARTY_SIZE, NULL);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, PARTY_SIZE, NULL);
if ((gBattleResources->bufferA[battler][1] & 0xF) == 1)
PrintLinkStandbyMsg();
@ -1613,7 +1613,7 @@ static void CompleteWhenChoseItem(u32 battler)
{
if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
{
BtlController_EmitOneReturnValue(battler, BUFFER_B, gSpecialVar_ItemId);
BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, gSpecialVar_ItemId);
PlayerBufferExecCompleted(battler);
}
}
@ -1640,9 +1640,9 @@ static void PlayerHandleYesNoInput(u32 battler)
PlaySE(SE_SELECT);
if (gMultiUsePlayerCursor != 0)
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 0xE, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 0xE, 0);
else
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 0xD, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 0xD, 0);
PlayerBufferExecCompleted(battler);
}
@ -2114,7 +2114,7 @@ static void PlayerChooseMoveInBattlePalace(u32 battler)
if (--gBattleStruct->arenaMindPoints[battler] == 0)
{
gBattlePalaceMoveSelectionRngValue = gRngValue;
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace(battler));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, ChooseMoveAndTargetInBattlePalace(battler));
PlayerBufferExecCompleted(battler);
}
}
@ -2180,7 +2180,7 @@ static void PlayerHandleChoosePokemon(u32 battler)
&& (gBattleResources->bufferA[battler][1] & 0xF) != PARTY_ACTION_CHOOSE_FAINTED_MON
&& (gBattleResources->bufferA[battler][1] & 0xF) != PARTY_ACTION_SEND_MON_TO_BOX)
{
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, gBattlerPartyIndexes[battler] + 1, gBattlePartyCurrentOrder);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, gBattlerPartyIndexes[battler] + 1, gBattlePartyCurrentOrder);
PlayerBufferExecCompleted(battler);
}
else
@ -2279,25 +2279,25 @@ static void PlayerHandlePlayBGM(u32 battler)
static void PlayerHandleTwoReturnValues(u32 battler)
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 0, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 0, 0);
PlayerBufferExecCompleted(battler);
}
static void PlayerHandleChosenMonReturnValue(u32 battler)
{
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, 0, NULL);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, 0, NULL);
PlayerBufferExecCompleted(battler);
}
static void PlayerHandleOneReturnValue(u32 battler)
{
BtlController_EmitOneReturnValue(battler, BUFFER_B, 0);
BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, 0);
PlayerBufferExecCompleted(battler);
}
static void PlayerHandleOneReturnValue_Duplicate(u32 battler)
{
BtlController_EmitOneReturnValue_Duplicate(battler, BUFFER_B, 0);
BtlController_EmitOneReturnValue_Duplicate(battler, B_COMM_TO_ENGINE, 0);
PlayerBufferExecCompleted(battler);
}

8
src/battle_controller_player_partner.c
View File

@ -265,7 +265,7 @@ static void PlayerPartnerBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else
@ -366,11 +366,11 @@ static void PlayerPartnerHandleChooseMove(u32 battler)
&& !(gBattleStruct->gimmick.usableGimmick[battler] == GIMMICK_Z_MOVE
&& !ShouldUseZMove(battler, gBattlerTarget, moveInfo->moves[chosenMoveId])))
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (RET_GIMMICK) | (gBattlerTarget << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (RET_GIMMICK) | (gBattlerTarget << 8));
}
else
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, (chosenMoveId) | (gBattlerTarget << 8));
}
PlayerPartnerBufferExecCompleted(battler);
@ -413,7 +413,7 @@ static void PlayerPartnerHandleChoosePokemon(u32 battler)
gBattleStruct->AI_monToSwitchIntoId[battler] = PARTY_SIZE;
gBattleStruct->monToSwitchIntoId[battler] = chosenMonId;
}
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, chosenMonId, NULL);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, chosenMonId, NULL);
PlayerPartnerBufferExecCompleted(battler);
}

10
src/battle_controller_recorded_opponent.c
View File

@ -451,7 +451,7 @@ static void RecordedOpponentHandlePrintString(u32 battler)
static void RecordedOpponentHandleChooseAction(u32 battler)
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0);
RecordedOpponentBufferExecCompleted(battler);
}
@ -459,13 +459,13 @@ static void RecordedOpponentHandleChooseMove(u32 battler)
{
if (gBattleTypeFlags & BATTLE_TYPE_PALACE)
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace(battler));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, ChooseMoveAndTargetInBattlePalace(battler));
}
else
{
u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler);
u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler);
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, moveId | (target << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, moveId | (target << 8));
}
RecordedOpponentBufferExecCompleted(battler);
@ -478,7 +478,7 @@ static void RecordedOpponentHandleChooseItem(u32 battler)
gBattleStruct->chosenItem[battler] = (byte1 << 8) | byte2;
gBattleStruct->itemPartyIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_TARGET, battler);
gBattleStruct->itemMoveIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_MOVE, battler);
BtlController_EmitOneReturnValue(battler, BUFFER_B, gBattleStruct->chosenItem[battler]);
BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, gBattleStruct->chosenItem[battler]);
RecordedOpponentBufferExecCompleted(battler);
}
@ -486,7 +486,7 @@ static void RecordedOpponentHandleChoosePokemon(u32 battler)
{
gBattleStruct->monToSwitchIntoId[battler] = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler);
gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, gBattleStruct->monToSwitchIntoId[battler], NULL);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, gBattleStruct->monToSwitchIntoId[battler], NULL);
RecordedOpponentBufferExecCompleted(battler);
}

14
src/battle_controller_recorded_player.c
View File

@ -342,7 +342,7 @@ static void RecordedPlayerBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else
@ -430,7 +430,7 @@ static void ChooseActionInBattlePalace(u32 battler)
{
if (gBattleCommunication[4] >= gBattlersCount / 2)
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_BATTLE_PALACE_ACTION, battler), 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RecordedBattle_GetBattlerAction(RECORDED_BATTLE_PALACE_ACTION, battler), 0);
RecordedPlayerBufferExecCompleted(battler);
}
}
@ -443,7 +443,7 @@ static void RecordedPlayerHandleChooseAction(u32 battler)
}
else
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0);
RecordedPlayerBufferExecCompleted(battler);
}
}
@ -452,13 +452,13 @@ static void RecordedPlayerHandleChooseMove(u32 battler)
{
if (gBattleTypeFlags & BATTLE_TYPE_PALACE)
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace(battler));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, ChooseMoveAndTargetInBattlePalace(battler));
}
else
{
u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler);
u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler);
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, moveId | (target << 8));
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, moveId | (target << 8));
}
RecordedPlayerBufferExecCompleted(battler);
@ -471,7 +471,7 @@ static void RecordedPlayerHandleChooseItem(u32 battler)
gBattleStruct->chosenItem[battler] = (byte1 << 8) | byte2;
gBattleStruct->itemPartyIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_TARGET, battler);
gBattleStruct->itemMoveIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_MOVE, battler);
BtlController_EmitOneReturnValue(battler, BUFFER_B, gBattleStruct->chosenItem[battler]);
BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, gBattleStruct->chosenItem[battler]);
RecordedPlayerBufferExecCompleted(battler);
}
@ -479,7 +479,7 @@ static void RecordedPlayerHandleChoosePokemon(u32 battler)
{
gBattleStruct->monToSwitchIntoId[battler] = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler);
gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing
BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, gBattleStruct->monToSwitchIntoId[battler], NULL);
BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, gBattleStruct->monToSwitchIntoId[battler], NULL);
RecordedPlayerBufferExecCompleted(battler);
}

12
src/battle_controller_safari.c
View File

@ -127,16 +127,16 @@ static void HandleInputChooseAction(u32 battler)
switch (gActionSelectionCursor[battler])
{
case 0:
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_BALL, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_SAFARI_BALL, 0);
break;
case 1:
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_POKEBLOCK, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_SAFARI_POKEBLOCK, 0);
break;
case 2:
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_GO_NEAR, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_SAFARI_GO_NEAR, 0);
break;
case 3:
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_RUN, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_SAFARI_RUN, 0);
break;
}
SafariBufferExecCompleted(battler);
@ -220,7 +220,7 @@ static void CompleteWhenChosePokeblock(u32 battler)
{
if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
{
BtlController_EmitOneReturnValue(battler, BUFFER_B, gSpecialVar_ItemId);
BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, gSpecialVar_ItemId);
SafariBufferExecCompleted(battler);
}
}
@ -232,7 +232,7 @@ static void SafariBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else

14
src/battle_controller_wally.c
View File

@ -145,7 +145,7 @@ static void WallyHandleActions(u32 battler)
if (--gBattleStruct->wallyWaitFrames == 0)
{
PlaySE(SE_SELECT);
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_MOVE, 0);
WallyBufferExecCompleted(battler);
gBattleStruct->wallyBattleState++;
gBattleStruct->wallyMovesState = 0;
@ -156,7 +156,7 @@ static void WallyHandleActions(u32 battler)
if (--gBattleStruct->wallyWaitFrames == 0)
{
PlaySE(SE_SELECT);
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_MOVE, 0);
WallyBufferExecCompleted(battler);
gBattleStruct->wallyBattleState++;
gBattleStruct->wallyMovesState = 0;
@ -166,7 +166,7 @@ static void WallyHandleActions(u32 battler)
case 3:
if (--gBattleStruct->wallyWaitFrames == 0)
{
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_WALLY_THROW, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_WALLY_THROW, 0);
WallyBufferExecCompleted(battler);
gBattleStruct->wallyBattleState++;
gBattleStruct->wallyMovesState = 0;
@ -187,7 +187,7 @@ static void WallyHandleActions(u32 battler)
if (--gBattleStruct->wallyWaitFrames == 0)
{
PlaySE(SE_SELECT);
BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_ITEM, 0);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_ITEM, 0);
WallyBufferExecCompleted(battler);
}
break;
@ -209,7 +209,7 @@ static void CompleteOnChosenItem(u32 battler)
{
if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
{
BtlController_EmitOneReturnValue(battler, BUFFER_B, gSpecialVar_ItemId);
BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, gSpecialVar_ItemId);
WallyBufferExecCompleted(battler);
}
}
@ -279,7 +279,7 @@ static void WallyBufferExecCompleted(u32 battler)
{
u8 playerId = GetMultiplayerId();
PrepareBufferDataTransferLink(battler, 2, 4, &playerId);
PrepareBufferDataTransferLink(battler, B_COMM_CONTROLLER_IS_DONE, 4, &playerId);
gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
}
else
@ -378,7 +378,7 @@ static void WallyHandleChooseMove(u32 battler)
if (--gBattleStruct->wallyMoveFrames == 0)
{
PlaySE(SE_SELECT);
BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, 0x100);
BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, 10, 0x100);
WallyBufferExecCompleted(battler);
}
break;

233
src/battle_controllers.c
View File

@ -689,11 +689,11 @@ static void PrepareBufferDataTransfer(u32 battler, u32 bufferId, u8 *data, u16 s
{
switch (bufferId)
{
case BUFFER_A:
case B_COMM_TO_CONTROLLER:
for (i = 0; i < size; data++, i++)
gBattleResources->bufferA[battler][i] = *data;
break;
case BUFFER_B:
case B_COMM_TO_ENGINE:
for (i = 0; i < size; data++, i++)
gBattleResources->bufferB[battler][i] = *data;
break;
@ -701,20 +701,41 @@ static void PrepareBufferDataTransfer(u32 battler, u32 bufferId, u8 *data, u16 s
}
}
#define tInitialDelayTimer data[10]
#define tState data[11]
#define tCurrentBlock_WrapFrom data[12]
#define tBlockSendDelayTimer data[13]
#define tCurrentBlock_End data[14]
#define tCurrentBlock_Start data[15]
//
// Inbound communications are stored in one buffer; outbound communications
// in another. Both buffers work pretty similarly: the next message will be
// written into the buffer after the previous message (with 4-byte alignment),
// unless we're too close to the end of the buffer, in which case we jump back
// to the start.
//
// Regarding the task variable names above: these variables are altered in-
// place, so the precise operational definition of "current" depends on when
// the variables are being accessed. When data is present in the send and
// receive buffers, "current" refers to the most recently received message;
// but when a message is actually being placed in the buffers, "current"
// refers to the previous message, until such time that we finish updating it
// to refer to the new message.
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;
gTasks[sLinkSendTaskId].tState = 0;
gTasks[sLinkSendTaskId].tCurrentBlock_WrapFrom = 0;
gTasks[sLinkSendTaskId].tBlockSendDelayTimer = 0;
gTasks[sLinkSendTaskId].tCurrentBlock_End = 0;
gTasks[sLinkSendTaskId].tCurrentBlock_Start = 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;
gTasks[sLinkReceiveTaskId].tCurrentBlock_WrapFrom = 0;
gTasks[sLinkReceiveTaskId].tBlockSendDelayTimer = 0; // not used by "receive" task
gTasks[sLinkReceiveTaskId].tCurrentBlock_End = 0;
gTasks[sLinkReceiveTaskId].tCurrentBlock_Start = 0;
}
enum
@ -730,52 +751,72 @@ enum
LINK_BUFF_DATA,
};
// We want to send a message. Place it into the "send" buffer.
// First argument is a BATTLELINKCOMMTYPE_
void PrepareBufferDataTransferLink(u32 battler, u32 bufferId, u16 size, u8 *data)
{
s32 alignedSize;
s32 i;
alignedSize = size - size % 4 + 4;
if (gTasks[sLinkSendTaskId].data[14] + alignedSize + LINK_BUFF_DATA + 1 > BATTLE_BUFFER_LINK_SIZE)
if (gTasks[sLinkSendTaskId].tCurrentBlock_End + alignedSize + LINK_BUFF_DATA + 1 > BATTLE_BUFFER_LINK_SIZE)
{
gTasks[sLinkSendTaskId].data[12] = gTasks[sLinkSendTaskId].data[14];
gTasks[sLinkSendTaskId].data[14] = 0;
gTasks[sLinkSendTaskId].tCurrentBlock_WrapFrom = gTasks[sLinkSendTaskId].tCurrentBlock_End;
gTasks[sLinkSendTaskId].tCurrentBlock_End = 0;
}
gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_BUFFER_ID] = bufferId;
gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ACTIVE_BATTLER] = battler;
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;
#define BYTE_TO_SEND(offset) \
gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].tCurrentBlock_End + offset]
BYTE_TO_SEND(LINK_BUFF_BUFFER_ID) = bufferId;
BYTE_TO_SEND(LINK_BUFF_ACTIVE_BATTLER) = battler;
BYTE_TO_SEND(LINK_BUFF_ATTACKER) = gBattlerAttacker;
BYTE_TO_SEND(LINK_BUFF_TARGET) = gBattlerTarget;
BYTE_TO_SEND(LINK_BUFF_SIZE_LO) = alignedSize;
BYTE_TO_SEND(LINK_BUFF_SIZE_HI) = (alignedSize & 0x0000FF00) >> 8;
BYTE_TO_SEND(LINK_BUFF_ABSENT_BATTLER_FLAGS) = gAbsentBattlerFlags;
BYTE_TO_SEND(LINK_BUFF_EFFECT_BATTLER) = gEffectBattler;
for (i = 0; i < size; i++)
gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_DATA + i] = data[i];
BYTE_TO_SEND(LINK_BUFF_DATA + i) = data[i];
gTasks[sLinkSendTaskId].data[14] = gTasks[sLinkSendTaskId].data[14] + alignedSize + LINK_BUFF_DATA;
#undef BYTE_TO_SEND
gTasks[sLinkSendTaskId].tCurrentBlock_End = gTasks[sLinkSendTaskId].tCurrentBlock_End + alignedSize + LINK_BUFF_DATA;
}
enum {
SENDTASK_STATE_INITIALIZE = 0,
SENDTASK_STATE_INITIAL_DELAY = 1,
SENDTASK_STATE_COUNT_PLAYERS = 2,
SENDTASK_STATE_BEGIN_SEND_BLOCK = 3,
SENDTASK_STATE_FINISH_SEND_BLOCK = 4,
SENDTASK_STATE_UNUSED_STATE = 5,
};
static void Task_HandleSendLinkBuffersData(u8 taskId)
{
u16 numPlayers;
u16 blockSize;
switch (gTasks[taskId].data[11])
#define BYTE_TO_SEND(offset) \
gLinkBattleSendBuffer[gTasks[taskId].tCurrentBlock_Start + offset]
switch (gTasks[taskId].tState)
{
case 0:
gTasks[taskId].data[10] = 100;
gTasks[taskId].data[11]++;
case SENDTASK_STATE_INITIALIZE:
gTasks[taskId].tInitialDelayTimer = 100;
gTasks[taskId].tState++;
break;
case 1:
gTasks[taskId].data[10]--;
if (gTasks[taskId].data[10] == 0)
gTasks[taskId].data[11]++;
case SENDTASK_STATE_INITIAL_DELAY:
gTasks[taskId].tInitialDelayTimer--;
if (gTasks[taskId].tInitialDelayTimer == 0)
gTasks[taskId].tState++;
break;
case 2:
case SENDTASK_STATE_COUNT_PLAYERS:
if (gWirelessCommType)
{
gTasks[taskId].data[11]++;
gTasks[taskId].tState++;
}
else
{
@ -789,56 +830,66 @@ static void Task_HandleSendLinkBuffersData(u8 taskId)
if (IsLinkMaster())
{
CheckShouldAdvanceLinkState();
gTasks[taskId].data[11]++;
gTasks[taskId].tState++;
}
else
{
gTasks[taskId].data[11]++;
gTasks[taskId].tState++;
}
}
}
break;
case 3:
if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
case SENDTASK_STATE_BEGIN_SEND_BLOCK:
if (gTasks[taskId].tCurrentBlock_Start != gTasks[taskId].tCurrentBlock_End)
{
if (gTasks[taskId].data[13] == 0)
if (gTasks[taskId].tBlockSendDelayTimer == 0)
{
if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
&& gTasks[taskId].data[15] == gTasks[taskId].data[12])
if (gTasks[taskId].tCurrentBlock_Start > gTasks[taskId].tCurrentBlock_End
&& gTasks[taskId].tCurrentBlock_Start == gTasks[taskId].tCurrentBlock_WrapFrom)
{
gTasks[taskId].data[12] = 0;
gTasks[taskId].data[15] = 0;
gTasks[taskId].tCurrentBlock_WrapFrom = 0;
gTasks[taskId].tCurrentBlock_Start = 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(BitmaskAllOtherLinkPlayers(), &gLinkBattleSendBuffer[gTasks[taskId].data[15]], blockSize);
gTasks[taskId].data[11]++;
blockSize = (BYTE_TO_SEND(LINK_BUFF_SIZE_LO) | (BYTE_TO_SEND(LINK_BUFF_SIZE_HI) << 8)) + LINK_BUFF_DATA;
SendBlock(BitmaskAllOtherLinkPlayers(), &BYTE_TO_SEND(0), blockSize);
gTasks[taskId].tState++;
}
else
{
gTasks[taskId].data[13]--;
gTasks[taskId].tBlockSendDelayTimer--;
break;
}
}
break;
case 4:
case SENDTASK_STATE_FINISH_SEND_BLOCK:
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] = 1;
gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
gTasks[taskId].data[11] = 3;
blockSize = BYTE_TO_SEND(LINK_BUFF_SIZE_LO) | (BYTE_TO_SEND(LINK_BUFF_SIZE_HI) << 8);
gTasks[taskId].tBlockSendDelayTimer = 1;
gTasks[taskId].tCurrentBlock_Start = gTasks[taskId].tCurrentBlock_Start + blockSize + LINK_BUFF_DATA;
gTasks[taskId].tState = SENDTASK_STATE_BEGIN_SEND_BLOCK;
}
break;
case 5:
if (--gTasks[taskId].data[13] == 0)
case SENDTASK_STATE_UNUSED_STATE:
if (--gTasks[taskId].tBlockSendDelayTimer == 0)
{
gTasks[taskId].data[13] = 1;
gTasks[taskId].data[11] = 3;
gTasks[taskId].tBlockSendDelayTimer = 1;
gTasks[taskId].tState = SENDTASK_STATE_BEGIN_SEND_BLOCK;
}
break;
}
#undef BYTE_TO_SEND
}
// We have received a message. Place it into the "receive" buffer.
//
// Counterintuitively, we also "receive" the outbound messages that
// we send to other players. The GBA basically stores communicated
// data for all four players, so inbound and outbound data can be
// handled uniformly unless a game specifically decides to do
// otherwise. Pokemon, evidently, did not specifically decide to do
// otherwise.
void TryReceiveLinkBattleData(void)
{
u8 i;
@ -858,19 +909,19 @@ void TryReceiveLinkBattleData(void)
u8 *dest, *src;
u16 dataSize = gBlockRecvBuffer[i][2];
if (gTasks[sLinkReceiveTaskId].data[14] + 9 + dataSize > 0x1000)
if (gTasks[sLinkReceiveTaskId].tCurrentBlock_End + 9 + dataSize > 0x1000)
{
gTasks[sLinkReceiveTaskId].data[12] = gTasks[sLinkReceiveTaskId].data[14];
gTasks[sLinkReceiveTaskId].data[14] = 0;
gTasks[sLinkReceiveTaskId].tCurrentBlock_WrapFrom = gTasks[sLinkReceiveTaskId].tCurrentBlock_End;
gTasks[sLinkReceiveTaskId].tCurrentBlock_End = 0;
}
dest = &gLinkBattleRecvBuffer[gTasks[sLinkReceiveTaskId].data[14]];
dest = &gLinkBattleRecvBuffer[gTasks[sLinkReceiveTaskId].tCurrentBlock_End];
src = recvBuffer;
for (j = 0; j < dataSize + 8; j++)
dest[j] = src[j];
gTasks[sLinkReceiveTaskId].data[14] = gTasks[sLinkReceiveTaskId].data[14] + dataSize + 8;
gTasks[sLinkReceiveTaskId].tCurrentBlock_End = gTasks[sLinkReceiveTaskId].tCurrentBlock_End + dataSize + 8;
}
}
}
@ -881,49 +932,61 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
{
u16 blockSize;
u8 battler;
u8 var;
u8 playerId;
if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
#define BYTE_TO_RECEIVE(offset) \
gLinkBattleRecvBuffer[gTasks[taskId].tCurrentBlock_Start + offset]
if (gTasks[taskId].tCurrentBlock_Start != gTasks[taskId].tCurrentBlock_End)
{
if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
&& gTasks[taskId].data[15] == gTasks[taskId].data[12])
if (gTasks[taskId].tCurrentBlock_Start > gTasks[taskId].tCurrentBlock_End
&& gTasks[taskId].tCurrentBlock_Start == gTasks[taskId].tCurrentBlock_WrapFrom)
{
gTasks[taskId].data[12] = 0;
gTasks[taskId].data[15] = 0;
gTasks[taskId].tCurrentBlock_WrapFrom = 0;
gTasks[taskId].tCurrentBlock_Start = 0;
}
battler = 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);
battler = BYTE_TO_RECEIVE(LINK_BUFF_ACTIVE_BATTLER);
blockSize = BYTE_TO_RECEIVE(LINK_BUFF_SIZE_LO) | (BYTE_TO_RECEIVE(LINK_BUFF_SIZE_HI) << 8);
switch (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 0])
switch (BYTE_TO_RECEIVE(0))
{
case 0:
if (gBattleControllerExecFlags & (1u << battler))
case B_COMM_TO_CONTROLLER:
if (IS_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battler))
return;
memcpy(gBattleResources->bufferA[battler], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA], blockSize);
memcpy(gBattleResources->bufferA[battler], &BYTE_TO_RECEIVE(LINK_BUFF_DATA), blockSize);
MarkBattlerReceivedLinkData(battler);
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];
gBattlerAttacker = BYTE_TO_RECEIVE(LINK_BUFF_ATTACKER);
gBattlerTarget = BYTE_TO_RECEIVE(LINK_BUFF_TARGET);
gAbsentBattlerFlags = BYTE_TO_RECEIVE(LINK_BUFF_ABSENT_BATTLER_FLAGS);
gEffectBattler = BYTE_TO_RECEIVE(LINK_BUFF_EFFECT_BATTLER);
}
break;
case 1:
memcpy(gBattleResources->bufferB[battler], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA], blockSize);
case B_COMM_TO_ENGINE:
memcpy(gBattleResources->bufferB[battler], &gLinkBattleRecvBuffer[gTasks[taskId].tCurrentBlock_Start + LINK_BUFF_DATA], blockSize);
break;
case 2:
var = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA];
gBattleControllerExecFlags &= ~(1u << (battler + var * 4));
case B_COMM_CONTROLLER_IS_DONE:
playerId = BYTE_TO_RECEIVE(LINK_BUFF_DATA);
MARK_BATTLE_CONTROLLER_IDLE_FOR_PLAYER(battler, playerId);
break;
}
gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
gTasks[taskId].tCurrentBlock_Start = gTasks[taskId].tCurrentBlock_Start + blockSize + LINK_BUFF_DATA;
}
#undef BYTE_TO_RECEIVE
}
#undef tInitialDelayTimer
#undef tState
#undef tCurrentBlock_WrapFrom
#undef tBlockSendDelayTimer
#undef tCurrentBlock_End
#undef tCurrentBlock_Start
void BtlController_EmitGetMonData(u32 battler, u32 bufferId, u8 requestId, u8 monToCheck)
{
gBattleResources->transferBuffer[0] = CONTROLLER_GETMONDATA;
@ -2346,7 +2409,7 @@ void BtlController_HandleGetMonData(u32 battler)
monToCheck >>= 1;
}
}
BtlController_EmitDataTransfer(battler, BUFFER_B, size, monData);
BtlController_EmitDataTransfer(battler, B_COMM_TO_ENGINE, size, monData);
BattleControllerComplete(battler);
}
@ -2362,7 +2425,7 @@ void BtlController_HandleGetRawMonData(u32 battler)
for (i = 0; i < gBattleResources->bufferA[battler][2]; i++)
dst[i] = src[i];
BtlController_EmitDataTransfer(battler, BUFFER_B, gBattleResources->bufferA[battler][2], dst);
BtlController_EmitDataTransfer(battler, B_COMM_TO_ENGINE, gBattleResources->bufferA[battler][2], dst);
BattleControllerComplete(battler);
}

58
src/battle_main.c
View File

@ -3320,7 +3320,7 @@ const u8* FaintClearSetData(u32 battler)
u32 partner = BATTLE_PARTNER(battler);
if (IsBattlerAlive(partner))
{
BtlController_EmitSpriteInvisibility(partner, BUFFER_A, FALSE);
BtlController_EmitSpriteInvisibility(partner, B_COMM_TO_CONTROLLER, FALSE);
MarkBattlerForControllerExec(partner);
}
}
@ -3398,7 +3398,7 @@ static void DoBattleIntro(void)
{
case BATTLE_INTRO_STATE_GET_MON_DATA:
battler = gBattleCommunication[1];
BtlController_EmitGetMonData(battler, BUFFER_A, REQUEST_ALL_BATTLE, 0);
BtlController_EmitGetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_ALL_BATTLE, 0);
MarkBattlerForControllerExec(battler);
gBattleStruct->introState++;
break;
@ -3415,7 +3415,7 @@ static void DoBattleIntro(void)
if (!gBattleControllerExecFlags)
{
battler = GetBattlerAtPosition(0);
BtlController_EmitIntroSlide(battler, BUFFER_A, gBattleEnvironment);
BtlController_EmitIntroSlide(battler, B_COMM_TO_CONTROLLER, gBattleEnvironment);
MarkBattlerForControllerExec(battler);
gBattleCommunication[0] = 0;
gBattleCommunication[1] = 0;
@ -3459,18 +3459,18 @@ static void DoBattleIntro(void)
switch (GetBattlerPosition(battler))
{
case B_POSITION_PLAYER_LEFT: // player sprite
BtlController_EmitDrawTrainerPic(battler, BUFFER_A);
BtlController_EmitDrawTrainerPic(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
break;
case B_POSITION_OPPONENT_LEFT:
if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) // opponent 1 sprite
{
BtlController_EmitDrawTrainerPic(battler, BUFFER_A);
BtlController_EmitDrawTrainerPic(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
else // wild mon 1
{
BtlController_EmitLoadMonSprite(battler, BUFFER_A);
BtlController_EmitLoadMonSprite(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL);
}
@ -3478,7 +3478,7 @@ static void DoBattleIntro(void)
case B_POSITION_PLAYER_RIGHT:
if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_INGAME_PARTNER)) // partner sprite
{
BtlController_EmitDrawTrainerPic(battler, BUFFER_A);
BtlController_EmitDrawTrainerPic(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
break;
@ -3487,13 +3487,13 @@ static void DoBattleIntro(void)
{
if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS) && !BATTLE_TWO_VS_ONE_OPPONENT) // opponent 2 if exists
{
BtlController_EmitDrawTrainerPic(battler, BUFFER_A);
BtlController_EmitDrawTrainerPic(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
}
else if (IsBattlerAlive(battler)) // wild mon 2 if alive
{
BtlController_EmitLoadMonSprite(battler, BUFFER_A);
BtlController_EmitLoadMonSprite(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL);
}
@ -3530,7 +3530,7 @@ static void DoBattleIntro(void)
}
battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
BtlController_EmitDrawPartyStatusSummary(battler, BUFFER_A, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY);
BtlController_EmitDrawPartyStatusSummary(battler, B_COMM_TO_CONTROLLER, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY);
MarkBattlerForControllerExec(battler);
for (i = 0; i < PARTY_SIZE; i++)
@ -3549,7 +3549,7 @@ static void DoBattleIntro(void)
}
battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
BtlController_EmitDrawPartyStatusSummary(battler, BUFFER_A, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY);
BtlController_EmitDrawPartyStatusSummary(battler, B_COMM_TO_CONTROLLER, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY);
MarkBattlerForControllerExec(battler);
gBattleStruct->introState++;
@ -3599,7 +3599,7 @@ static void DoBattleIntro(void)
else
battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A);
BtlController_EmitIntroTrainerBallThrow(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattleStruct->introState++;
break;
@ -3611,7 +3611,7 @@ static void DoBattleIntro(void)
else
battler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A);
BtlController_EmitIntroTrainerBallThrow(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
if (B_FAST_INTRO_PKMN_TEXT == TRUE
@ -3667,7 +3667,7 @@ static void DoBattleIntro(void)
else
battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A);
BtlController_EmitIntroTrainerBallThrow(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattleStruct->introState++;
break;
@ -3679,7 +3679,7 @@ static void DoBattleIntro(void)
else
battler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A);
BtlController_EmitIntroTrainerBallThrow(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
gBattleStruct->introState++;
@ -4228,7 +4228,7 @@ static void HandleTurnActionSelectionState(void)
else
{
gBattleStruct->itemPartyIndex[battler] = PARTY_SIZE;
BtlController_EmitChooseAction(battler, BUFFER_A, gChosenActionByBattler[0], gBattleResources->bufferB[0][1] | (gBattleResources->bufferB[0][2] << 8));
BtlController_EmitChooseAction(battler, B_COMM_TO_CONTROLLER, gChosenActionByBattler[0], gBattleResources->bufferB[0][1] | (gBattleResources->bufferB[0][2] << 8));
MarkBattlerForControllerExec(battler);
gBattleCommunication[battler]++;
}
@ -4279,7 +4279,7 @@ static void HandleTurnActionSelectionState(void)
i);
}
BtlController_EmitChooseMove(battler, BUFFER_A, IsDoubleBattle() != 0, FALSE, &moveInfo);
BtlController_EmitChooseMove(battler, B_COMM_TO_CONTROLLER, IsDoubleBattle() != 0, FALSE, &moveInfo);
MarkBattlerForControllerExec(battler);
}
break;
@ -4311,7 +4311,7 @@ static void HandleTurnActionSelectionState(void)
}
else
{
BtlController_EmitChooseItem(battler, BUFFER_A, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChooseItem(battler, B_COMM_TO_CONTROLLER, gBattleStruct->battlerPartyOrders[battler]);
MarkBattlerForControllerExec(battler);
}
break;
@ -4320,21 +4320,21 @@ static void HandleTurnActionSelectionState(void)
if (gBattleTypeFlags & BATTLE_TYPE_ARENA
|| !CanBattlerEscape(battler))
{
BtlController_EmitChoosePokemon(battler, BUFFER_A, PARTY_ACTION_CANT_SWITCH, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChoosePokemon(battler, B_COMM_TO_CONTROLLER, PARTY_ACTION_CANT_SWITCH, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
}
else if (ItemId_GetHoldEffect(gBattleMons[battler].item) != HOLD_EFFECT_SHED_SHELL
&& (i = IsAbilityPreventingEscape(battler))) // must be last to keep i value integrity
{
BtlController_EmitChoosePokemon(battler, BUFFER_A, ((i - 1) << 4) | PARTY_ACTION_ABILITY_PREVENTS, PARTY_SIZE, gBattleMons[i - 1].ability, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChoosePokemon(battler, B_COMM_TO_CONTROLLER, ((i - 1) << 4) | PARTY_ACTION_ABILITY_PREVENTS, PARTY_SIZE, gBattleMons[i - 1].ability, gBattleStruct->battlerPartyOrders[battler]);
}
else
{
if (battler == 2 && gChosenActionByBattler[0] == B_ACTION_SWITCH)
BtlController_EmitChoosePokemon(battler, BUFFER_A, PARTY_ACTION_CHOOSE_MON, gBattleStruct->monToSwitchIntoId[0], ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChoosePokemon(battler, B_COMM_TO_CONTROLLER, PARTY_ACTION_CHOOSE_MON, gBattleStruct->monToSwitchIntoId[0], ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
else if (battler == 3 && gChosenActionByBattler[1] == B_ACTION_SWITCH)
BtlController_EmitChoosePokemon(battler, BUFFER_A, PARTY_ACTION_CHOOSE_MON, gBattleStruct->monToSwitchIntoId[1], ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChoosePokemon(battler, B_COMM_TO_CONTROLLER, PARTY_ACTION_CHOOSE_MON, gBattleStruct->monToSwitchIntoId[1], ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
else
BtlController_EmitChoosePokemon(battler, BUFFER_A, PARTY_ACTION_CHOOSE_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChoosePokemon(battler, B_COMM_TO_CONTROLLER, PARTY_ACTION_CHOOSE_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
}
MarkBattlerForControllerExec(battler);
break;
@ -4349,7 +4349,7 @@ static void HandleTurnActionSelectionState(void)
}
break;
case B_ACTION_SAFARI_POKEBLOCK:
BtlController_EmitChooseItem(battler, BUFFER_A, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChooseItem(battler, B_COMM_TO_CONTROLLER, gBattleStruct->battlerPartyOrders[battler]);
MarkBattlerForControllerExec(battler);
break;
case B_ACTION_CANCEL_PARTNER:
@ -4359,7 +4359,7 @@ static void HandleTurnActionSelectionState(void)
if (gBattleMons[GetPartnerBattler(battler)].status2 & STATUS2_MULTIPLETURNS
|| gBattleMons[GetPartnerBattler(battler)].status2 & STATUS2_RECHARGE)
{
BtlController_EmitEndBounceEffect(battler, BUFFER_A);
BtlController_EmitEndBounceEffect(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
return;
}
@ -4389,11 +4389,11 @@ static void HandleTurnActionSelectionState(void)
}
gBattleStruct->gimmick.toActivate &= ~((1u << BATTLE_PARTNER(GetBattlerPosition(battler))));
BtlController_EmitEndBounceEffect(battler, BUFFER_A);
BtlController_EmitEndBounceEffect(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
return;
case B_ACTION_DEBUG:
BtlController_EmitDebugMenu(battler, BUFFER_A);
BtlController_EmitDebugMenu(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
break;
}
@ -4577,11 +4577,11 @@ static void HandleTurnActionSelectionState(void)
|| (position & BIT_FLANK) != B_FLANK_LEFT
|| gBattleStruct->battlerState[GetBattlerAtPosition(BATTLE_PARTNER(position))].absentBattlerFlags)
{
BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_STOP_BOUNCE, i);
BtlController_EmitLinkStandbyMsg(battler, B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_STOP_BOUNCE, i);
}
else
{
BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_STOP_BOUNCE_ONLY, i);
BtlController_EmitLinkStandbyMsg(battler, B_COMM_TO_CONTROLLER, LINK_STANDBY_STOP_BOUNCE_ONLY, i);
}
MarkBattlerForControllerExec(battler);
gBattleCommunication[battler]++;

224
src/battle_script_commands.c
View File

@ -1782,7 +1782,7 @@ static void Cmd_ppreduce(void)
if (MOVE_IS_PERMANENT(gBattlerAttacker, gCurrMovePos))
{
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_PPMOVE1_BATTLE + gCurrMovePos, 0,
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_PPMOVE1_BATTLE + gCurrMovePos, 0,
sizeof(gBattleMons[gBattlerAttacker].pp[gCurrMovePos]),
&gBattleMons[gBattlerAttacker].pp[gCurrMovePos]);
MarkBattlerForControllerExec(gBattlerAttacker);
@ -2452,7 +2452,7 @@ static void Cmd_attackanimation(void)
}
BtlController_EmitMoveAnimation(gBattlerAttacker,
BUFFER_A,
B_COMM_TO_CONTROLLER,
gCurrentMove,
gBattleScripting.animTurn,
gBattleMovePower,
@ -2498,7 +2498,7 @@ static void DoublesHPBarReduction(void)
s32 currDmg = gBattleStruct->moveDamage[battlerDef];
s32 healthValue = min(currDmg, 10000); // Max damage (10000) not present in R/S, ensures that huge damage values don't change sign
BtlController_EmitHealthBarUpdate(battlerDef, BUFFER_A, healthValue);
BtlController_EmitHealthBarUpdate(battlerDef, B_COMM_TO_CONTROLLER, healthValue);
MarkBattlerForControllerExec(battlerDef);
if (GetBattlerSide(battlerDef) == B_SIDE_PLAYER && currDmg > 0)
@ -2534,7 +2534,7 @@ static void Cmd_healthbarupdate(void)
{
s16 healthValue = min(gBattleStruct->moveDamage[battler], 10000); // Max damage (10000) not present in R/S, ensures that huge damage values don't change sign
BtlController_EmitHealthBarUpdate(battler, BUFFER_A, healthValue);
BtlController_EmitHealthBarUpdate(battler, B_COMM_TO_CONTROLLER, healthValue);
MarkBattlerForControllerExec(battler);
if (GetBattlerSide(battler) == B_SIDE_PLAYER && gBattleStruct->moveDamage[battler] > 0)
@ -2674,7 +2674,7 @@ static void Cmd_datahpupdate(void)
}
gHitMarker &= ~HITMARKER_PASSIVE_DAMAGE;
// Send updated HP
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[battler].hp), &gBattleMons[battler].hp);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[battler].hp), &gBattleMons[battler].hp);
MarkBattlerForControllerExec(battler);
}
@ -2735,11 +2735,11 @@ static void Cmd_effectivenesssound(void)
switch (moveResultFlags & ~MOVE_RESULT_MISSED)
{
case MOVE_RESULT_SUPER_EFFECTIVE:
BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_SUPER_EFFECTIVE);
BtlController_EmitPlaySE(gBattlerTarget, B_COMM_TO_CONTROLLER, SE_SUPER_EFFECTIVE);
MarkBattlerForControllerExec(gBattlerTarget);
break;
case MOVE_RESULT_NOT_VERY_EFFECTIVE:
BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_NOT_EFFECTIVE);
BtlController_EmitPlaySE(gBattlerTarget, B_COMM_TO_CONTROLLER, SE_NOT_EFFECTIVE);
MarkBattlerForControllerExec(gBattlerTarget);
break;
case MOVE_RESULT_DOESNT_AFFECT_FOE:
@ -2753,17 +2753,17 @@ static void Cmd_effectivenesssound(void)
default:
if (moveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE)
{
BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_SUPER_EFFECTIVE);
BtlController_EmitPlaySE(gBattlerTarget, B_COMM_TO_CONTROLLER, SE_SUPER_EFFECTIVE);
MarkBattlerForControllerExec(gBattlerTarget);
}
else if (moveResultFlags & MOVE_RESULT_NOT_VERY_EFFECTIVE)
{
BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_NOT_EFFECTIVE);
BtlController_EmitPlaySE(gBattlerTarget, B_COMM_TO_CONTROLLER, SE_NOT_EFFECTIVE);
MarkBattlerForControllerExec(gBattlerTarget);
}
else if (!(moveResultFlags & (MOVE_RESULT_DOESNT_AFFECT_FOE | MOVE_RESULT_FAILED)))
{
BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_EFFECTIVE);
BtlController_EmitPlaySE(gBattlerTarget, B_COMM_TO_CONTROLLER, SE_EFFECTIVE);
MarkBattlerForControllerExec(gBattlerTarget);
}
break;
@ -2972,7 +2972,7 @@ static void Cmd_printselectionstring(void)
{
CMD_ARGS(u16 id);
BtlController_EmitPrintSelectionString(gBattlerAttacker, BUFFER_A, cmd->id);
BtlController_EmitPrintSelectionString(gBattlerAttacker, B_COMM_TO_CONTROLLER, cmd->id);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -3028,7 +3028,7 @@ static void Cmd_printselectionstringfromtable(void)
const u16 *ptr = cmd->ptr;
ptr += gBattleCommunication[MULTISTRING_CHOOSER];
BtlController_EmitPrintSelectionString(gBattlerAttacker, BUFFER_A, *ptr);
BtlController_EmitPrintSelectionString(gBattlerAttacker, B_COMM_TO_CONTROLLER, *ptr);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -3075,14 +3075,14 @@ void StealTargetItem(u8 battlerStealer, u8 battlerItem)
gBattleMons[battlerStealer].item = gLastUsedItem;
gDisableStructs[battlerStealer].unburdenActive = FALSE;
BtlController_EmitSetMonData(battlerStealer, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gLastUsedItem), &gLastUsedItem); // set attacker item
BtlController_EmitSetMonData(battlerStealer, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gLastUsedItem), &gLastUsedItem); // set attacker item
MarkBattlerForControllerExec(battlerStealer);
}
RecordItemEffectBattle(battlerItem, ITEM_NONE);
CheckSetUnburden(battlerItem);
BtlController_EmitSetMonData(battlerItem, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[battlerItem].item); // remove target item
BtlController_EmitSetMonData(battlerItem, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[battlerItem].item); // remove target item
MarkBattlerForControllerExec(battlerItem);
gBattleStruct->choicedMove[battlerItem] = 0;
@ -3476,7 +3476,7 @@ void SetMoveEffect(bool32 primary, bool32 certain)
gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleScripting.moveEffect];
BtlController_EmitSetMonData(gEffectBattler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].status1), &gBattleMons[gEffectBattler].status1);
BtlController_EmitSetMonData(gEffectBattler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].status1), &gBattleMons[gEffectBattler].status1);
MarkBattlerForControllerExec(gEffectBattler);
if (gHitMarker & HITMARKER_STATUS_ABILITY_EFFECT)
@ -3946,7 +3946,7 @@ void SetMoveEffect(bool32 primary, bool32 certain)
gBattleMons[gEffectBattler].item = 0;
CheckSetUnburden(gEffectBattler);
BtlController_EmitSetMonData(gEffectBattler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item);
BtlController_EmitSetMonData(gEffectBattler, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item);
MarkBattlerForControllerExec(gEffectBattler);
BattleScriptPush(gBattlescriptCurrInstr + 1);
gBattlescriptCurrInstr = BattleScript_MoveEffectIncinerate;
@ -3961,7 +3961,7 @@ void SetMoveEffect(bool32 primary, bool32 certain)
gBattleMons[gEffectBattler].item = 0;
CheckSetUnburden(gEffectBattler);
BtlController_EmitSetMonData(gEffectBattler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item);
BtlController_EmitSetMonData(gEffectBattler, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item);
MarkBattlerForControllerExec(gEffectBattler);
BattleScriptPush(gBattlescriptCurrInstr + 1);
gBattlescriptCurrInstr = BattleScript_MoveEffectBugBite;
@ -4263,7 +4263,7 @@ void SetMoveEffect(bool32 primary, bool32 certain)
if (!(gDisableStructs[gBattlerTarget].mimickedMoves & (1u << i))
&& !(gBattleMons[gBattlerTarget].status2 & STATUS2_TRANSFORMED))
{
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[gBattlerTarget].pp[i]), &gBattleMons[gBattlerTarget].pp[i]);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[gBattlerTarget].pp[i]), &gBattleMons[gBattlerTarget].pp[i]);
MarkBattlerForControllerExec(gBattlerTarget);
}
@ -4786,7 +4786,7 @@ static void Cmd_tryfaintmon(void)
gBattleMons[gBattlerAttacker].pp[moveIndex] = 0;
BattleScriptPush(gBattlescriptCurrInstr);
gBattlescriptCurrInstr = BattleScript_GrudgeTakesPp;
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, moveIndex + REQUEST_PPMOVE1_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].pp[moveIndex]), &gBattleMons[gBattlerAttacker].pp[moveIndex]);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, moveIndex + REQUEST_PPMOVE1_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].pp[moveIndex]), &gBattleMons[gBattlerAttacker].pp[moveIndex]);
MarkBattlerForControllerExec(gBattlerAttacker);
PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerAttacker].moves[moveIndex])
@ -4819,7 +4819,7 @@ static void Cmd_dofaintanimation(void)
return;
}
BtlController_EmitFaintAnimation(battler, BUFFER_A);
BtlController_EmitFaintAnimation(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
}
@ -4835,7 +4835,7 @@ static void Cmd_cleareffectsonfaint(void)
if (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || !IsBattlerAlive(battler))
{
gBattleMons[battler].status1 = 0;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}
@ -5264,7 +5264,7 @@ static void Cmd_getexp(void)
gBattleResources->beforeLvlUp->stats[STAT_SPATK] = GetMonData(&gPlayerParty[*expMonId], MON_DATA_SPATK);
gBattleResources->beforeLvlUp->stats[STAT_SPDEF] = GetMonData(&gPlayerParty[*expMonId], MON_DATA_SPDEF);
BtlController_EmitExpUpdate(gBattleStruct->expGetterBattlerId, BUFFER_A, *expMonId, gBattleStruct->battlerExpReward);
BtlController_EmitExpUpdate(gBattleStruct->expGetterBattlerId, B_COMM_TO_CONTROLLER, *expMonId, gBattleStruct->battlerExpReward);
MarkBattlerForControllerExec(gBattleStruct->expGetterBattlerId);
}
gBattleScripting.getexpState++;
@ -5861,7 +5861,7 @@ static void Cmd_absorb(void)
return;
u32 battler = GetBattlerForBattleScript(cmd->battler);
BtlController_EmitHealthBarUpdate(battler, BUFFER_A, gBattleStruct->moveDamage[battler]);
BtlController_EmitHealthBarUpdate(battler, B_COMM_TO_CONTROLLER, gBattleStruct->moveDamage[battler]);
MarkBattlerForControllerExec(battler);
if (GetBattlerSide(battler) == B_SIDE_PLAYER && gBattleStruct->moveDamage[battler] > 0)
@ -5966,7 +5966,7 @@ static void PlayAnimation(u32 battler, u8 animId, const u16 *argPtr, const u8 *n
|| animId == B_ANIM_TERA_CHARGE
|| animId == B_ANIM_TERA_ACTIVATE)
{
BtlController_EmitBattleAnimation(battler, BUFFER_A, animId, &gDisableStructs[battler], *argPtr);
BtlController_EmitBattleAnimation(battler, B_COMM_TO_CONTROLLER, animId, &gDisableStructs[battler], *argPtr);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = nextInstr;
}
@ -5982,7 +5982,7 @@ static void PlayAnimation(u32 battler, u8 animId, const u16 *argPtr, const u8 *n
|| animId == B_ANIM_SNOW_CONTINUES
|| animId == B_ANIM_FOG_CONTINUES)
{
BtlController_EmitBattleAnimation(battler, BUFFER_A, animId, &gDisableStructs[battler], *argPtr);
BtlController_EmitBattleAnimation(battler, B_COMM_TO_CONTROLLER, animId, &gDisableStructs[battler], *argPtr);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = nextInstr;
}
@ -5992,7 +5992,7 @@ static void PlayAnimation(u32 battler, u8 animId, const u16 *argPtr, const u8 *n
}
else
{
BtlController_EmitBattleAnimation(battler, BUFFER_A, animId, &gDisableStructs[battler], *argPtr);
BtlController_EmitBattleAnimation(battler, B_COMM_TO_CONTROLLER, animId, &gDisableStructs[battler], *argPtr);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = nextInstr;
}
@ -6157,7 +6157,7 @@ static void Cmd_playstatchangeanimation(void)
}
else if (changeableStatsCount != 0 && !gBattleScripting.statAnimPlayed)
{
BtlController_EmitBattleAnimation(battler, BUFFER_A, B_ANIM_STATS_CHANGE, &gDisableStructs[battler], statAnimId);
BtlController_EmitBattleAnimation(battler, B_COMM_TO_CONTROLLER, B_ANIM_STATS_CHANGE, &gDisableStructs[battler], statAnimId);
MarkBattlerForControllerExec(battler);
if (flags & STAT_CHANGE_MULTIPLE_STATS && changeableStatsCount > 1)
gBattleScripting.statAnimPlayed = TRUE;
@ -6194,7 +6194,7 @@ static bool32 TryKnockOffBattleScript(u32 battlerDef)
// In Gen 5+, Knock Off removes the target's item rather than rendering it unusable.
if (B_KNOCK_OFF_REMOVAL >= GEN_5)
{
BtlController_EmitSetMonData(battlerDef, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerDef].item), &gBattleMons[battlerDef].item);
BtlController_EmitSetMonData(battlerDef, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerDef].item), &gBattleMons[battlerDef].item);
MarkBattlerForControllerExec(battlerDef);
}
else
@ -6410,7 +6410,7 @@ static void Cmd_moveend(void)
{
gProtectStructs[gBattlerAttacker].touchedProtectLike = FALSE;
gBattleMons[gBattlerAttacker].status1 = STATUS1_BURN;
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].status1), &gBattleMons[gBattlerAttacker].status1);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].status1), &gBattleMons[gBattlerAttacker].status1);
MarkBattlerForControllerExec(gBattlerAttacker);
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BeakBlastBurn;
@ -6479,7 +6479,7 @@ static void Cmd_moveend(void)
&& !(gBattleStruct->moveResultFlags[gBattlerTarget] & MOVE_RESULT_NO_EFFECT))
{
gBattleMons[gBattlerTarget].status1 &= ~STATUS1_FREEZE;
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
MarkBattlerForControllerExec(gBattlerTarget);
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_DefrostedViaFireMove;
@ -6492,7 +6492,7 @@ static void Cmd_moveend(void)
&& !(gBattleStruct->moveResultFlags[gBattlerTarget] & MOVE_RESULT_NO_EFFECT))
{
gBattleMons[gBattlerTarget].status1 &= ~STATUS1_FROSTBITE;
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
MarkBattlerForControllerExec(gBattlerTarget);
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_FrostbiteHealedViaFireMove;
@ -6782,7 +6782,7 @@ static void Cmd_moveend(void)
if (gStatuses3[gBattlerAttacker] & (STATUS3_SEMI_INVULNERABLE)
&& gHitMarker & (HITMARKER_NO_ANIMATIONS | HITMARKER_DISABLE_ANIMATION))
{
BtlController_EmitSpriteInvisibility(gBattlerAttacker, BUFFER_A, TRUE);
BtlController_EmitSpriteInvisibility(gBattlerAttacker, B_COMM_TO_CONTROLLER, TRUE);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattleScripting.moveendState++;
return;
@ -6794,7 +6794,7 @@ static void Cmd_moveend(void)
|| !(gStatuses3[gBattlerAttacker] & (STATUS3_SEMI_INVULNERABLE))
|| WasUnableToUseMove(gBattlerAttacker))
{
BtlController_EmitSpriteInvisibility(gBattlerAttacker, BUFFER_A, FALSE);
BtlController_EmitSpriteInvisibility(gBattlerAttacker, B_COMM_TO_CONTROLLER, FALSE);
MarkBattlerForControllerExec(gBattlerAttacker);
gStatuses3[gBattlerAttacker] &= ~STATUS3_SEMI_INVULNERABLE;
gSpecialStatuses[gBattlerAttacker].restoredBattlerSprite = TRUE;
@ -6807,7 +6807,7 @@ static void Cmd_moveend(void)
if (!gSpecialStatuses[gBattlerTarget].restoredBattlerSprite && gBattlerTarget < gBattlersCount
&& !(gStatuses3[gBattlerTarget] & STATUS3_SEMI_INVULNERABLE))
{
BtlController_EmitSpriteInvisibility(gBattlerTarget, BUFFER_A, FALSE);
BtlController_EmitSpriteInvisibility(gBattlerTarget, B_COMM_TO_CONTROLLER, FALSE);
MarkBattlerForControllerExec(gBattlerTarget);
gStatuses3[gBattlerTarget] &= ~STATUS3_SEMI_INVULNERABLE;
gBattleScripting.moveendState++;
@ -7578,7 +7578,7 @@ static void Cmd_returnatktoball(void)
if (!(gHitMarker & HITMARKER_FAINTED(gBattlerAttacker)))
{
BtlController_EmitReturnMonToBall(gBattlerAttacker, BUFFER_A, FALSE);
BtlController_EmitReturnMonToBall(gBattlerAttacker, B_COMM_TO_CONTROLLER, FALSE);
MarkBattlerForControllerExec(gBattlerAttacker);
}
gBattlescriptCurrInstr = cmd->nextInstr;
@ -7594,7 +7594,7 @@ static void Cmd_getswitchedmondata(void)
gBattlerPartyIndexes[battler] = gBattleStruct->monToSwitchIntoId[battler];
BtlController_EmitGetMonData(battler, BUFFER_A, REQUEST_ALL_BATTLE, 1u << gBattlerPartyIndexes[battler]);
BtlController_EmitGetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_ALL_BATTLE, 1u << gBattlerPartyIndexes[battler]);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -7640,7 +7640,7 @@ static void Cmd_switchindataupdate(void)
if (i != PARTY_SIZE)
{
gBattlerPartyIndexes[battler] = gBattleStruct->monToSwitchIntoId[battler] = i;
BtlController_EmitGetMonData(battler, BUFFER_A, REQUEST_ALL_BATTLE, 1u << gBattlerPartyIndexes[battler]);
BtlController_EmitGetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_ALL_BATTLE, 1u << gBattlerPartyIndexes[battler]);
MarkBattlerForControllerExec(battler);
return;
}
@ -7715,7 +7715,7 @@ static void Cmd_switchinanim(void)
gAbsentBattlerFlags &= ~(1u << battler);
BtlController_EmitSwitchInAnim(battler, BUFFER_A, gBattlerPartyIndexes[battler], cmd->dontClearTransform, cmd->dontClearSubstitute);
BtlController_EmitSwitchInAnim(battler, B_COMM_TO_CONTROLLER, gBattlerPartyIndexes[battler], cmd->dontClearTransform, cmd->dontClearSubstitute);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -7894,7 +7894,7 @@ static void ChooseMonToSendOut(u32 battler, u8 slotId)
gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE;
gBattleStruct->field_93 &= ~(1u << battler);
BtlController_EmitChoosePokemon(battler, BUFFER_A, PARTY_ACTION_SEND_OUT, slotId, ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChoosePokemon(battler, B_COMM_TO_CONTROLLER, PARTY_ACTION_SEND_OUT, slotId, ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
MarkBattlerForControllerExec(battler);
}
@ -7919,7 +7919,7 @@ static void Cmd_openpartyscreen(void)
{
gAbsentBattlerFlags |= 1u << battler;
gHitMarker &= ~HITMARKER_FAINTED(battler);
BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE);
BtlController_EmitLinkStandbyMsg(battler, B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_ONLY, FALSE);
MarkBattlerForControllerExec(battler);
}
else if (!gSpecialStatuses[battler].faintedHasReplacement)
@ -7930,7 +7930,7 @@ static void Cmd_openpartyscreen(void)
}
else
{
BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE);
BtlController_EmitLinkStandbyMsg(battler, B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_ONLY, FALSE);
MarkBattlerForControllerExec(battler);
}
}
@ -7952,7 +7952,7 @@ static void Cmd_openpartyscreen(void)
{
gAbsentBattlerFlags |= 1u << battler;
gHitMarker &= ~HITMARKER_FAINTED(battler);
BtlController_EmitCantSwitch(battler, BUFFER_A);
BtlController_EmitCantSwitch(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
else if (!gSpecialStatuses[battler].faintedHasReplacement)
@ -7962,7 +7962,7 @@ static void Cmd_openpartyscreen(void)
}
else if (battler < 2 || (battler > 1 && !(flags & BATTLE_PARTNER(battler))))
{
BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE);
BtlController_EmitLinkStandbyMsg(battler, B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_ONLY, FALSE);
MarkBattlerForControllerExec(battler);
flags |= battler;
}
@ -7981,7 +7981,7 @@ static void Cmd_openpartyscreen(void)
else
battler = i;
BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE);
BtlController_EmitLinkStandbyMsg(battler, B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_ONLY, FALSE);
MarkBattlerForControllerExec(battler);
}
}
@ -8005,7 +8005,7 @@ static void Cmd_openpartyscreen(void)
{
gAbsentBattlerFlags |= (1u << battler);
gHitMarker &= ~(HITMARKER_FAINTED(battler));
BtlController_EmitCantSwitch(battler, BUFFER_A);
BtlController_EmitCantSwitch(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
else if (!gSpecialStatuses[battler].faintedHasReplacement)
@ -8063,7 +8063,7 @@ static void Cmd_openpartyscreen(void)
gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE;
gBattleStruct->field_93 &= ~(1u << battler);
BtlController_EmitChoosePokemon(battler, BUFFER_A, hitmarkerFaintBits, gBattleStruct->monToSwitchIntoId[BATTLE_PARTNER(battler)], ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
BtlController_EmitChoosePokemon(battler, B_COMM_TO_CONTROLLER, hitmarkerFaintBits, gBattleStruct->monToSwitchIntoId[BATTLE_PARTNER(battler)], ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8077,7 +8077,7 @@ static void Cmd_openpartyscreen(void)
{
if (i != battler)
{
BtlController_EmitLinkStandbyMsg(i, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE);
BtlController_EmitLinkStandbyMsg(i, B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_ONLY, FALSE);
MarkBattlerForControllerExec(i);
}
}
@ -8091,7 +8091,7 @@ static void Cmd_openpartyscreen(void)
// Make sure we're checking a valid battler. In edge case scenarios - battler could be absent and battlerOpposite would become a non-existent one softlocking the game.
if (battlerOpposite < gBattlersCount)
{
BtlController_EmitLinkStandbyMsg(battlerOpposite, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE);
BtlController_EmitLinkStandbyMsg(battlerOpposite, B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_ONLY, FALSE);
MarkBattlerForControllerExec(battlerOpposite);
}
}
@ -8286,7 +8286,7 @@ static bool32 DoSwitchInEffectsForBattler(u32 battler)
else
gBattleMons[battler].status1 |= STATUS1_POISON;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
gBattleScripting.battler = battler;
BattleScriptPushCursor();
@ -8453,7 +8453,7 @@ static void Cmd_trainerslidein(void)
CMD_ARGS(u8 position);
u32 battler = GetBattlerForBattleScript(cmd->position);
BtlController_EmitTrainerSlide(battler, BUFFER_A);
BtlController_EmitTrainerSlide(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8463,7 +8463,7 @@ static void Cmd_playse(void)
{
CMD_ARGS(u16 song);
BtlController_EmitPlaySE(gBattlerAttacker, BUFFER_A, cmd->song);
BtlController_EmitPlaySE(gBattlerAttacker, B_COMM_TO_CONTROLLER, cmd->song);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8473,7 +8473,7 @@ static void Cmd_fanfare(void)
{
CMD_ARGS(u16 song);
BtlController_EmitPlayFanfareOrBGM(gBattlerAttacker, BUFFER_A, cmd->song, FALSE);
BtlController_EmitPlayFanfareOrBGM(gBattlerAttacker, B_COMM_TO_CONTROLLER, cmd->song, FALSE);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8484,7 +8484,7 @@ static void Cmd_playfaintcry(void)
CMD_ARGS(u8 battler);
u32 battler = GetBattlerForBattleScript(cmd->battler);
BtlController_EmitFaintingCry(battler, BUFFER_A);
BtlController_EmitFaintingCry(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8495,7 +8495,7 @@ static void Cmd_endlinkbattle(void)
CMD_ARGS();
u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
BtlController_EmitEndLinkBattle(battler, BUFFER_A, gBattleOutcome);
BtlController_EmitEndLinkBattle(battler, B_COMM_TO_CONTROLLER, gBattleOutcome);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8506,7 +8506,7 @@ static void Cmd_returntoball(void)
CMD_ARGS(u8 battler, bool8 changingForm);
u32 battler = GetBattlerForBattleScript(cmd->battler);
BtlController_EmitReturnMonToBall(battler, BUFFER_A, TRUE);
BtlController_EmitReturnMonToBall(battler, B_COMM_TO_CONTROLLER, TRUE);
MarkBattlerForControllerExec(battler);
// Don't always execute a form change here otherwise we can stomp gigantamax
@ -8735,7 +8735,7 @@ static void Cmd_hitanimation(void)
|| !(DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove))
|| gDisableStructs[battler].substituteHP == 0)
{
BtlController_EmitHitAnimation(battler, BUFFER_A);
BtlController_EmitHitAnimation(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
}
}
@ -8753,7 +8753,7 @@ static void Cmd_hitanimation(void)
|| !(DoesSubstituteBlockMove(gBattlerAttacker, battlerDef, gCurrentMove))
|| gDisableStructs[battlerDef].substituteHP == 0)
{
BtlController_EmitHitAnimation(battlerDef, BUFFER_A);
BtlController_EmitHitAnimation(battlerDef, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battlerDef);
}
}
@ -8840,7 +8840,7 @@ static void Cmd_updatebattlermoves(void)
switch (gBattleCommunication[0])
{
case 0:
BtlController_EmitGetMonData(battler, BUFFER_A, REQUEST_ALL_BATTLE, 0);
BtlController_EmitGetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_ALL_BATTLE, 0);
MarkBattlerForControllerExec(battler);
gBattleCommunication[0]++;
break;
@ -8908,7 +8908,7 @@ static void Cmd_drawpartystatussummary(void)
}
}
BtlController_EmitDrawPartyStatusSummary(battler, BUFFER_A, hpStatuses, 1);
BtlController_EmitDrawPartyStatusSummary(battler, B_COMM_TO_CONTROLLER, hpStatuses, 1);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8919,7 +8919,7 @@ static void Cmd_hidepartystatussummary(void)
CMD_ARGS(u8 battler);
u32 battler = GetBattlerForBattleScript(cmd->battler);
BtlController_EmitHidePartyStatusSummary(battler, BUFFER_A);
BtlController_EmitHidePartyStatusSummary(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8963,7 +8963,7 @@ static void Cmd_statusanimation(void)
&& gDisableStructs[battler].substituteHP == 0
&& !(gHitMarker & (HITMARKER_NO_ANIMATIONS | HITMARKER_DISABLE_ANIMATION)))
{
BtlController_EmitStatusAnimation(battler, BUFFER_A, FALSE, gBattleMons[battler].status1);
BtlController_EmitStatusAnimation(battler, B_COMM_TO_CONTROLLER, FALSE, gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}
gBattlescriptCurrInstr = cmd->nextInstr;
@ -8982,7 +8982,7 @@ static void Cmd_status2animation(void)
&& gDisableStructs[battler].substituteHP == 0
&& !(gHitMarker & (HITMARKER_NO_ANIMATIONS | HITMARKER_DISABLE_ANIMATION)))
{
BtlController_EmitStatusAnimation(battler, BUFFER_A, TRUE, gBattleMons[battler].status2 & status2ToAnim);
BtlController_EmitStatusAnimation(battler, B_COMM_TO_CONTROLLER, TRUE, gBattleMons[battler].status2 & status2ToAnim);
MarkBattlerForControllerExec(battler);
}
gBattlescriptCurrInstr = cmd->nextInstr;
@ -9001,7 +9001,7 @@ static void Cmd_chosenstatusanimation(void)
&& gDisableStructs[battler].substituteHP == 0
&& !(gHitMarker & (HITMARKER_NO_ANIMATIONS | HITMARKER_DISABLE_ANIMATION)))
{
BtlController_EmitStatusAnimation(battler, BUFFER_A, cmd->isStatus2, wantedStatus);
BtlController_EmitStatusAnimation(battler, B_COMM_TO_CONTROLLER, cmd->isStatus2, wantedStatus);
MarkBattlerForControllerExec(battler);
}
gBattlescriptCurrInstr = cmd->nextInstr;
@ -9119,12 +9119,12 @@ static void BestowItem(u32 battlerAtk, u32 battlerDef)
gLastUsedItem = gBattleMons[battlerAtk].item;
gBattleMons[battlerAtk].item = ITEM_NONE;
BtlController_EmitSetMonData(battlerAtk, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerAtk].item), &gBattleMons[battlerAtk].item);
BtlController_EmitSetMonData(battlerAtk, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerAtk].item), &gBattleMons[battlerAtk].item);
MarkBattlerForControllerExec(battlerAtk);
CheckSetUnburden(battlerAtk);
gBattleMons[battlerDef].item = gLastUsedItem;
BtlController_EmitSetMonData(battlerDef, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerDef].item), &gBattleMons[battlerDef].item);
BtlController_EmitSetMonData(battlerDef, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerDef].item), &gBattleMons[battlerDef].item);
MarkBattlerForControllerExec(battlerDef);
gDisableStructs[battlerDef].unburdenActive = FALSE;
}
@ -9179,7 +9179,7 @@ static void Cmd_removeitem(void)
gBattleStruct->canPickupItem |= (1u << battler);
CheckSetUnburden(battler);
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battler].item), &gBattleMons[battler].item);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battler].item), &gBattleMons[battler].item);
MarkBattlerForControllerExec(battler);
ClearBattlerItemEffectHistory(battler);
@ -9501,7 +9501,7 @@ static void Cmd_makevisible(void)
return;
battler = GetBattlerForBattleScript(cmd->battler);
BtlController_EmitSpriteInvisibility(battler, BUFFER_A, FALSE);
BtlController_EmitSpriteInvisibility(battler, B_COMM_TO_CONTROLLER, FALSE);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -9976,7 +9976,7 @@ static void HandleScriptMegaPrimalBurst(u32 caseId, u32 battler, u32 type)
PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[battler].species);
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_SPECIES_BATTLE, 1u << gBattlerPartyIndexes[battler], sizeof(gBattleMons[battler].species), &gBattleMons[battler].species);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_SPECIES_BATTLE, 1u << gBattlerPartyIndexes[battler], sizeof(gBattleMons[battler].species), &gBattleMons[battler].species);
MarkBattlerForControllerExec(battler);
}
// Update healthbox and elevation and play cry.
@ -10474,7 +10474,7 @@ static void Cmd_various(void)
case VARIOUS_EMIT_YESNOBOX:
{
VARIOUS_ARGS();
BtlController_EmitYesNoBox(battler, BUFFER_A);
BtlController_EmitYesNoBox(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
break;
}
@ -10517,7 +10517,7 @@ static void Cmd_various(void)
battler = 1;
if (IsBattlerAlive(battler))
{
BtlController_EmitReturnMonToBall(battler, BUFFER_A, FALSE);
BtlController_EmitReturnMonToBall(battler, B_COMM_TO_CONTROLLER, FALSE);
MarkBattlerForControllerExec(battler);
}
break;
@ -10530,7 +10530,7 @@ static void Cmd_various(void)
battler = 3;
if (IsBattlerAlive(battler))
{
BtlController_EmitReturnMonToBall(battler, BUFFER_A, FALSE);
BtlController_EmitReturnMonToBall(battler, B_COMM_TO_CONTROLLER, FALSE);
MarkBattlerForControllerExec(battler);
}
}
@ -10588,7 +10588,7 @@ static void Cmd_various(void)
case VARIOUS_PLAY_TRAINER_DEFEATED_MUSIC:
{
VARIOUS_ARGS();
BtlController_EmitPlayFanfareOrBGM(battler, BUFFER_A, MUS_VICTORY_TRAINER, TRUE);
BtlController_EmitPlayFanfareOrBGM(battler, B_COMM_TO_CONTROLLER, MUS_VICTORY_TRAINER, TRUE);
MarkBattlerForControllerExec(battler);
break;
}
@ -10610,7 +10610,7 @@ static void Cmd_various(void)
case VARIOUS_INSTANT_HP_DROP:
{
VARIOUS_ARGS();
BtlController_EmitHealthBarUpdate(battler, BUFFER_A, INSTANT_HP_BAR_DROP);
BtlController_EmitHealthBarUpdate(battler, B_COMM_TO_CONTROLLER, INSTANT_HP_BAR_DROP);
MarkBattlerForControllerExec(battler);
break;
}
@ -10618,7 +10618,7 @@ static void Cmd_various(void)
{
VARIOUS_ARGS();
gBattleMons[battler].status1 = 0;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
break;
}
@ -10631,7 +10631,7 @@ static void Cmd_various(void)
data[i] = gBattleMons[battler].pp[i];
}
data[i] = gBattleMons[battler].ppBonuses;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_PP_DATA_BATTLE, 0, 5, data);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_PP_DATA_BATTLE, 0, 5, data);
MarkBattlerForControllerExec(battler);
break;
}
@ -10762,7 +10762,7 @@ static void Cmd_various(void)
case VARIOUS_PLAY_MOVE_ANIMATION:
{
VARIOUS_ARGS(u16 move);
BtlController_EmitMoveAnimation(battler, BUFFER_A, cmd->move, gBattleScripting.animTurn, 0, 0, gBattleMons[battler].friendship, &gDisableStructs[battler], gMultiHitCounter);
BtlController_EmitMoveAnimation(battler, B_COMM_TO_CONTROLLER, cmd->move, gBattleScripting.animTurn, 0, 0, gBattleMons[battler].friendship, &gDisableStructs[battler], gMultiHitCounter);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
return;
@ -10947,7 +10947,7 @@ static void Cmd_various(void)
if (!gBattleTextBuff1)
PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[battler].species);
*/
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_SPECIES_BATTLE, 1u << gBattlerPartyIndexes[battler], sizeof(gBattleMons[battler].species), &gBattleMons[battler].species);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_SPECIES_BATTLE, 1u << gBattlerPartyIndexes[battler], sizeof(gBattleMons[battler].species), &gBattleMons[battler].species);
MarkBattlerForControllerExec(battler);
}
// Change stats.
@ -11096,7 +11096,7 @@ static void Cmd_various(void)
}
gBattleMons[gBattlerTarget].status1 = gBattleMons[gBattlerAttacker].status1 & STATUS1_ANY;
battler = gBattlerTarget;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
TryActivateSleepClause(battler, gBattlerPartyIndexes[battler]);
@ -11110,7 +11110,7 @@ static void Cmd_various(void)
TryDeactivateSleepClause(GetBattlerSide(battler), gBattlerPartyIndexes[battler]);
gBattleMons[battler].status1 = 0;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
break;
}
@ -11167,7 +11167,7 @@ static void Cmd_various(void)
VARIOUS_ARGS(u8 case_);
if (cmd->case_ == PRINT_SLIDE_MESSAGE)
{
BtlController_EmitPrintString(battler, BUFFER_A, STRINGID_TRAINERSLIDE);
BtlController_EmitPrintString(battler, B_COMM_TO_CONTROLLER, STRINGID_TRAINERSLIDE);
MarkBattlerForControllerExec(battler);
}
else if (cmd->case_ == RESTORE_BATTLER_SLIDE_CONTROL)
@ -11352,7 +11352,7 @@ static void Cmd_various(void)
if (gBattleControllerExecFlags)
break;
BtlController_EmitSpriteInvisibility(battler, BUFFER_A, TRUE);
BtlController_EmitSpriteInvisibility(battler, B_COMM_TO_CONTROLLER, TRUE);
MarkBattlerForControllerExec(battler);
break;
}
@ -11933,7 +11933,7 @@ static void Cmd_tryexplosion(void)
return;
gBattleStruct->moveDamage[gBattlerAttacker] = gBattleMons[gBattlerAttacker].hp;
BtlController_EmitHealthBarUpdate(gBattlerAttacker, BUFFER_A, INSTANT_HP_BAR_DROP);
BtlController_EmitHealthBarUpdate(gBattlerAttacker, B_COMM_TO_CONTROLLER, INSTANT_HP_BAR_DROP);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
}
@ -11946,7 +11946,7 @@ static void Cmd_setatkhptozero(void)
return;
gBattleMons[gBattlerAttacker].hp = 0;
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].hp), &gBattleMons[gBattlerAttacker].hp);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].hp), &gBattleMons[gBattlerAttacker].hp);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -12179,7 +12179,7 @@ static void Cmd_trysetrest(void)
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_REST;
gBattleMons[gBattlerTarget].status1 = STATUS1_SLEEP_TURN(3);
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
MarkBattlerForControllerExec(gBattlerTarget);
gBattlescriptCurrInstr = cmd->nextInstr;
}
@ -13264,7 +13264,7 @@ static void Cmd_updatestatusicon(void)
{
if (!(gAbsentBattlerFlags & (1u << battler)))
{
BtlController_EmitStatusIconUpdate(battler, BUFFER_A, gBattleMons[battler].status1, gBattleMons[battler].status2);
BtlController_EmitStatusIconUpdate(battler, B_COMM_TO_CONTROLLER, gBattleMons[battler].status1, gBattleMons[battler].status2);
MarkBattlerForControllerExec(battler);
}
}
@ -13275,7 +13275,7 @@ static void Cmd_updatestatusicon(void)
battler = gBattlerAttacker;
if (!(gAbsentBattlerFlags & (1u << battler)))
{
BtlController_EmitStatusIconUpdate(battler, BUFFER_A, gBattleMons[battler].status1, gBattleMons[battler].status2);
BtlController_EmitStatusIconUpdate(battler, B_COMM_TO_CONTROLLER, gBattleMons[battler].status1, gBattleMons[battler].status2);
MarkBattlerForControllerExec(battler);
}
if ((IsDoubleBattle()))
@ -13283,7 +13283,7 @@ static void Cmd_updatestatusicon(void)
battler = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerAttacker)));
if (!(gAbsentBattlerFlags & (1u << battler)))
{
BtlController_EmitStatusIconUpdate(battler, BUFFER_A, gBattleMons[battler].status1, gBattleMons[battler].status2);
BtlController_EmitStatusIconUpdate(battler, B_COMM_TO_CONTROLLER, gBattleMons[battler].status1, gBattleMons[battler].status2);
MarkBattlerForControllerExec(battler);
}
}
@ -13292,7 +13292,7 @@ static void Cmd_updatestatusicon(void)
else
{
battler = GetBattlerForBattleScript(cmd->battler);
BtlController_EmitStatusIconUpdate(battler, BUFFER_A, gBattleMons[battler].status1, gBattleMons[battler].status2);
BtlController_EmitStatusIconUpdate(battler, B_COMM_TO_CONTROLLER, gBattleMons[battler].status1, gBattleMons[battler].status2);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
}
@ -13397,7 +13397,7 @@ static void Cmd_transformdataexecution(void)
RecordAllMoves(gBattlerAttacker);
RecordAbilityBattle(gBattlerAttacker, gBattleMons[gBattlerAttacker].ability);
BtlController_EmitResetActionMoveSelection(gBattlerAttacker, BUFFER_A, RESET_MOVE_SELECTION);
BtlController_EmitResetActionMoveSelection(gBattlerAttacker, B_COMM_TO_CONTROLLER, RESET_MOVE_SELECTION);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_TRANSFORMED;
}
@ -13863,7 +13863,7 @@ static void Cmd_copymovepermanently(void)
}
movePpData.ppBonuses = gBattleMons[gBattlerAttacker].ppBonuses;
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_MOVES_PP_BATTLE, 0, sizeof(movePpData), &movePpData);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_MOVES_PP_BATTLE, 0, sizeof(movePpData), &movePpData);
MarkBattlerForControllerExec(gBattlerAttacker);
PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastPrintedMoves[gBattlerTarget])
@ -14043,7 +14043,7 @@ static void Cmd_tryspiteppreduce(void)
if (!(gDisableStructs[gBattlerTarget].mimickedMoves & (1u << i))
&& !(gBattleMons[gBattlerTarget].status2 & STATUS2_TRANSFORMED))
{
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[gBattlerTarget].pp[i]), &gBattleMons[gBattlerTarget].pp[i]);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[gBattlerTarget].pp[i]), &gBattleMons[gBattlerTarget].pp[i]);
MarkBattlerForControllerExec(gBattlerTarget);
}
@ -14154,7 +14154,7 @@ static void Cmd_healpartystatus(void)
if (toHeal)
{
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, toHeal, sizeof(zero), &zero);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, toHeal, sizeof(zero), &zero);
MarkBattlerForControllerExec(gBattlerAttacker);
}
@ -14840,7 +14840,7 @@ static void Cmd_trymemento(void)
{
// Success, drop user's HP bar to 0
gBattleStruct->moveDamage[gBattlerAttacker] = gBattleMons[gBattlerAttacker].hp;
BtlController_EmitHealthBarUpdate(gBattlerAttacker, BUFFER_A, INSTANT_HP_BAR_DROP);
BtlController_EmitHealthBarUpdate(gBattlerAttacker, B_COMM_TO_CONTROLLER, INSTANT_HP_BAR_DROP);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
}
@ -14922,7 +14922,7 @@ static void Cmd_curestatuswithmove(void)
gBattleMons[gBattlerAttacker].status1 = 0;
gBattlescriptCurrInstr = cmd->nextInstr;
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].status1), &gBattleMons[gBattlerAttacker].status1);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].status1), &gBattleMons[gBattlerAttacker].status1);
MarkBattlerForControllerExec(gBattlerAttacker);
}
else
@ -15081,10 +15081,10 @@ static void Cmd_tryswapitems(void)
RecordItemEffectBattle(gBattlerAttacker, 0);
RecordItemEffectBattle(gBattlerTarget, ItemId_GetHoldEffect(oldItemAtk));
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(*newItemAtk), newItemAtk);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(*newItemAtk), newItemAtk);
MarkBattlerForControllerExec(gBattlerAttacker);
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[gBattlerTarget].item);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[gBattlerTarget].item);
MarkBattlerForControllerExec(gBattlerTarget);
gBattleStruct->choicedMove[gBattlerTarget] = MOVE_NONE;
@ -15524,7 +15524,7 @@ static void Cmd_switchoutabilities(void)
TryDeactivateSleepClause(GetBattlerSide(battler), gBattlerPartyIndexes[battler]);
gBattleMons[battler].status1 = 0;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE,
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE,
1u << gBattleStruct->battlerPartyIndexes[battler],
sizeof(gBattleMons[battler].status1),
&gBattleMons[battler].status1);
@ -15536,7 +15536,7 @@ static void Cmd_switchoutabilities(void)
regenerate += gBattleMons[battler].hp;
if (regenerate > gBattleMons[battler].maxHP)
regenerate = gBattleMons[battler].maxHP;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HP_BATTLE,
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_HP_BATTLE,
1u << gBattleStruct->battlerPartyIndexes[battler],
sizeof(regenerate),
&regenerate);
@ -15764,7 +15764,7 @@ static void Cmd_tryrecycleitem(void)
*usedHeldItem = ITEM_NONE;
gBattleMons[gBattlerAttacker].item = gLastUsedItem;
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].item), &gBattleMons[gBattlerAttacker].item);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].item), &gBattleMons[gBattlerAttacker].item);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -15913,13 +15913,13 @@ static void Cmd_handleballthrow(void)
if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
{
BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, BALL_TRAINER_BLOCK);
BtlController_EmitBallThrowAnim(gBattlerAttacker, B_COMM_TO_CONTROLLER, BALL_TRAINER_BLOCK);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = BattleScript_TrainerBallBlock;
}
else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL)
{
BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, BALL_3_SHAKES_SUCCESS);
BtlController_EmitBallThrowAnim(gBattlerAttacker, B_COMM_TO_CONTROLLER, BALL_3_SHAKES_SUCCESS);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattlescriptCurrInstr = BattleScript_WallyBallThrow;
}
@ -16122,7 +16122,7 @@ static void Cmd_handleballthrow(void)
if (odds > 254) // mon caught
{
BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, BALL_3_SHAKES_SUCCESS);
BtlController_EmitBallThrowAnim(gBattlerAttacker, B_COMM_TO_CONTROLLER, BALL_3_SHAKES_SUCCESS);
MarkBattlerForControllerExec(gBattlerAttacker);
TryBattleFormChange(gBattlerTarget, FORM_CHANGE_END_BATTLE);
gBattlescriptCurrInstr = BattleScript_SuccessBallThrow;
@ -16175,7 +16175,7 @@ static void Cmd_handleballthrow(void)
for (shakes = 0; shakes < maxShakes && Random() < odds; shakes++);
}
BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, shakes);
BtlController_EmitBallThrowAnim(gBattlerAttacker, B_COMM_TO_CONTROLLER, shakes);
MarkBattlerForControllerExec(gBattlerAttacker);
if (shakes == maxShakes) // mon caught, copy of the code above
@ -16284,7 +16284,7 @@ static void Cmd_givecaughtmon(void)
case GIVECAUGHTMON_DO_CHOOSE_MON:
if (!gPaletteFade.active)
{
BtlController_EmitChoosePokemon(gBattlerAttacker, BUFFER_A, PARTY_ACTION_SEND_MON_TO_BOX, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gBattlerAttacker]);
BtlController_EmitChoosePokemon(gBattlerAttacker, B_COMM_TO_CONTROLLER, PARTY_ACTION_SEND_MON_TO_BOX, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gBattlerAttacker]);
MarkBattlerForControllerExec(gBattlerAttacker);
gBattleCommunication[MULTIUSE_STATE] = GIVECAUGHTMON_HANDLE_CHOSEN_MON;
}
@ -16613,7 +16613,7 @@ static void Cmd_trainerslideout(void)
CMD_ARGS(u8 position);
u32 battler = GetBattlerForBattleScript(cmd->position);
BtlController_EmitTrainerSlideBack(battler, BUFFER_A);
BtlController_EmitTrainerSlideBack(battler, B_COMM_TO_CONTROLLER);
MarkBattlerForControllerExec(battler);
gBattlescriptCurrInstr = cmd->nextInstr;
@ -18363,7 +18363,7 @@ void BS_TryRevivalBlessing(void)
struct Pokemon *party = GetSideParty(side);
u16 hp = GetMonData(&party[gSelectedMonPartyId], MON_DATA_MAX_HP) / 2;
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HP_BATTLE, 1u << gSelectedMonPartyId, sizeof(hp), &hp);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_HP_BATTLE, 1u << gSelectedMonPartyId, sizeof(hp), &hp);
MarkBattlerForControllerExec(gBattlerAttacker);
PREPARE_SPECIES_BUFFER(gBattleTextBuff1, GetMonData(&party[gSelectedMonPartyId], MON_DATA_SPECIES));
@ -18384,7 +18384,7 @@ void BS_TryRevivalBlessing(void)
else
{
// Open party menu, wait to go to next instruction.
BtlController_EmitChoosePokemon(gBattlerAttacker, BUFFER_A, PARTY_ACTION_CHOOSE_FAINTED_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gBattlerAttacker]);
BtlController_EmitChoosePokemon(gBattlerAttacker, B_COMM_TO_CONTROLLER, PARTY_ACTION_CHOOSE_FAINTED_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gBattlerAttacker]);
MarkBattlerForControllerExec(gBattlerAttacker);
}
}
@ -18423,7 +18423,7 @@ static void UpdatePokeFlutePartyStatus(struct Pokemon* party, u8 position)
{
battler = GetBattlerAtPosition(position);
status = 0;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, monToCheck, 4, &status);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, monToCheck, 4, &status);
MarkBattlerForControllerExec(battler);
gBattleCommunication[MULTISTRING_CHOOSER] = 1;
}
@ -18624,7 +18624,7 @@ static void TrySetParalysis(const u8 *nextInstr, const u8 *failInstr)
gBattleMons[gBattlerTarget].status1 |= STATUS1_PARALYSIS;
gBattleCommunication[MULTISTRING_CHOOSER] = 3;
gEffectBattler = gBattlerTarget;
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
MarkBattlerForControllerExec(gBattlerTarget);
gBattlescriptCurrInstr = nextInstr;
}
@ -18641,7 +18641,7 @@ static void TrySetPoison(const u8 *nextInstr, const u8 *failInstr)
gBattleMons[gBattlerTarget].status1 |= STATUS1_POISON;
gBattleCommunication[MULTISTRING_CHOOSER] = 0;
gEffectBattler = gBattlerTarget;
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
MarkBattlerForControllerExec(gBattlerTarget);
gBattlescriptCurrInstr = nextInstr;
}
@ -18663,7 +18663,7 @@ static void TrySetSleep(const u8 *nextInstr, const u8 *failInstr)
TryActivateSleepClause(gBattlerTarget, gBattlerPartyIndexes[gBattlerTarget]);
gBattleCommunication[MULTISTRING_CHOOSER] = 4;
gEffectBattler = gBattlerTarget;
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1);
MarkBattlerForControllerExec(gBattlerTarget);
gBattlescriptCurrInstr = nextInstr;
}
@ -18817,7 +18817,7 @@ void BS_TryRecycleBerry(void)
*usedHeldItem = ITEM_NONE;
gBattleMons[gBattlerTarget].item = gLastUsedItem;
BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[gBattlerTarget].item);
BtlController_EmitSetMonData(gBattlerTarget, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[gBattlerTarget].item);
MarkBattlerForControllerExec(gBattlerTarget);
gBattlescriptCurrInstr = cmd->nextInstr;

30
src/battle_util.c
View File

@ -1148,7 +1148,7 @@ void PrepareStringBattle(u16 stringId, u32 battler)
if ((stringId == STRINGID_ITDOESNTAFFECT || stringId == STRINGID_PKMNWASNTAFFECTED || stringId == STRINGID_PKMNUNAFFECTED))
TryInitializeTrainerSlideEnemyMonUnaffected(gBattlerTarget);
BtlController_EmitPrintString(battler, BUFFER_A, stringId);
BtlController_EmitPrintString(battler, B_COMM_TO_CONTROLLER, stringId);
MarkBattlerForControllerExec(battler);
}
@ -2580,7 +2580,7 @@ u8 DoBattlerEndTurnEffects(void)
gBattleMons[gBattlerAttacker].status2 &= ~STATUS2_NIGHTMARE;
gBattleCommunication[MULTISTRING_CHOOSER] = 1;
BattleScriptExecute(BattleScript_MonWokeUpInUproar);
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerAttacker].status1);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerAttacker].status1);
MarkBattlerForControllerExec(gBattlerAttacker);
break;
}
@ -2737,7 +2737,7 @@ u8 DoBattlerEndTurnEffects(void)
gBattleMons[battler].status1 |= ((Random() % 4) + 3);
TryActivateSleepClause(battler, gBattlerPartyIndexes[battler]);
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
BattleScriptExecute(BattleScript_YawnMakesAsleep);
}
@ -2909,7 +2909,7 @@ u8 DoBattlerEndTurnEffects(void)
if (IsBattlerAlive(battler) && gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SEA_OF_FIRE)
{
gBattleStruct->moveDamage[battler] = GetNonDynamaxMaxHP(battler) / 8;
BtlController_EmitStatusAnimation(battler, BUFFER_A, FALSE, STATUS1_BURN);
BtlController_EmitStatusAnimation(battler, B_COMM_TO_CONTROLLER, FALSE, STATUS1_BURN);
MarkBattlerForControllerExec(battler);
BattleScriptExecute(BattleScript_HurtByTheSeaOfFire);
effect++;
@ -3870,7 +3870,7 @@ u32 AtkCanceller_MoveSuccessOrder(void)
if (effect == 2)
{
BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerAttacker].status1);
BtlController_EmitSetMonData(gBattlerAttacker, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerAttacker].status1);
MarkBattlerForControllerExec(gBattlerAttacker);
}
@ -5396,7 +5396,7 @@ u32 AbilityBattleEffects(u32 caseID, u32 battler, u32 ability, u32 special, u32
if (gBattleMons[battler].status2 & STATUS2_CONFUSION
&& !(gStatuses4[battler] & STATUS4_INFINITE_CONFUSION))
gBattleMons[battler].status2 -= STATUS2_CONFUSION_TURN(1);
BtlController_EmitSpriteInvisibility(battler, BUFFER_A, TRUE);
BtlController_EmitSpriteInvisibility(battler, B_COMM_TO_CONTROLLER, TRUE);
MarkBattlerForControllerExec(battler);
BattleScriptPushCursorAndCallback(BattleScript_CommanderActivates);
effect++;
@ -5480,7 +5480,7 @@ u32 AbilityBattleEffects(u32 caseID, u32 battler, u32 ability, u32 special, u32
gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE;
gBattleScripting.battler = battler;
BattleScriptPushCursorAndCallback(BattleScript_ShedSkinActivates);
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
effect++;
}
@ -5573,7 +5573,7 @@ u32 AbilityBattleEffects(u32 caseID, u32 battler, u32 ability, u32 special, u32
&& !gHasFetchedBall)
{
gBattleScripting.battler = battler;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, 2, &gLastUsedBall);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_HELDITEM_BATTLE, 0, 2, &gLastUsedBall);
MarkBattlerForControllerExec(battler);
gHasFetchedBall = TRUE;
gLastUsedItem = gLastUsedBall;
@ -6428,7 +6428,7 @@ u32 AbilityBattleEffects(u32 caseID, u32 battler, u32 ability, u32 special, u32
}
gBattleScripting.battler = gBattlerAbility = battler;
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
return effect;
}
@ -7222,7 +7222,7 @@ static u32 ItemRestorePp(u32 battler, u32 itemId, enum ItemCaseId caseID)
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BerryPPHealRet;
}
BtlController_EmitSetMonData(battler, BUFFER_A, i + REQUEST_PPMOVE1_BATTLE, 0, 1, &changedPP);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, i + REQUEST_PPMOVE1_BATTLE, 0, 1, &changedPP);
MarkBattlerForControllerExec(battler);
if (MOVE_IS_PERMANENT(battler, i))
gBattleMons[battler].pp[i] = changedPP;
@ -7885,7 +7885,7 @@ u32 ItemBattleEffects(enum ItemCaseId caseID, u32 battler, bool32 moveTurn)
gBattlerAttacker = gPotentialItemEffectBattler = gBattleScripting.battler = battler;
if (effect == ITEM_STATUS_CHANGE)
{
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}
}
@ -8085,7 +8085,7 @@ u32 ItemBattleEffects(enum ItemCaseId caseID, u32 battler, bool32 moveTurn)
gBattlerAttacker = gPotentialItemEffectBattler = gBattleScripting.battler = battler;
if (effect == ITEM_STATUS_CHANGE)
{
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}
}
@ -8099,7 +8099,7 @@ u32 ItemBattleEffects(enum ItemCaseId caseID, u32 battler, bool32 moveTurn)
gPotentialItemEffectBattler = gBattleScripting.battler = battler;
if (effect == ITEM_STATUS_CHANGE)
{
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}
break;
@ -8115,7 +8115,7 @@ u32 ItemBattleEffects(enum ItemCaseId caseID, u32 battler, bool32 moveTurn)
gPotentialItemEffectBattler = gBattleScripting.battler = battler;
if (effect == ITEM_STATUS_CHANGE)
{
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}
break;
@ -8427,7 +8427,7 @@ u32 ItemBattleEffects(enum ItemCaseId caseID, u32 battler, bool32 moveTurn)
if (effect == ITEM_STATUS_CHANGE)
{
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}
}

2
src/battle_util2.c
View File

@ -206,7 +206,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battler)
if (effect == 2)
{
BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
BtlController_EmitSetMonData(battler, B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(battler);
}